一、构造函数和析构函数
1 class Person:
2 def __init__(self): #构造函数 类在实例化的时候自动调用的方法
3 self.__base_price = 8000
4 print('构造函数')
5
6 def __del__(self): #析构函数 实例被销毁之后自动调用
7 print('析构函数')
8
9 def say(self):
10 print('say')
11
12 def set_price(self,discount): #实例方法
13 self.__base_price = self.__base_price - self.__base_price * discount
14 return self.__base_price
15
16 def get_price(self):
17 return self.__base_price
18
19 if __name__ == '__main__':
20 xh = Person() #实例化
21 xh.say()
22 print(xh.set_price(0.5))
23 print(xh.get_price())
24
25 #结果
26 构造函数
27 say
28 4000.0
29 4000.0
30 析构函数二、私有方法和私有属性
私有就是只有在类里面可以访问，实例化之后不可以访问和调用，有私有方法和私有属性。私有就把变量名或者函数名前面加上"__"两个下划线，其实就是通过私有来实现封装的。
1 class Dog(object):
2 __type = '狗' # 私有属性
3
4 def cry(self):
5 self.__test() # 调用私有方法
6 print('私有属性%s' % self.__type)
7 print('狗 [%s] 汪汪汪' % self.name)
8
9 def __test(self): # 私有方法
10 self.name = 'test' #
11
12
13 d = Dog()
14 d.cry() # 正常可以调用
15 d.__type # 报错，因为是私有属性，在外面不能访问
16 d.__test() # 报错，因为是私有方法，在外面不能访问三、静态方法和类方法
1 class Person: #经典类
2 #属性就是变量
3 #功能就是函数
4 country = 'China' #类变量
5 base_price = 8000
6 discount = 0.1
7
8 def __del__(self):
9 pass
10
11 @staticmethod #静态方法，和类本身没有什么关系了，就相当于在类里面定义了一个方法而已
12 def help():
13 print("这个类是造机器人的")
14
15 @classmethod #类方法，和静态方法不同的是，它可以使用类变量，必须要传一个值，代表的就是这个类
16 def getClassname(cls):
17 print('Person')
18
19 @classmethod
20 def sayCountry(cls):
21 #代表的本身这个类，可直接调用类方法
22 cls.getClassname()
23 print(cls.country)
24
25 def __init__(self,uid,name): #构造方法
26 print('self的内存地址:',id(self))
27 self.id = uid #实例变量
28 self.name = name #pep8
29
30 def cook(self): #实例方法
31 print('%s鱼香肉丝'%self.name)
32
33 def housework(self):
34 print('%s正在做家务'%self.name)
35 print('国籍是%s'%self.country)
36
37 @property #私有方法
38 def price(self,):
39 return self.base_price - self.base_price * self.discount
40
41 if __name__ == '__main__':
42 Person.country = 'USA' #修改类属性
43 Person.sayCountry() #直接调用类方法，无需实例化
44 Person.help() #直接调用静态方法，无需实例化
45
46 xh = Person(1,'小黑') #__init__(xh,1,'小黑')，实例化
47 xh.housework() #housework(xh)，调用实例方法
48 xh.sayCountry() #实例化后调用类方法
49 xh.help() #静态方法可直接调用，也可实例化后再调用
50 print(xh.country)
51
52 #结果：
53 Person
54 USA
55 这个类是造机器人的
56 self的内存地址: 2048490123392
57 小黑正在做家务
58 国籍是USA
59 Person
60 USA四、抽象类和反射
1、抽象类：
1 import abc
2
3 class BaseCar(metaclass=abc.ABCMeta): #这个是一个抽象类，只是用来继承的
4 def __init__(self,uid):
5 self.uid = uid
6
7 @abc.abstractmethod #如果抽象类里面的函数通过abstractmethod修饰，那就在子类里面必须实现
8 def run(self):
9 pass
10
11 class Bmw(BaseCar): #子类，继承父类BaseCar
12 def run(self): #重写父类里的抽象类
13 print('run')
14
15 m = Bmw('uid') #因父类构造函数有参数uid，因此子类实例化的时候要传这个参数
16 m.run() #调用实例方法2、反射：
指程序可以访问、检测和修改它本身状态或行为的一种能力（自省）。python面向对象中的反射：即通过字符串的形式操作对象相关的属性；python中的一切事物都是对象（都可以使用反射）
四种可以实现自省的函数：1.hasattr 2.setattr 3.getattr 4.delattr
1 class Custom:
2 feature='black'
3 def __init__(self,name,addr):
4 self.name=name
5 self.addr=addr
6 def buy_house(self):
7 print('%s正在买房子'%self.name)
8 def rent_house(self):
9 print('%s正在租房子' %self.name)
10 z1=Custom('李梅','北京')
11 #对象是否有某种属性
12 print(hasattr(z1,'name')) #True
13 print(hasattr(z1,'buy_house')) #True
14 print(hasattr(z1,'zyy')) #False
15 #取对象的某种属性
16 print(getattr(z1,'name')) #李梅
17 print(getattr(z1,'rent_house'))
18 print(getattr(z1,'i am a sheep','没有这个属性')) #没有这个属性，找不到只会返回后面的值，不会报错
19 #为对象设置某种属性
20 setattr(z1,'李白',True)
21 print(z1.__dict__) #{'name': '李梅', 'addr': '北京', '李白': True}
22 #删除对象某种属性
23 delattr(z1,'李白')
24 print(z1.__dict__) #{'name': '李梅', 'addr': '北京'}
25
26 #结果
27 True
28 True
29 False
30 李梅
31 <bound method Custom.rent_house of <__main__.Custom object at 0x0000020FDC26E7F0>>
32 没有这个属性
33 {'name': '李梅', 'addr': '北京', '李白': True}
34 {'name': '李梅', 'addr': '北京'}