大师兄的Python学习笔记(二): 面向对象和类

大师兄的Python学习笔记(一): 基础篇
大师兄的Python学习笔记(三): 模块和包

三、面向过程和面向对象的思维方式

1.面向过程(Proceduce Oriented)
  • 如果想吃西红柿炒鸡蛋:
    step1: 打鸡蛋
    step2: 切西红柿
    step3: 热锅
    step4: 炒鸡蛋
    step5: 炒西红柿
    step6: 放盐
    step7: 出锅

  • 这种把任务切分成一系列子工作,自顶向下一步一步实现的方式叫做面向过程

2. 面向对象(Object Oriented)
  • 如果想吃西红柿炒鸡蛋:
    step1: 设计一个饭馆的蓝图(类)
    饭馆包含食材:西红柿、鸡蛋
    饭馆包含调料:盐
    饭馆包含炊具:锅
    饭馆包含功能:炒菜
    step2: 根据蓝图建造一个饭馆(对象)
    step3: 点西红柿炒鸡蛋这道菜
  • 这里我们实际上是将制作西红柿炒鸡蛋的过程封装到对象饭馆中。
  • 吃饭的人只需要对厨房下达命令,至于功能的实现方式则不用关心。
  • 这种将功能抽象封装的方式叫做面向对象
3.面向对象的优缺点

1)易复用
建立厨房后,如果为一万人提供西红柿炒鸡蛋,我们只需要下达一万次命令即可,不用重复造轮子。
2)易维护
如果想吃黄瓜炒鸡蛋,只需将食材中的西红柿替换成黄瓜,不用重新设计整个流程。
3)易扩展
如果想吃西红柿鸡蛋盖饭,只需要增加食材大米和蒸饭的功能,而并不需要重建一个厨房。
4)缺点:性能低于面向过程
如果只是一个人吃饭,盖饭馆就很浪费。

4.总结

1)面向过程适合简单、少量的任务。
2)面向对象适合复杂、大量的任务。
3)面向对象并不能取代面向过程,面向对象的最底层是面向过程。

四、类和对象

1.类
  • 类就是具备某些共同特征的实体的集合,它是一种抽象的数据类型,它是对所具有相同特征实体的抽象。
  • 比如:西红柿和鸡蛋都属于食材,食材是个抽象的概念,是一个类。
2.对象
  • 对象是具体的事物,单个的个体。
  • 比如:西红柿和鸡蛋可以是对象、盐和锅可以是对象、西红柿炒鸡蛋可以是对象,厨房也可以是对象。
3.类和对象的关系

类是对象的概括,对象是类的具体体现

五、在Python中实现类和对象

1.类的声明
  • 用class关键字。
  • 类的成员只可以是属性或方法。
  • 属性可以看理解为类中的变量。
  • 方法可以看理解为类中的函数。
class <类名>():
     <类的成员> # 这里必须有缩进
>>>class FoodMaterial():
>>>    price = 10  # 属性
>>>    def cut():   # 方法
>>>        print('我被切成片了!')    
2.类的实例化
  • 也就是将类实例化成为对象
<变量> = <类名>()
>>>class FoodMaterial():
>>>    price = 10  # 属性
>>>    def cut():   # 方法
>>>        print('我被切成片了!')    
>>>tomato = FoodMaterial() # 这里将类实例化后存储在变量中
3. 访问类和对象的成员

1)访问类的属性和调用方法

方法一:
<类名>.<属性名> # 访问属性
<类名>.<方法名>() # 调用方法
方法二:
getattr(<类名>,"<属性名>")
getattr(<类名>,"<方法名>")()
>>>class FoodMaterial():
>>>    price = 10  
>>>    def cut():   
>>>        print('我被切成片了!')    
>>>print(FoodMaterial.price) # 访问属性
>>>10
>>>FoodMaterial.cut() # 调用方法
>>>我被切成片了!

2) 访问对象的属性和方法

方法一:
<对象名>.<属性名> # 访问属性
<对象名>.<方法名>() # 调用方法
方法二:
getattr(<对象名>,"<属性名>")
getattr(<对象名>,"<方法名>")()
>>>class FoodMaterial():
>>>    price = 10  
>>>    def cut(self):   # self我们后面说
>>>        print('我被切成片了!')    
>>>tomato = FoodMaterial() 
>>>print(tomato.price) # 访问属性
>>>10
>>>tomato.cut() # 调用方法
>>>我被切成片了!
4. 修改类和对象的属性

1)修改类的属性

