• 中文
    • English
  • 注册
  • 赞助本站

    • 支付宝
    • 微信
    • QQ

    感谢一直支持本站的所有人!

    • 查看作者
    • 第十五章:面向对象高级编程

      一. 使用__slots__

      1. 当我们创建一个class实例后,可以给该实例绑定任何属性和方法,但每个实例绑定的属性和方法对另一个实例不起作用,可以给class绑定方法,让所有的实例都可以调用

      from types import MethodType
      
      class Dog(object):
          pass
      
      def fn(self,name):  # 该方法一般直接定义在class中,但动态绑定允许我们在程序运行的过程中动态给class加上功能,这在静态语言中很难实现。
          self.name = name
      
      s  =  Dog()
      s.fn = MethodType(fn,s)
      s.fn("哈哈")
      print(s.name) #哈哈
      
      s2 = Dog()
      s2.fn("哈哈2") # AttributeError: 'Dog' object has no attribute 'fn'
      print(s2.name) # AttributeError错误 (给一个实例绑定的方法,对另一个实例是不起作用的)
      
      Dog.fn = fn  # 为了给所有实例都绑定方法,可以给class绑定方法
      s2.fn("哈哈2")
      print(s2.name) # AttributeError错误

      2. Python允许在定义class的时候,定义一个特殊的__slots__变量,来限制该class实例能添加的属性,但是_slots__定义的属性仅对当前类实例起作用,对继承的子类是不起作用的,除非在子类中也定义__slots__,这样,子类实例允许定义的属性就是自身的__slots__加上父类的__slots__。

      class Dog(object):
          __slots__ = ('name','age')
      
      
      d = Dog()
      d.name = '嘎嘎'
      print(d.name) # 嘎嘎
      d.gender = '男' #AttributeError: 'Dog' object has no attribute 'gender'

      二. 使用@property

      Python内置的@property装饰器负责把一个方法变成属性调用

      class Student(object):
      
          @property  #把一个getter方法变成属性,只需要加上@property就可以
          def score(self):
              return self._score
      
          @score.setter #负责把一个setter方法变成属性赋值
          def score(self,value):
              if not isinstance(value,int):
                  raise ValueError('score必须是整数')
              if value < 0 or value > 100:
                  raise ValueError('score必须 < 0 且 > 100')
              self._score = value
      
      
      
          @property  #只定义getter方法,不定义setter方法就是一个只读属性
          def age(self):
              return self._age
      
      
      s = Student()
      s.score = 70   # 如果直接这么写,会属性暴露出去,且无法控制socre的值是否合法
      
      print(s.score) #70

      三. 多重继承

      多重继承,一个子类就可以同时获得多个父类的所有功能,也就是说,如果需要“混入”额外的功能,通过多重继承就可以实现,这种设计通常称之为MixIn。

      class Animal(object):
          pass
      
      # 大类:
      class Mammal(Animal): # 哺乳动物
          pass
      
      class Bird(Animal): #鸟
          pass
      
      
      class RunnableMixIn(object):  # 能跑
          def run(self):
              print('Running...')
      
      
      class FlyableMixIn(object):  # 能飞
          def fly(self):
              print('Flying...')
      
      
      
      # 各种动物:
      class Dog(Mammal,RunnableMixIn): # 狗属于哺乳动物
          pass
      
      class Bat(Mammal,FlyableMixIn): # 蝙蝠属于哺乳动物
          pass
      
      class Parrot(Bird,FlyableMixIn): # 鹦鹉属于鸟
          pass
      
      class Ostrich(Bird,RunnableMixIn): #鸵鸟属于鸟
          pass
      
      d = Dog()
      
      d.run()

      四. 定制类

      (1)__str__和__repr__

      __str__()返回用户看到的字符串,而__repr__()返回程序开发者看到的字符串,__repr__()是为调试服务的,一般两者代码一致。

      class Student(object):
          def __init__(self,name):
              self.name = name
      
          def __str__(self):  #返回用户看到的字符串
              return "学生的名字是:%s" % self.name
          __repr__ = __str__ # __repr__()返回程序开发者看到的字符串,如果不用print会调用repr
          
      s = Student("张甲")
      
      print(s) #学生的名字是:张甲

      (2)__iter__

      如果一个类想被用于for ... in循环,类似list或tuple那样,就必须实现一个__iter__()方法,该方法返回一个迭代对象,for循环就会不断调用该迭代对象的__next__()方法拿到循环的下一个值

      class Test(object):
          def __init__(self):
              self.x = 0
      
          def __iter__(self):
              return self
      
          def __next__(self):
              self.x += 2
              if self.x > 10:
                  raise StopIteration() # 退出循环的条件
              return self.x
      
      
      for i in Test():
          print(i)  # 2 4 6 8 10

      (3)__getitem__

      __iter__只是像list,需要实现getitem方法才可以像list一样通过下标取元素

      class Test(object):
          def __init__(self):
              self.x = 0
      
          def __iter__(self):
              return self
      
          def __next__(self):
              self.x += 2
              if self.x > 10:
                  raise StopIteration() # 退出循环的条件
              return self.x
      
          def __getitem__(self, item):
              for i in range(item):
                  self.x += 2
              return self.x
      
      t = Test()
      print(t[3]) # 6

      但是__getitem__()传入的参数可能是一个int,也可能是一个切片对象slice,所以要根据各种类型做判断,另外,__setitem__()方法,可以把对象视作list或dict来对集合赋值。__delitem__()方法用于删除某个元素

      (4)___getattr____

      getattr方法可以当我们调用某个实例不存在的属性或者函数的时候,将其动态返回

      class Student(object):
          def __getattr__(self, attr):
              if attr == 'age':
                  return lambda: 25
      
      t = Student()
      
      print(t.age()) # 25

      (5)__call__

      我们可以通过__call__()方法,直接默认调用某个方法,通过callable()函数,我们就可以判断一个对象是否是“可调用”对象

      class Student(object):
          def __call__(self, *args, **kwargs):
              print("哈哈")
      
      s = Student()
      
      s() # 哈哈
      print(callable(s)) # True

      五. 枚举类

      枚举类的每个常量都是class的一个唯一实例

      from enum import Enum
      
      Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))
      
      print(Month.Mar) # Month.Mar
      
      for name,member in Month.__members__.items():
          print(name,'=>',member,",",member.value)
          
      '''
      Jan => Month.Jan , 1
      Feb => Month.Feb , 2
      Mar => Month.Mar , 3
      Apr => Month.Apr , 4
      May => Month.May , 5
      Jun => Month.Jun , 6
      Jul => Month.Jul , 7
      Aug => Month.Aug , 8
      Sep => Month.Sep , 9
      Oct => Month.Oct , 10
      Nov => Month.Nov , 11
      Dec => Month.Dec , 12
      '''

      此外,可以从Enum派生出自定义类,并通过@unique装饰器帮助我们检查保证没有重复值

      from enum import Enum,unique
      
      @unique
      class Weekday(Enum):
          Sun = 0  # Sun的value被设定为0
          Mon = 1
          Tue = 2
          Wed = 3
          Thu = 4
          Fri = 5
          Sat = 6
      
      print(Weekday.Mon) # Weekday.Mon
      print(Weekday['Mon']) # Weekday.Mon
      print(Weekday(1)) # Weekday.Mon
      
      for name, member in Weekday.__members__.items():
          print(name, '=>', member, ",", member.value)
      
      '''
      Sun => Weekday.Sun , 0
      Mon => Weekday.Mon , 1
      Tue => Weekday.Tue , 2
      Wed => Weekday.Wed , 3
      Thu => Weekday.Thu , 4
      Fri => Weekday.Fri , 5
      Sat => Weekday.Sat , 6
      '''

      六. 元类

      动态语言和静态语言最大的不同,就是函数和类的定义,不是编译时定义的,而是运行时动态创建的。

      class Hello(object):
          def hello(self):
              print("Hello,word")
      
      h = Hello()
      print(type(h)) # print(type(h)) # 
      print(type(Hello)) # <class 'type'>

      type函数可以返回一个对象的类型,也可以创建新的类型

      def fn():
          print("哈哈")
      
      Hello = type('Hello',(object,),dict(hello =fn))
      
      print(Hello()) #<__main__.Hello object at 0x000001D33543FB80>

      metaclass:TODO:没空看,以后用到再学吧

      参考资料

      [1] 廖雪峰-Python教程

    • 0
    • 0
    • 0
    • 170
    • 请登录之后再进行评论

      登录
    • 做任务
    • 实时动态
    • 偏好设置
    • 返回顶部
    • 单栏布局 侧栏位置: