day15、了解类和方法 2019-01-11
一、编程思想
1.面向过程编程：遇到问题直接将算法和逻辑转换成代码。
2.函数式编程：遇到问题就找一个或者写一个拥有相应功能的函数。以2函数作为工具。
3.面向对象编程：遇到问题就考虑可不可以有一个类，来给我提供相应的功能和数据。以类和对象为编程工具。
python 既支持函数式编程，也支持面向对象编程。
二、认识类和对象（声明）
1.什么是类，什么是对象
类就是拥有相同功能和相同属性的对象和集合；类是抽象的。
对象就是类的示例；对象是具体的。
仓鼠是类，小白就是仓鼠的对象。
2.类的声明
类里面的内容包含：功能（函数）、属性（变量/代码）
a.语法：
class 类名(父类):
类的内容
b.说明：
class -----python 声明类的关键字
类名 -----要求：为标识符，不能是关键字。
规范驼峰式命名（通过首字母大写来区分不同的单词）；第一个字母要大写
: -----固定写法
类的内容 -----包含类的方法、属性和说明文档。
方法就是声明在类里面的函数。
属性就是声明在类里面的变量。
3.对象的声明
语法：
类名（） -----创建指定类的对象
例如：
class Persen:
"""类的说明文档：人类"""
people_num = 180000000 # 类中的属性
def eat(self):
'''类中的方法'''
print('人都会吃饭。')
def main():
# 创建 Person 类的对象；p1 就是对象
p1 = Persen()
print(p1)
# 同一个类可以声明多个变量
p2 = Persen()
print(p1)
p3 = p2
print(p1)
if __name__ == '__main__':
main()
运行结果：
<__main__.Persen object at 0x000001C19002B780>
<__main__.Persen object at 0x000001C19002B780>
<__main__.Persen object at 0x000001C19002B780>
三、对象方法
class 类名:
类中的属性
类中的方法
1.类中的方法
声明在类中的函数就是方法
类中的函数包括：对象方法（实例方法）、类方法、静态方法
2.对象方法
a.什么是对象方法：
（1）直接声明在类里面的方法就是对象方法
（2）有默认参数 self 。
（3）调用时，通过 '对象.方法' 的方式来调用（对象方法要通过对象来调用）
b.参数 self ：
（1）当我们通过对象调用对象方法时，self 不需要传参，因为系统会自动将当期对象传递给 self 。
（2）什么是当前对象：调用当前方法的对象（谁调用对象方法， self 就是谁）。
注意：在当前类，对象能做的事情，self 都能做。
例如：
class Person:
# 声明类时，类里面的内容会执行
print('=================')
def run(self):
print('self:', self)
print('人会跑，马会跳，老猪会睡觉')
def eat(self, food):
self.run()
print('self2:', self)
print(food)
def main():
# 创建对象
p1 = Person()
# 通过对象调用对象方法
print('p1:', p1)
p1.run()
# 调用对象方法只需要给出了 self 以外的其它参数就需要传参
p1.eat('I love CD.')
p2 = Person()
print('p2:', p2)
if __name__ == '__main__':
main()
运行结果：
=================
p1: <__main__.Person object at 0x000001593827B940>
self: <__main__.Person object at 0x000001593827B940>
人会跑，马会跳，老猪会睡觉
self: <__main__.Person object at 0x000001593827B940>
人会跑，马会跳，老猪会睡觉
self2: <__main__.Person object at 0x000001593827B940>
I love CD.
p2: <__main__.Person object at 0x000001593827B908>
四、init 方法和 构造（construction）方法
1.init 方法：init
a.init 方法是类中的一个特殊的方法，专门用来对象创建的对象进行初始化。
b.当通过类创建对象的时候，系统会自动调用 init 方法。
2.构造方法
a.函数名和类名一样的函数就是构造方法，专门用来创建对象。
b.python 中声明类的时候，系统会自动创建这个类创建的构造方法。
c.当我们用构造方法创建对象的时候，内部都会先在内存中开辟空间保存对象，
然后用创建的这个对象去调用 __init__ 方法，用来对对象进行初始化。
__init__ 方法调用结束后，返回对象。
注意：如果类的 __init__ 方法除了 self 以外还有其他参数，
那么在创建对象的时候，需要通过给构造方法来给 __init__ 方法传参。
例如：
# 创建一个类
class Dog:
def __init__(self, x, y):
print(x, y)
print('dog 的 init')
# 创建一个类
class Person:
# 类中，以‘__’开头，并且，以‘__’结尾的方法叫魔法方法。不需要主动调用，系统会自动调用。
def __init__(self):
print('init 被调用咯')
def main():
# 创建对象的时候就会调用 __init__ 方法
p1 = Person()
# 创建一次，调用一次 __init__ 方法
p2 = Person()
# 构造一个 dog1 方法（构造方法）
dog1 = Dog(50, 100)
# print('dog1:', dog1)
if __name__ == '__main__':
main()
运行结果：
init 被调用咯
init 被调用咯
50 100
dog 的 init
五、对象属性
1.什么是对象属性
类中的属性分为类的字段和对象属性
a.对象属性 -----属性的值会因为对象的不同而不一样，这种属于就应该声明为对象属性。
（1）声明在 init 方法中。
（2）以 'self.属性 = 值' 的方式来声明（这里的属性就是对象属性）。 -----方式
（3）通过 '对象.属性' 的方式来使用。 -----使用
b.类的字段 -----属性的值不会因为对象的不同而不同，这种属性就可以声明成类的字段。
（1）直接声明在类中，函数外面的变量就是类的字段。
（2）以 '变量名 = 值' 的方式来声明。
（3）通过 '类.字段' 的方式来使用。
例如：
class JuXing:
num1 = 50
def __init__(self, chang, kuan):
self.chang = chang
self.kuan = kuan
def mian_ji(self):
mian_ji = self.chang * self.kuan
print('面积为：', mian_ji, ' m^2')
def zhou_chang(self):
zhou_chang = (self.chang + self.kuan) * 2
print('周长为：', zhou_chang, ' m')
class Dog:
def __init__(self, name1, type1='萨摩耶'):
self.age = 3
self.name = name1
self.type = type1
def eat(self, food):
print('%s 在吃 %s' % (self.name, food))
class Person:
def __init__(self, name1='', age1=3):
# name 和 age 就是对象属性。
self.name = name1
self.age = age1
def main():
print(JuXing.num1)
p1 = Person('泷泽萝拉', 23)
# 获取对象属性的值。
print(p1.name, p1.age)
p2 = Person('阿西吧', 28)
# 修改对象属性的值。
p2.name = '苍井空'
print(p2.name, p2.age)
dog1 = Dog('阿黄')
dog1.eat('筎')
dog2 = Dog('大白', '土狗')
print(dog2.name, dog2.type)
p3 = JuXing(2, 3)
p3.mian_ji()
p3.zhou_chang()
if __name__ == '__main__':
main()
运行结果：
50
泷泽萝拉 23
苍井空 28
阿黄 在吃 筎
大白 土狗
面积为： 6 m^2
周长为： 10 m
六、对象属性的增删改查
python 中对象的属性支持增删改查
1.查（获取对象属性）
对象.属性 -----获取指定对象指定属性值；当属性不存在的时候，会报错。
getattr(对象, 属性名：str, 默认值) -----获取指定对象指定属性值；当属性不存在的时候，没赋默认值，会报错；
如果给默认值属性赋了值，程序不会报错，并且将默认值作为结果。
2.增/改
对象.属性 = 值 -----当属性存在的时候，就是修改属性的值；当属性不存在的时候，就是添加属性的值；
setattr(对象, 属性名, 值)
3.删除
del 对象.属性
delattr(对象.属性名)
4. slots 魔法
约束类里面的属性的多少，可以删除，添加的不在后面的范围内就加不了。
建议不用
例如：
class Dog:
# 约束当前类的对象最多能拥有哪些个属性
# __slots__ = ('name', 'color')
def __init__(self, name='', color='黑'):
self.name = name
self.color = color
# 属性的增删改查
class Person:
def __init__(self, name='哈哈哈', age=0, sex='男'):
self.name = name
self.age = age
self.sex = sex
def main():
dog1 = Dog('阿黄', '黄色')
dog1.age = 2
dog1.name = '客家话'
dog1.name1 = 'hhh'
p1 = Person()
p2 = Person()
# 1.查
# 对象.属性 -----获取指定对象指定属性值；当属性不存在的时候，会报错。
# getattr(对象, 属性名：str, 默认值) -----获取指定对象指定属性值；当属性不存在的时候，没赋默认值，会报错；
# 如果给默认值属性赋了值，程序不会报错，并且将默认值作为结果。
print(p1.name)
attr = input('属性：')
print(getattr(p1, attr))
# 属性不确定时，可以使用 getattr
print(getattr(p1, 'name', None))
print(getattr(p1, 'name1', None))
# 2.增/改
p1.name = 'xiaohua'
print(p1.name)
p1.height = 180
print(p1.height)
setattr(p1, 'age', 18)
print(p1.age)
setattr(p1, 'weight', 72)
print(p1.weight)
# 3.删除
del p1.sex
delattr(p1, 'age')
# 删除后用不了
# 注意：对象属性的操作，只针对操作的那一个对象，不会影响其他对象。
print(p2.age)
if __name__ == '__main__':
main()
运行结果：
哈哈哈
属性：name
哈哈哈
哈哈哈
None
xiaohua
180
18
72
0
七、内置属性
内置属性指的是我们创建类的时候系统自动给我们添加的属性（其实是通过继承获取到的）
1. name
类.name -----获取类的名字，返回值是一个字符串。
2.class
对象.class -----获取对象对应的类（结果是类）。
3.doc
类.doc -----获取类的说明文档(结果是字符串)
4.dict
对象.dict -----将对象转换成字典。将属性和值转换成字典键值对。
注意：当给 slots 属性赋值后，对象的 dict 属性就不能用
5.module
类.module -----获取当前类所在的模块的模块名。
6.bases
类.bases -----获取当前类的父类。
例如：
class Person:
num1 = 50
# __slots__ = ('name', 'age', 'sex')
def __init__(self, name='', age=0, sex='男'):
self.name = name
self.age = age
self.sex = sex
def eat(self, food):
print(self.name, '在吃', food)
# 定制对象的打印格式（当我们通过 print 打印一个对象的时候，实质就是打印对象调用 __repr__ 函数）
# 这个函数的返回值必须是字符串
def __repr__(self):
return '{ %s.%s at %s}' % (self.__class__.__module__, self.__class__.__name__, hex(id(self)))
def main():
# 获取类的名字，返回值是一个字符串
p1 = Person('xiaoming', 18)
print(Person)
class_name = Person.__name__
print(Person, class_name)
print(class_name.upper())
my_class = p1.__class__
# 获取对象对应的类（结果是类）。
print(my_class)
p2 = my_class
print(my_class.num1)
print(Person.__doc__)
print(float.__doc__)
# 获取对象 p1 的说明文档
print(p1.__class__.__doc__)
# 将对象转换成字典。将属性和值转换成字典键值对。
print(p1.__dict__)
print(Person.__dict__)
# 获取当前类所在的模块的模块名。
print(Person.__module__)
# 获取当前类的父类。
print(Person.__bases__) # (<class 'object'>,)
if __name__ == '__main__':
main()
运行结果：
<class '__main__.Person'>
<class '__main__.Person'> Person
PERSON
<class '__main__.Person'>
50
None
float(x) -> floating point number
Convert a string or number to a floating point number, if possible.
None
{'name': 'xiaoming', 'age': 18, 'sex': '男'}
{'__module__': '__main__', 'num1': 50, '__init__': <function Person.__init__ at 0x000002235D01D7B8>, 'eat': <function Person.eat at 0x000002235D01D840>, '__repr__': <function Person.__repr__ at 0x000002235D01D8C8>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}
__main__
(<class 'object'>,)
八、类方法和静态方法
1.对象方法
a.怎么声明：直接声明在类型。
b.特点：自带 self 参数，调用的时候不用传参，谁调用指向谁。
c.怎么调用：对象.方法
2.类方法：
a.怎么声明：声明函数前加 @classmethod
b.特点：自带默认参数 cls；调用的时候不用传参，系统会自动将调用当前函数的类传给它。
c.怎么调用：通过类来调用； 类.方法
（cls 是谁调用就指向谁，类方法只能通过类来调用，所以 cls 就是一个类）
（类能做的事，cls 都能做）
3.静态方法
a.怎么声明：声明函数前加 @staticmethod
b.特点：没有默认参数
c.怎么调用：通过类来调用； 类.方法
4.在类中怎么选择使用哪种方法
a.如果实现类中函数的功能需要使用对象的属性，就使用对象方法。
b.实现函数的功能时，不需要对象属性的前提下，如果需要类的字段，就使用类方法。
c.实现函数的功能时，既不需要使用对象属性，也不需要类的字段，就声明成静态方法。
例如：
class Person:
num1 = 50
@staticmethod
def func3():
print('静态方法')
@classmethod
def func1(cls):
# 类能做的，cls 都能做
p1 = cls()
print(p1) # 用 cls 来创建对象
cls.num1 = 1000 # 用 cls 来使用类的字段
cls.func2() # 用 cls 来调用类方法
print('cls:', cls)
print('这是一个类方法')
@classmethod
def func2(cls):
print('这是方法二。')
def main():
print(Person)
Person.func1()
Person.func3()
if __name__ == '__main__':
main()
运行结果：
<class '__main__.Person'>
<__main__.Person object at 0x00000256CAC6B8D0>
这是方法二。
cls: <class '__main__.Person'>
这是一个类方法
静态方法