方法一:<类名>.<属性名> = <值> # 修改类属性
方法二:setattr(<类名>,"<属性名>",<值>)
>>>class FoodMaterial():
>>>    price = 10  
>>>tomato = FoodMaterial()
>>>FoodMaterial.price = 20
>>>print(FoodMaterial.price)
20
>>>print(tomato.price) # 这时对象的属性也跟着改变了
20

2)修改对象的属性

  • 如果对象的属性被修改过,就不会跟着类的属性同步了。
方法一:<对象名>.<属性名> = <值> # 修改对象属性
方法二:setattr(<对象名>,"<属性名>",<值>)
>>>class FoodMaterial():
>>>    price = 10  
>>>tomato = FoodMaterial()
>>>tomato.price = 20
>>>print(tomato.price)
20
>>>print(FoodMaterial.price) # 这时类的属性并没有改变
10
>>>FoodMaterial.price = 30 # 如果这时我们再修改类的属性
>>>print(tomato.price) # 对象的属性不会再跟着改变
20
5. 增加类和对象的属性

1)增加类的属性

方法一:<类名>.<属性名> = <值> 
方法二:setattr(<类名>,"<属性名>",<值>)
>>>class FoodMaterial():
>>>    price = 10  
>>>tomato = FoodMaterial()
>>>FoodMaterial.colour = 'red'
>>>print(FoodMaterial.colour)
red
>>>print(tomato.colour) # 这时对象的属性也跟着增加了
red

2)增加对象的属性

方法一:<对象名>.<属性名> = <值> # 增加对象属性
方法二:setattr(<对象名>,"<属性名>",<值>)
>>>class FoodMaterial():
>>>    price = 10  
>>>tomato = FoodMaterial()
>>>tomato.colour = 20
>>>print(tomato.colour)
red
>>>print(FoodMaterial.colour) # 这时类的属性并没有增加
AttributeError: type object 'FoodMaterial' has no attribute 'colour'
>>>FoodMaterial.colour = 'yellow' # 如果这时我们再修改类的属性
>>>print(tomato.colour) # 对象的属性不会改变
red
6. 删除类和对象的属性

1)删除类的属性

方法一:del <类名>.<属性名>  # 删除类属性
方法二:delattr(<类名>,"<属性名>")
>>>class FoodMaterial():
>>>    price = 10  
>>>    colour = 'red'
>>>tomato = FoodMaterial()
>>>del FoodMaterial.price
>>>print(FoodMaterial.price) # 删除属性
AttributeError: type object 'FoodMaterial' has no attribute 'price'
>>>print(tomato.colour) # 这时对象的属性也被删除了
AttributeError: type object 'FoodMaterial' has no attribute 'price'

2)删除对象的属性

  • 从下面的例子就可以看出,对象的属性在没有单独定义的情况下,实际上是调用了类的属性
  • 如果单独为对象创建属性,在属性名相同的情况下,优先调用对象的属性
方法一:del <对象名>.<属性名> # 删除对象属性
方法二:delattr(<对象名>,"<属性名>")
>>>class FoodMaterial():
>>>    price = 10  
>>>    colour = 'red'
>>>tomato = FoodMaterial()
>>>del tomato.price # 这里会提示tomato并没有price属性,实际上是调用的FoodMaterial得price属性
AttributeError: price

>>>tomato.price = 20 # 为对象增加属性
>>>print(tomato.price) # 覆盖了类的属性
20
>>>del tomato.price # 删除了对象的属性
>>>print(tomato.price) # 这里又调用了类的属性
10

>>>del FoodMaterial.price # 如果这时我们将类的属性也删除掉
>>>print(tomato.price) # 无法调用属性,所以报错了
AttributeError: 'FoodMaterial' object has no attribute 'price'
7.关于self
  • self是类和对象中的特一个特殊的参数,代表类本身。
  • self只在类和对象中存在。
  • self不需要赋值。
  • self是类中默认的第一个参数。
  • 其实self并不是系统指定的关键字,他可以叫任何名字,只要他是类中的第一个参数就可以。
    1)在类中使用self参数
  • 很少直接使用类中的self参数
>>>class FoodMaterial():
>>>    def cut(self) :
>>>        print('我被切成片了!')
>>>FoodMaterial.cut(FoodMaterial) # 这时需要将类自身作为参数返回,不然会报错。
我被切成片了!
  • 因为对象也属于类,所以可以用对象作为self参数。但是这种用法比较奇葩,不推荐使用。
>>>class FoodMaterial():
>>>    def cut(self) :
>>>        print('我被切成片了!')
>>>tomato = FoodMaterial()
>>>FoodMaterial.cut(tomato) # 这里将方法当做参数代表类本身,也可以正常运行
我被切成片了!
  • 如果不使用self名称,也没有任何区别,但不推荐这样使用。
