Python学习笔记(四)

1. 面向对象编程(OOP)
1.1 类和实例
1.2 访问限制
1.3 继承和多态
1.4 获取对象信息
1.5 实例属性和类属性
2. 面向对象高级编程
2.1 使用_slots_
2.2 使用@property
2.3 多重继承
2.4 定制类
2.5 使用枚举类
2.6 使用元类

1. 面向对象编程(OOP)

面向对象编程，简称OOP，是一种程序设计思想。OOP把对象作为程序的基本单元，一个对象包含了数据和操作数据的函数。
在Python中，所有数据类型都可以视为对象，当然也可以自定义对象。自定义的对象数据类型就是面向对象中的类(Class)的概念。

  1. class Student(object):
  3.     def __init__(self, name, score):
  4.         self.name = name
  5.         self.score = score
  7.     def print_score(self):
  8.         print('%s: %s' % (self.name, self.score))

给对象发消息实际上是调用对象对应的关联函数，称之为对象的方法(Method)

1.1 类和实例

面向对象最重要的概念就是类(Class)和实例(Insance)。
在Python中定义类用class关键字，class后紧接着是类名，类名通常是大写开头的单词，紧接着是Object。
由于类可以起到模板的作用，因此，在创建实类的时候，把一些我们认为是必须绑定的属性强制填写进去。通过定义一个特殊的_init_方法。

  1. class Student(object):
  3.     def __init__(self, name, score): # 注意_init_第一个参数永远是self，表示创建实例的本身
  4.         self.name = name
  5.         self.score = score

数据封装:
封装数据的函数是和类本身关联起来的，我们称之为类的方法:

  1. class Student(object):
  3.     def __init__(self, name, score):
  4.         self.name = name
  5.         self.score = score
  7.     def print_score(self): # 除了第一个参数是self外，其他和普通函数一样
  8.         print('%s: %s' % (self.name, self.score))

1.2 访问限制

如果让内部属性不被外部访问修改，可以把属性的名称的前面加上两个下划线_，在Python中，实例的变量名如果以__开头，就变成了一个私有变量(private),只有内部可以访问，外部不能访问。

  1. class Student(object):
  3.     def __init__(self, name, score):
  4.         self.__name = name
  5.         self.__score = score
  7.     def print_score(self):
  8.         print('%s: %s' % (self.__name, self.__score))

如果外部代码想获取和修改name和score,可以给类增加get_score和set_score这样的方法。

  1. class Student(object):
  2.     ...
  3.     def get_score(self):
  4.         return self.__score
  5.     def set_score(self, score):
  6.         self.__score = score

在Python中，以双下划线_开头和以双下划线_结束的变量名，类似__xx__这样的是特殊变量,特殊变量是可以直接访问的，不是private变量。
以一个下划线开头的变量，比如_name,这样的实例变量是可以直接访问的，但是按照约定成俗的规定，意思就是”虽然我可以被直接访问，但是，请把我视为私有变量，不要随意访问”。
双下划线开头的变量，比如__name也不是一定不能被外部直接访问，可以通过_Student__name来访问__name变量。

1.3 继承和多态

在OOP程序设计中，当我们定义一个Class的时候，可以从某个现有的Class继承，新的Class类称为子类，而被继承的类称为基类，父类或者超类。

  1. # 基类
  2. class Animal(object):
  3.     def run(self):
  4.         print('Animal is running...')
  5. # 子类
  6. class Dog(Animal):
  7.     pass

继承的好处:

  1. 子类可以继承父类所有的方法。

  2. 子类可以自己增加方法。

    当子类和父类同时拥有相同的方法时，子类覆盖了父类的方法，执行子类的方法，称之为多态。
    多态的好处，就是著名的开闭原则。对拓展开放，对修改关闭。
    静态语言VS动态语言
    对于静态语言(Java)来说，如果需要传入Animal类型，则传入的对象必须是Animal类型或者它的子类，否则，则无法调用run()方法。
    对于动态语言(Python)来说，则不一定需要传入Animal类，我们只需要保证传入的对象一个run()方法就行。

  1. class Timer(object):
  2.     def run(self):
  3.         print('Start...')

1.4 获取对象信息

  1. 判断对象类型，使用type()。
  2. 对于class继承关系来说，使用type()就不方便，要判断class的类型，可以使用isinstance()函数。能用type()判断的基本类型也可以用isinstance()判断。
  3. 如果要获得一个对象的所有属性和方法，可以使用dir()函数，返回一个包含字符串的list。
  1. # type()判断对象类型
  2. >>> type(abs)
  3. <class 'builtin_function_or_method'>
  4. >>> type(a)
  5. <class '__main__.Animal'>
  6. # isinstance()判断对象类型
  7. >>> isinstance([1, 2, 3], (list, tuple))
  8. True
  9. >>> isinstance((1, 2, 3), (list, tuple))
  10. True
  11. # dir()获取对象的所有属性和方法
  12. >>> dir('ABC')
  13. ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