>>>class FoodMaterial():
>>>    def cut(somethingbutnotself) : # 证明self并不是关键字
>>>        print('我被切成片了!')
>>>FoodMaterial.cut(FoodMaterial) 
我被切成片了!

2)在对象中使用self参数

  • 在调用对象方法时,会默认将自身作为第一个参数返回。所以如例(3.2)中,如果在没有为方法添加self参数,而直接用对象中的该方法会报错。
>>>class FoodMaterial():
>>>    def cut() :
>>>        print('我被切成片了!')
>>>tomato = FoodMaterial()
>>>tomato.cut() # 这里会提示传入了一个参数,但是cut()不需要传入参数
TypeError: cut() takes 0 positional arguments but 1 was given

>>># 正确的调用方式
>>>class FoodMaterial():
>>>    def cut(self) :
>>>        print('我被切成片了!')
>>>tomato = FoodMaterial()
>>>tomato.cut() # tomato会默认将自身作为第一个参数传入方法
我被切成片了!
  • 在对象中self改变了变量和函数的作用域,成为对象内的全局变量。
>>>class FoodMaterial():
>>>    def __init__(self): # __init__是魔法函数,这里可以先理解为一个在对象创建时自动执行的方法。
>>>        self.price = 10 # 这里self.price成为对象内的全局变量
>>>    def getPrice(self) :
>>>        print('我的价格是:{price}'.format(price=self.price)) # 调用了方法内的变量self.price,证明其作用域是全局
>>>tomato = FoodMaterial() 
>>>tomato.getPrice()
我的价格是:10
8.Python中的构造函数
  • 构造函数是一种特殊的方法,用来在创建对象时为对象赋值。
  • Python中构造函数的方法是: def __init__(self,arg1,arg2)
  • 构造函数只能调用一次,就是在创建类的时候调用
  • __init__ 其实是一个魔法函数,后面会介绍。
>>>class FoodMaterial():
>>>    def __init__(self,price,colour): # 构造函数,参数在创建类时需要提供
>>>          self.price = price 
>>>          self.colour = colour
>>>          self.show() # 在创建类时就要执行的方法
>>>    def show(self):
>>>          print(self.price)
>>>          print(self.colour)
>>>tomato = FoodMaterial(price=10,colour='red') # 这里并没有再专门调用show(),在创建时就自动执行了。
10
red

>>>print(FoodMaterial.price) # 直接用类访问不到构造函数中的成员,因为构造函数只在创建对象时执行。
AttributeError: type object 'FoodMaterial' has no attribute 'price'

六、面向对象的三大特征

  • 封装
  • 继承
  • 多态
1. 封装
  • 封装就是对对象的成员进行访问限制,是为了保护私隐,明确区分内外。
  • 封装的级别分为:公开(public)、受保护的(protected)、私有的(private)
  • 与Java不同,Python中没有public,private,protected的关键字
  • Python中的封装并不是严格的语法,更像是一种规范。

1)公开的(public)
公共的封装实际对成员没有任何操作,任何地方都可以访问。
2)受保护的(protected)

  • 受保护的成员名称前增加一个下划线_。
  • 受保护的封装在类中或者子类中都可以访问,但在外部不允许访问。
  • 我测试受保护的成员实际上是可以直接访问的,应该只是一种书写规范,希望有人可以指正我。
_<受保护的成员名>
>>>class FoodMaterial():
>>>    _price = 10 # 受保护的属性
>>>    def _getPrice(self) : # 受保护的方法
>>>        print('我的价格是:{price}'.format(price=self.price)) 

3)私有的(private)

  • 私有员名称前增加两个划线__。
  • 私有成员只能在当前类或对象中访问。
  • Python中的私有实现方式是一种被称为name mangling的障眼法。
__<私有的成员名>
>>>class FoodMaterial():
>>>    __price = 10 # 私有的属性
>>>    def __getPrice(self) : # 私有的方法
>>>        print('我的价格是:{price}'.format(price=self.__price)) 
>>>tomato = FoodMaterial() # 实例化
>>>print(tomato.__price) # 注意,这里的报错是:不存在这个值!。
AttributeError: 'FoodMaterial' object has no attribute '__price'
>>>tomato.__getPrice()
AttributeError: 'FoodMaterial' object has no attribute '__getPrice'
  • 用魔法函数__dict__查看类的全部成员,可以看出私有成员实际是被改名为:_<类名>__<成员名>
>>>print(FoodMaterial.__dict__)
>>>mappingproxy({'__module__': '__main__',
>>>              '_FoodMaterial__price': 10, # 这里可以看到被改名了
>>>              '_FoodMaterial__getPrice': ,
>>>              '__dict__': ,
>>>              '__weakref__': ,
>>>              '__doc__': None})

>>>print(tomato._FoodMaterial__price) # 试着访问改名后的成员
10
>>>print(tomato._FoodMaterial__getPrice())
我的价格是:10
2. 继承

1)继承的作用:

  • 继承就是一个类可以获得另外一个类中的成员属性和成员方法。
  • 继承可以减少代码,增加代码的复用功。
  • 继承可以建立类与类直接的关系。

2)继承与被继承的概念:

  • 被继承的类叫父类,也叫基类,也叫超类。
  • 用于继承的类,叫子类,也叫派生类。
  • 所有的类全都是object的子类,继承时如果不特别指定父类,将默认继承object类。

3)继承的语法

class <子类名>(<父类名>):
         <类的内容> 
>>># 父类
>>>class Dog(object): # 这里不写object也会默认继承object
>>>    type = 'dog'
>>>    legs = 4
>>>    def bark(self):
>>>         print('汪汪!')

>>># 子类
>>>class Schnauzer(Dog): # schnauzer继承了dog类
>>>     sub_type = 'schnauzer'

4)继承的特性

  • 子类一旦继承父类,则可以使用父类中除私有成员外的所有内容。
  • 子类继承父类后并没有将父类成员完全赋值到子类中,而是通过引用关系访问调用。
  • 子类中可以定义独有的成员属性和方法。
  • 子类中定义的成员和父类成员如果相同,则优先使用子类成员。
>>># 父类
>>>class Dog(object): # 这里不写object也会默认继承object
>>>    type = 'dog'
>>>    def bark(self):
>>>         print('汪汪!')
>>>    def __showLegs(self): # 私有成员不会被继承
>>>         print(4)

>>># 子类
>>>class Schnauzer(Dog): # schnauzer继承了dog类
>>>     sub_type = 'schnauzer'
>>>     def bark(self): # 这里覆盖了父类的方法
>>>          print('嗷嗷1')
>>>qq = Schnauzer()

>>>print(qq.type) # 继承了父类的属性
'dog'

>>>print(qq.bark()) # 同名时首先引用了自己的方法
嗷嗷!

>>>print(qq.sub_type) # 有了自己的属性
'schnauzer'

>>>print(qq.__showLegs()) # 私有变量不会被继承
AttributeError: 'schnauzer' object has no attribute '__showLegs'

5)super函数

  • super()函数用于调用父类的一个方法。
  • super().<父类方法名>() = <父类名>.<父类方法名>()
self(<父类名>,self).<方法名>(参数) # 意思是将父类的方法转换为自己的方法。
self().<方法名>(参数) # python3.0中可以省略self()中的内容,但多重继承中还是需要。
>>># 父类
>>>class Dog(): 
>>>    def bark(self):
>>>         print('汪汪!')

>>># 子类
>>>class Schnauzer(Dog): # schnauzer继承了dog类
>>>    def barkTwice(self): 
>>>         super().bark() # 这里调用了父类的方法
>>>         print('嗷嗷!')
>>>qq = Schnauzer()
>>>qq.barkTwice()
汪汪!
嗷嗷!

6)继承的顺序

  • 优先查找自己的函数
  • 没有则查找父类
  • 如果父类没有则查找父类的父类
>>># 父类
>>>class Dog(): 
>>>    type = 'dog'

>>># 子类
>>>class Schnauzer(Dog): 
>>>    pass

>>># 孙类
>>>class BabySchnauzer(Schnauzer): 
>>>    pass

>>>qq = BabySchnauzer()
>>>print(qq.type) # 继承了祖父类的属性s
'dog'

7)继承构造函数

  • 如果定义了构造函数,则实例化时使用构造函数。
  • 如果没定义,则自动查找父类构造函数。
  • 如果重写了构造函数,还要继承父类的构造方法,可以使用 super()方法。
>>># 父类
>>>class Dog(): 
>>>    def __init__(self,legs):
>>>        self.type = 'dog'
>>>    def fatherType(self):
>>>        print('father type is {type}'.format(type=self.type))

>>># 子类
>>>class Schnauzer(Dog): 
>>>     def __init__(self,legs):
>>>         super().__init__(self,legs) # 这里调用了父类的构造函数,将参数传入
>>>     def sonType(self):
>>>         print('son type is {type}'.format(type=self.type))