1.5 实例属性和类属性

由于Python是动态语言，根据类创建的实例可以绑定任意属性。
在编写程序的时候，千万不要把实例属性和类属性使用相同的名字，因为相同名称的实例属性将屏蔽掉类属性，当删除实例属性的时候，再使用相同的名称，访问到的将是类属性。

  1. >>> class Student(object):
  2. ...     name = 'Student'
  3. ...
  4. >>> s = Student() # 创建实例s
  5. >>> print(s.name) # 打印name属性，因为实例并没有name属性，所以会继续查找class的name属性
  6. Student
  7. >>> print(Student.name) # 打印类的name属性
  8. Student
  9. >>> s.name = 'Michael' # 给实例绑定name属性
  10. >>> print(s.name) # 由于实例属性优先级比类属性高，因此，它会屏蔽掉类的name属性
  11. Michael
  12. >>> print(Student.name) # 但是类属性并未消失，用Student.name仍然可以访问
  13. Student
  14. >>> del s.name # 如果删除实例的name属性
  15. >>> print(s.name) # 再次调用s.name，由于实例的name属性没有找到，类的name属性就显示出来了
  16. Student

2. 面向对象高级编程

2.1 使用_slots_

为了限制实例的属性，Python允许在定义class的时候，定义一个特殊的_slots_变量。

  1. class Student(object):
  2.     __slots__ = ('name', 'age') # 用tuple定义允许绑定的属性名称
  1. >>> s = Student() # 创建新的实例
  2. >>> s.name = 'Michael' # 绑定属性'name'
  3. >>> s.age = 25 # 绑定属性'age'
  4. >>> s.score = 99 # 绑定属性'score'
  5. Traceback (most recent call last):
  6.   File "<stdin>", line 1, in <module>
  7. AttributeError: 'Student' object has no attribute 'score'

使用_slots_要注意，_slots_定义的属性仅对当前类实例起作用，对继承的子类是不起作用的。

2.2 使用@property

在绑定属性的时候，我们不能直接把属性暴露出去，为了限制属性的范围，可以通过get和set方法检查参数。
Python内置的@property装饰器就是负责把一个方法变成属性调用。

  1. class Student(object):
  3.     @property
  4.     def score(self):
  5.         return self._score
  7.     @score.setter   # 只定义getter方法，不定义setter方法就表明该属性只读
  8.     def score(self, value):
  9.         if not isinstance(value, int):
  10.             raise ValueError('score must be an integer!')
  11.         if value < 0 or value > 100:
  12.             raise ValueError('score must between 0 ~ 100!')
  13.         self._score = value

2.3 多重继承

通过多重继承，一个子类就可以同时获得多个子类的所有功能。
在设计类的继承关系时，通常，主线是单一继承下来的，如果需要混入”额外”的功能，通常就需要多重继承来实现。这种设计称之为”MixIn”。
我们不需要负责庞大的继承链，只有选择组合不同类的功能，就可以快速构造出所需的子类。

2.4 定制类

_str_
print打印实例的时候，会出现一堆类似<main.Student object at 0x109afb190>，为了打印好看，我们只需要定义一个_str_方法。但是直接打印的时候还是会出现类似的问题，那么再定义一个_repr_()就会与_str_()效果一样。

  1. class Student(object):
  2.     def __init__(self, name):
  3.         self.name = name
  4.     def __str__(self):
  5.         return 'Student object (name=%s)' % self.name
  6.     __repr__ = __str__

_iter_
如果一个类想被用于for…in…循环，类似list和tuple这样，就必须实现一个_iter_方法，该方法返回一个迭代对象。

  1. class Fib(object):
  2.     def __init__(self):
  3.         self.a, self.b = 0, 1 # 初始化两个计数器a，b
  5.     def __iter__(self):
  6.         return self # 实例本身就是迭代对象，故返回自己
  8.     def __next__(self):
  9.         self.a, self.b = self.b, self.a + self.b # 计算下一个值
  10.         if self.a > 100000: # 退出循环的条件
  11.             raise StopIteration();
  12.         return self.a # 返回下一个值
  1. >>> for n in Fib():
  2. ...     print(n)
  3. ...
  4. 1
  5. 1
  6. 2
  7. 3
  8. 5
  9. ...
  10. 46368
  11. 75025