>>>qq = Schnauzer(4)
>>>qq.sonType()
son type is dog
>>>qq.fatherType() # 将参数传给父类的方法,并调用方法
father type is dog

8)多继承

  • 多继承就是子类同时继承多个类,方法是:def <子类名>(<父类一>,<父类二>):
  • 如果两个父类的属性相同,则继承写在前面的父类。
  • 可以通过inspect.getmro(<类名>)查看类的MRO列表(继承顺序)
>>># 父类一·
>>>class Human():
>>>    type = 'human'
>>>    def introHuman(self):
>>>          print('i am human!')

>>>class Fish():
>>>    type = 'fish'
>>>    def introFish(self):
>>>          print('i am fish!')

>>>class Fishman(human,fish): # 多个父类
>>>    pass
>>>f = Fishman()

>>>print(f.introHuman()) # 同时继承了两个父类的方法
i am human!
>>>print(f.introFish())
i am fish!

>>>print(f.type) # 属性名相同则继承前面的父类
human

>>>import inspect # 导入inspect包
>>>inspect.getmro(fishman) # 查看fishman类的mro
(__main__.fishman, __main__.human, __main__.fish, object)
  • 单继承和多继承的对比:
/ 单继承 多继承
优点 传承有序逻辑清晰语法简单隐患少 类的功能扩展方便
缺点 功能扩展性受父类限制 继承关系混乱
  • 经典钻石继承问题:当一个孙类同时继承多个父类,而这些父类又继承同一个祖父类时,如果孙类同时继承多个父类的构造函数,祖父类构造函数会被初始化多次。
# 祖父类
>>>class Grandpa(object):
>>>    def __init__(self):
>>>        print('from grandpa')
# 父类1
>>>class Dad1(Grandpa):
>>>    def __init__(self):
>>>        grandpa.__init__(self)
>>>        print('from dad1')
# 父类2
>>>class Dad2(Grandpa):
>>>    def __init__(self):
>>>        grandpa.__init__(self)
>>>        print('from dad2')
# 子类
>>>class Son(Dad1, Dad2):
>>>    def __init__(self):
>>>        dad1.__init__(self) 
>>>        dad2.__init__(self) # 同时调用两个父类的构造函数
>>>        print('from son')

>>>s = Son()
from grandpa
from dad1
from grandpa
from dad2
from son
  • 钻石继承问题解决方案:使用super()函数
# 祖父类
>>>class Grandpa(object):
>>>    def __init__(self):
>>>        print('from grandpa')
# 父类1
>>>class Dad1(Grandpa):
>>>    def __init__(self):
>>>        super().__init__()
>>>        print('from dad1')
# 父类2
>>>class Dad2(Grandpa):
>>>    def __init__(self):
>>>        super().__init__()
>>>        print('from dad2')
# 子类
>>>class Son(dad1, dad2):
>>>    def __init__(self):
>>>        super().__init__() #这里同时继承了两个父类的构造函数
>>>        print('from son')

>>>s = Son() # 这里祖父类只调用了一次
from grandpa
from dad1
from dad2
from son
3. 多态

1)理解多态

  • 首先要理解创建一个类就是创建了一种数据类型,和list,dict是一样的。
>>>a = list()
>>>type(a) 
list
>>>isinstance(a,list) # a 属于list类型
True

>>>class Animal():
>>>    pass
>>>dog = Animal()
>>>type(dog)
__main__.Animal
>>>isinstance(dog,Animal)  # dog是animal数据类型
True
  • 多态是指同一个对象在不同情况下有不同的状态出现。
  • 多态是一种思想,而不是一种语法。
  • 多态增加了程序的灵活性和扩展性。
>>>class Animal(): # 创造动物的数据类型
>>>    pass

>>>class Dog(Animal): # 狗属于动物
>>>    pass

>>>class Cat(Animal): # 猫也属于动物
>>>    pass

>>>qq = Dog()
>>>isinstance(qq,Dog)
True
>>>isinstance(qq,Animal) # qq即属于狗,也属于动物
True

>>>mimi = Cat()
>>>isinstance(mimi,Cat)
True
>>>isinstance(mimi,Animal) # mimi即属于猫,也属于动物
True

2)多态性

  • 指具有不同功能的函数可以使用相同的函数名,这样就可以用一个函数名调用不同内容的函数。
  • 多态性是一钟调用方式,
>>>class Animal():
>>>    def talk(self):
>>>        pass

>>>class Human():
>>>    def talk(self):
>>>        print('你好!')

>>>class Dog():
>>>    def talk(self):
>>>        print('汪汪!')

>>>class Cat():
>>>    def talk(self):
>>>        print('喵喵!')

>>> ppl = Human()
>>> pp = Dog()
>>> mimi = Cat()

>>> Human.talk()
你好!
>>> Dog.talk()
汪汪!
>>> Cat.talk()
喵喵!

3)mixin模式

  • mixin模式通过多继承来实现,子类通过继承Mixin类获得一种功能。
  • Mixin类用<类名 + Mixin>的方式起名,但这不是语法,而是告诉后来读代码的人,这是一个Mixin类。
  • 一个Mixin类可以理解为一种功能,且只能是一种功能,如果有多个功能则创建多个Mixin类。
  • Mixin不能依赖于子类的实现
  • 子类及时没有继承这个Mixin类, 也能照样工作,只是缺少了某个功能
>>>class Animal():
>>>    pass

>>>class FlyMixin():  # Mixin类
>>>    def fly(self):
>>>        print('I can fly!')

>>>class Bird(Animal,FlyMixin): # 鸟既是动物,也能飞
>>>    pass

>>>kiki = Bird() # kiki作为bird类,获得了fly能力
>>>kiki.fly()
I can fly!

4)mixin模式的优点

  • 使用Mixin可以在不对类进行任何修改的情况下,扩充功能
  • 可以方便的组织和维护不同功能组件的划分
  • 可以根据需要任意调整功能类的组合
  • 可以避免创建很多新的类,导致类的继承混乱

七.类的成员描述符

(这里如果暂时看不懂请先看下一章魔法函数)

  • 类的成员描述符是为了在类中,对类的成员属性进行相关操作而创建的一种方式,大部分属于数据清洗。
  • 属性有三种操作:get获取属性值、set修改或添加属性、delete删除属性。
  • 实现成员描述符包括三种方法:描述器、属性修饰符、property函数
1. 描述器
  • 一个类只要实现了__get__,__set__,__delete__中任意一个方法,我们就可以叫它描述器
  • 如果仅仅实现了__get__.就是非数据描述器 non-data descriptor
  • 同时实现了__get__,__set__,就是数据描述器 data descriptor

1)__get__
不管是类还是实例去访问,默认都获得的是__get__的返回值,但是,如果中间有任何一次重新赋值,那么,这个实例获得的是新的值(对象),已经和原来的描述器完全脱离了关系。

>>>class Tomato():
>>>   def __get__(self,obj,cls):
>>>       print('here inside __get__ !')

>>>class MyClass():
>>>    t = Tomato() #类或实例默认获得__get__的返回值
>>>m = MyClass()
>>>m.t # 调用了__get__
here inside __get__ !

2)__set__
后期通过实例对描述器进行赋值,那么访问的是__set__,并且永远关联起来。但是如果通过修改类属性的方式复制,那么也会被重新获取新的值(对象)。

>>>class Tomato():
>>>   def __set__(self,obj,cls):
>>>       print('here inside __set__ !')

>>>class MyClass():
>>>    t = Tomato() #类或实例默认获得__get__的返回值
>>>m = MyClass()
>>>m.t = 'hello' # 赋值时调用__set__
here inside __set__ !

3)__delete__
采用del删除属性时,触发__delete__。

>>>class Tomato():
>>>   def __delete__(self,obj):
>>>       print('here inside __delete__ !')

>>>class MyClass():
>>>    t = Tomato()
>>>m = MyClass()
>>>del m.t # 用del删除属性时,触发__delete__
here inside __delete__ !
2. 属性修饰符
  • 属性修饰符包括:__getattribute__()、__getattr__()、__setattr__()、__delattr__()

1)__getattribute__()
调用属性或方法时,会先强制调用 getattribute 方法,然后再传回属性的值或者是 函数(方法)的引用。

>>>class Tomato():
>>>    def __init__(self):
>>>        name = 'tomato'
>>>    def __getattribute__(self, item):
>>>        print('inside __getattribute__!')
>>>t = Tomato()
>>>t.name # 调用属性时触发__getattribute__
inside __getattribute__!

2)__getattr__()
在实例以及对应的__dict__中查找属性失败,那么会调用__getattr__函数

>>>class Tomato():
>>>    def __getattr__(self, item):
>>>        print('inside __getattr__!')
>>>t = Tomato()
>>>t.name # 这里name并不存在,所以触发__getattr__
inside __getattr__!

3)__setattr__()
当为类属性赋值时,调用__setattr__()语句

>>>class Tomato():  
>>>    def __setattr__(self, item,value):
>>>        print('inside __setattr__!')
>>>t = Tomato()
>>>t.name = 'tomato' # 虽然和上个例子看起来相似,但其实这里时因为赋值触发__setattr__
inside __setattr__!