_getitem_
按照下标取出元素，实现切片的功能，就要实现_getitem_方法。

  1. class Fib(object):
  2.     def __getitem__(self, n):
  3.         a, b = 1, 1
  4.         for x in range(n):
  5.             a, b = b, a + b
  6.         return a
  7.      if isinstance(n, slice): # n是切片
  8.             start = n.start
  9.             stop = n.stop
  10.             if start is None:
  11.                 start = 0
  12.             a, b = 1, 1
  13.             L = []
  14.             for x in range(stop):
  15.                 if x >= start:
  16.                     L.append(a)
  17.                 a, b = b, a + b
  18.             return L

_getattr_
正常情况下，当我们调用类的方法或属性的时候，如果不存在就会报错，为了避免这个错误，Python中的_getattr_()方法能动态返回一个属性。

  1. class Student(object):
  3.     def __init__(self):
  4.         self.name = 'Michael'
  6.     def __getattr__(self, attr):
  7.         if attr=='score':
  8.             return 99

_call_
一个对象的实例可以有自己的属性和方法，当我们调用实例方法时，我们用instance.method()来调用，但是任何类只需要定义一个_call_()方法，就可以直接对实例进行调用。

  1. class Student(object):
  2.     def __init__(self, name):
  3.         self.name = name
  5.     def __call__(self):
  6.         print('My name is %s.' % self.name)
  7.     ---
  8.     >>> s = Student('Michael')
  9.     >>> s() # self参数不要传入
  10.     My name is Michael.

通过callable()函数，我们就可以判定一个对象是否是”可调用”对象。

2.5 使用枚举类

当我们需要定义常量的时候，一个办法就是用大写常量名通过整数定义，更好的办法是为这样的枚举类型定义一个class类型，然后，每个常量是class的唯一的实例。Python提供了Enum类来实现这个功能。

  1. from enum import Enum
  3. Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))
  4. # 这样我们就获得了Month类型的枚举类，可以直接使用Month.Jan来引用一个变量，或者枚举它的所有成员。
  5. for name, member in Month.__members__.items():
  6.     print(name, '=>', member, ',', member.value)

如果需要更精确的控制枚举类型，可以从Enum派生出自定义类。

  1. from enum import Enum, unique
  3. @unique   # @unique装饰器可以帮助我们检查保证没有重复值
  4. class Weekday(Enum):
  5.     Sun = 0 # Sun的value被设定为0
  6.     Mon = 1
  7.     Tue = 2
  8.     Wed = 3
  9.     Thu = 4
  10.     Fri = 5
  11.     Sat = 6
  12.  # 访问枚举类型的若干种方法
  13.  >>> day1 = Weekday.Mon
  14. >>> print(day1)
  15. Weekday.Mon
  16. >>> print(Weekday.Tue)
  17. Weekday.Tue
  18. >>> print(Weekday['Tue'])
  19. Weekday.Tue
  20. >>> print(Weekday.Tue.value)
  21. 2
  22. >>> print(day1 == Weekday.Mon)
  23. True
  24. >>> print(day1 == Weekday.Tue)
  25. False
  26. >>> print(Weekday(1))
  27. Weekday.Mon
  28. >>> print(day1 == Weekday(1))
  29. True
  30. >>> Weekday(7)
  31. Traceback (most recent call last):
  32.   ...
  33. ValueError: 7 is not a valid Weekday
  34. >>> for name, member in Weekday.__members__.items():
  35. ...     print(name, '=>', member)
  36. ...
  37. Sun => Weekday.Sun
  38. Mon => Weekday.Mon
  39. Tue => Weekday.Tue
  40. Wed => Weekday.Wed
  41. Thu => Weekday.Thu
  42. Fri => Weekday.Fri
  43. Sat => Weekday.Sat
  44.  # 既可以根据成员名称引用枚举常量，又可以根据value的值获得枚举常量。

2.6 使用元类

class的定义是运行时动态创建的，而创建class的方法就是使用type()函数。
type()函数可以查看一个类的类型或变量的类型，既可以返回一个对象的类型，又可以创建出新的类型。

  1.  >>> def fn(self, name='world'): # 先定义函数
  2. ...     print('Hello, %s.' % name)
  3. ...
  4. >>> Hello = type('Hello', (object,), dict(hello=fn)) # 创建Hello class
  5. >>> h = Hello()
  6. >>> h.hello()
  7. Hello, world.
  8. >>> print(type(Hello))
  9. <class 'type'>
  10. >>> print(type(h))
  11. <class '__main__.Hello'>

除了使用type()动态创建类以外，要控制类的创建行为，还可以使用metaclass。
metaclass，直译为元类，简单的解释就是，当我们定义了类之后，就可以根据类创建出实例，所以，先定义类，然后创建实例。
先定义metaclass，就可以创建类，最后创建实例。

感谢廖雪峰的官方网站提供的教程。Python学习笔记系列都基于廖老师的教程。





【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/aniudcs/p/5971163.html