4)__delattr__()
只要使用del语句删除属性,就会调用这个方法

>>>class Tomato():
>>>   def __init__(self):
>>>        self.name = 'tomato'
>>>   def __delattr__(self, item):
>>>        print('inside __delattr__!')
>>>t = Tomato()
>>>del t.name # 用del删除元素时触发__delattr__
inside __delattr__!
3. property函数
  • property() 函数的作用是在新式类中返回属性值。
  • 使用语法 property(,,,<属性描述>)
  • get、set和del方法对应描述器的三个方法。
  • 三个方法的名字可以任意取,但是在property()中要按顺序一一对应。
>>>class Tomato():
>>>    def __init__(self):
>>>        self._name = 'tomato' # 创建protected属性
>>>    def get_name(self): # 创建属性的get方法
>>>        print('here inside get_name')
>>>        return self._name
>>>    def set_name(self, value): # 创建属性的set方法
>>>        print('here inside set_name')
>>>        self._name = value
>>>    def del_name(self): # 创建属性的del方法
>>>        print('here inside del_name')
>>>        del self._name
>>>    name = property(get_name, set_name, del_name, "I'm the 'name' property.") # 为name属性附加property
>>>t = Tomato()

>>>print(t.name) # 触发get_name()
here inside get_name
'tomato'

>>>t.name = 'Tomato' # 触发set_name()
here inside set_name

>>>del t.name # 触发del_name()
here inside del_name

>>>help(t.name) # 触发描述
here inside get_name
  • 用装饰器实现property(如果对装饰器不熟悉可以先跳过):
>>>class Tomato():
>>>    def __init__(self):
>>>        self._name = 'tomato' # 创建protected属性
>>>    @property # 相当于get
>>>    def name(self): # 创建属性的get方法
>>>        print('here inside get_name')
>>>        return self._name
>>>    @name.setter # 相当于set
>>>    def set_name(self, value): # 创建属性的set方法
>>>        print('here inside set_name')
>>>        self._name = value
>>>    @name.deleter # 相当于del
>>>    def del_name(self): # 创建属性的del方法
>>>        print('here inside del_name')
>>>        del self._name
>>>t = Tomato()

>>>print(t.name) # 触发get_name()
here inside get_name
'tomato'

>>>t.name = 'Tomato' # 触发set_name()
here inside set_name

>>>del t.name # 触发del_name()
here inside del_name

>>>help(t.name) # 触发描述
here inside get_name

八.类的内置属性

类包含以下默认内置属性:
1)__dict__:以字典的方式显示类的成员组成

>>>class FoodMaterial():
>>>    def __init__(self):
>>>        self._price = 10 # 受保护的属性
>>>    def getPrice(self) : # 受保护的方法
>>>        print('我的价格是:{price}'.format(price=self.price)) 
>>>print(FoodMaterial.__dict__)
{'__module__': '__main__', '__init__': , 'getPrice': , '__dict__': , '__weakref__': , '__doc__': None}

>>>tomato = FoodMaterial()
>>>print(tomato.__dict__)
{'_price': 10}

2)__doc__: 获取类的文档信息

>>>class FoodMaterial():
>>>    '''This is class FoodMaterial'''
>>>    pass
>>>print(FoodMaterial.__doc__)
This is class FoodMaterial

>>>tomato = FoodMaterial()
>>>print(tomato.__doc__)
This is class FoodMaterial

3)__name__:获取类的名称,如果在模块中使用,获取模块的名称

>>>class FoodMaterial():
>>>    pass
>>>print(FoodMaterial.__name__)
'FoodMaterial'

4)__bases__: 获取某个类的所有父类,以元组的方式显示

>>>class Animal():
>>>    pass

>>>class Baby():
>>>    pass

>>>class Dog(Animal):
>>>    pass

>>>class puppy(Dog,Baby):
>>>    pass

>>>print(puppy.__bases___)
(__main__.Dog, __main__.Baby)

九.魔法函数

  • 魔术方法就是不需要人为调用的方法,基本是在特定的时刻自动触发。
  • 魔法函数大全(没找到很好的中文教程,点击查看英文介绍)。
  • 以下是一些常用的魔法函数:

1)__init__
见:构造函数 - 5.8
2)__str__
当类被打印时,将调用str方法的值。

>>>class Dog(object): # 如果不处理__str__方法
>>>    pass
>>>dog = Dog()
>>>print(dog) 
<__main__.Dog object at 0x000001A953477240>

>>>class Dog(object):
>>>    def __str__(self):
>>>        return 'It is a dog!'
>>>dog = Dog()
>>>print(dog) # 返回了__str__方法的值
It is a dog!

3)__new__

  • 初始化对象,在__init__前执行
  • __new__方法包含一个参数,用于传入要实例化的对象
  • __new__方法必须返回一个值,是实例化后的对象
>>>class Dog(object):
>>>    def __new__(cls):
>>>        print(cls)
>>>        return 1
>>>dog = Dog() # 调用了print(cls)


>>>print(dog) # 由于返回值是1,所以Dog变成了1
1
>>>type(dog) # 类型也变成了整数
int

4)__call__

  • 定义后可以将对象当作函数使用。
>>>class Dog(object):
>>>    def __call__(self,name):
>>>        print('{name} is running!'.format(name=name))
>>>dog = Dog()
>>>dog('qq') # 调用__call__
qq is running!

5)__len__

  • 在用len()方法时,会调用__len__方法
>>>class Dog(object):
>>>    def __len__(self):
>>>        print('very very long!')
>>>dog = Dog()
>>>len(dog)
very very long!
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
 in 
----> 1 len(dog)

TypeError: 'NoneType' object cannot be interpreted as an integer

6)__repr__
函数str() 用于将值转化为适于人阅读的形式,而repr() 转化为供解释器读取的形式,某对象没有适于人阅读的解释形式的话,str() 会返回与repr(),所以print展示的都是str的格式。

>>>class Dog(object):
>>>    def __repr__(self):
>>>        return 'It is a dog!'
>>>dog = Dog()
>>>print(dog) # 返回了__str__方法的值
It is a dog!

7)__setattr__
见:类的成员描述符 - 7
8)__getattr__
见:类的成员描述符 - 7
9)__delattr__
见:类的成员描述符 - 7
10)__getattribute__
见:类的成员描述符 - 7
11)__del__
见:类的成员描述符 - 7
12)__getitem__
定义__getitem__方法,就可以用对象像字典一样取值:key[value]

>>>class Dog(object):
>>>    def __init__(self):
>>>        self.name = 'dog'
>>>    def __getitem__(self,key):
>>>        print('here in __getitem__')
>>>        return self.name
>>>dog = Dog()
>>>print(dog['name']) # 调用了__getitem__方法
here in __getitem__
'dog'

13)__delitem__
定义__delitem__方法,就可以用对象像字典一样删除值:del key[value]

>>>class Dog(object):
>>>    def __init__(self):
>>>        self.name = 'dog'
>>>    def __delitem__(self,key):
>>>        print('here in __delitem__')
>>>        del self.name
>>>dog = Dog()
>>>del dog['name'] # 调用了__delitem__方法
here in __delitem__

>>>print(dog.name)
AttributeError: 'Dog' object has no attribute 'name'

十.抽象类

  • 抽象类就是没有具体实现内容的方法成为抽象类
  • 抽象类的主要意义是规范了子类的行为和接口
  • 抽象类的使用需要借助abc模块
  • 抽象类不允许直接实例化
  • 必须继承才可以使用,且继承的子类必须实现所有继承来的抽象方法
  • 假定子类没有是现实所有继承的抽象方法,则子类也不能实例化
>>>import abc # 导入abc模块
>>>class Animal(metaclass=abc.ABCMeta):
>>>    type = animal
>>>    @abc.abstractmethod # 定义抽象方法,无需实现功能
>>>    def bart(self):
>>>        pass
>>>dog = Animal() # 抽象类不能被实例化
TypeError: Can't instantiate abstract class animal with abstract methods bart

>>>class Dog(animal):  # 通过继承实现抽象类
>>>    def bart(self):
>>>        print('嗷嗷!')
>>>dog = Dog()
>>>dog.bart()
嗷嗷!

参考资料


  • https://www.runoob.com 菜鸟教程
  • http://www.tulingxueyuan.com/ 北京图灵学院
  • http://www.imooc.com/article/19184?block_id=tuijian_wz#child_5_1 两点水
  • https://blog.csdn.net/weixin_44213550/article/details/91346411 python老菜鸟
  • https://realpython.com/python-string-formatting/ Dan Bader
  • https://www.liaoxuefeng.com/ 廖雪峰
  • https://blog.csdn.net/Gnewocean/article/details/85319590 新海说
  • 《Python学习手册》Mark Lutz
  • 《Python编程 从入门到实践》Eric Matthes

本文作者:大师兄(superkmi)


大师兄的Python学习笔记(二): 面向对象和类_第1张图片
梦幻微武侠

你可能感兴趣的:(大师兄的Python学习笔记(二): 面向对象和类)