python-OOP高级编程

class Student(object):
	pass

std = Student()
std.name = 'Alexander'  #给实例动态绑定属性

def set_age(self, age):  #给实例定义一个函数作为方法
	self.age = age	

from types import MethodType
std.set_age = MethodType(set_age, std) #给实例绑定方法

std.set_age(26)  #调用方法
print(s.age)	

Output:26

对实例std绑定的方法 set_age()对其他实例是不起作用的。为了给所有实例都绑定方法，
可以对class绑定方法：
def set_score(self, score):
	self.score = score

Student.set_score = set_score  #Student类下的所有实例都可以调用该方法

std.set_score(100)
print(std.score)

Output:100	

#通常情况下，上面的set_score方法可以直接定义在class中，但动态绑定允许我们在程序
#运行的过程中动态给class加上功能，这在静态语言中很难实现。


1.使用__slots__:用于限制实例的属性
Python允许在定义class时，定义一个特殊的__slots__变量来限制该class实例能添加的属性

class Student(object):
	__slots__ = ('name', 'age')  #用tuple定义允许绑定的属性名称

std = Student()
std.name = 'Alex'
std.age = 26
std.score = 99
print(std.name, std.age, std.score)
Output:
Traceback (most recent call last):
  File "F:\Users\AlexanderShaw\PythonLearning\OnlyTest.py", line 7, in <module>
    std.score = 99
AttributeError: 'Student' object has no attribute 'score'

需要注意的是，__slots__定义的属性仅对当前类实例起作用，对继承的子类是不起作用的。
除非在子类中也定义__slots__，这样子类实例允许定义的属性就是自身的__slots__加上
父类的__slots__。

2.使用@property

#使用get,set方法对属性、传入参数进行检查,封装内部数据，不能在外部随意修改
class Student(object):

	def get_ score(self):
		return self.__score

	def set_score(self, value):
		if not isinstance(value, int):	
			raise ValueError('Score must be an integer!')
		if value < 0 or value >	100:
			raise ValueError('Score must between 1~100!')
		self.__score = score	

有没有既能检查参数，又可以用类似属性这样简单的方式来访问类的变量呢？
装饰器（decorator）可以给函数动态加上功能，对于类的方法，装饰器一样起作用。
Python内置的@property装饰器就是负责把一个方法变属性调用的：
class Student(object):
	@property
	def score(self):
		return self.__score

	@score.setter
	def score(self, value):
		if not isinstance(value, int):
			raise ValueError('Score must be integer!')	
		if value < 0 or value > 100:
			raise  ValueError('Score must between 1 ~ 100 !')
		self.__score = value		

把一个getter方法变成属性，只需要加上@property就可以.
此时，@property本身又创建了另一个装饰器 @score.setter，
负责把一个setter方法变成属性赋值，于是，我们就拥有一个可控的属性操作：
>>> std = Student()
>>> std.score = 60 # OK，实际转化为std.set_score(60)
>>> std.score # OK，实际转化为std.get_score()
60
>>> std.score = 9999
Traceback (most recent call last):
  ...
ValueError: score must between 0 ~ 100!

#不定义setter方法就是只读属性
class Student(object):

	@property
	def birth(self):
		return self.__birth
	@birth.setter
	def birth(self, value):
		self.__birth = value

	@property
	def age(self):
		return 2018 - self.__birth
	#此处的age()就是只读属性，因为可以根据birth和当前时间计算	
	

3.多重继承:一个子类可以拥有多个父类的所有功能	
#动物 -> 哺乳动物和鸟类 -> 能跑的和不能跑的哺乳动物和鸟类 -> 宠物和非宠物。。。

#主类，动物
class Animal(object):
	pass

#哺乳动物
class Mammal(Animal):
	pass

#鸟类
class Bird(Animal):
	pass

#各种动物
class Dog(Mammal):
	pass

class Parrot(Bird):
	pass


#现在给动物再加上Runnable和Flybale功能，只需先定义功能类：
class Runnable(object):
	def run(self):
		print("Running...")
class Flyable(object):
	def fly(self):
		print('Flying...')

#对于需要功能的动物，只需要多继承一个功能类即可
class Bat(Bird, Flyable):
	pass	
class Dog(Mammal, Runnable):
	pass

通过多重继承可以给子类添加额外的功能，这种设计称之为Mixln。MixIn的目的就是给一个
类增加多个功能，这样，在设计类的时候，我们优先考虑通过多重继承来组合多个MixIn的
功能，而不是设计多层次的复杂的继承关系。						


4.定制类
__slots__:限制实例的属性
__len__():可以让class作用于 len()
__str__():返回定义好格式的字符串，便于观察

class Student(object):
	def __init__(self, name):
		self.name = name

print(Student('Alex'))	

Output:<__main__.Student object at 0x000001C5A74CF5F8>


#定义__str__()方法，使输出美观且便于观察实例内部重要数据
class Student(object):
	def __init__(self, name):
		self.name = name
	
	def __str__(self):
		return 'Student object (name %s)' % self.name

print(Student('Alex'))	

Output:Student object (name Alex)		

>>> s = Student('Alex')
>>> s
<__main__.Student object at 0x000002217DEFCD30>
'''
	直接显示变量，调用的不是__str__()，而是 __repr__()。
	区别是：前者返回用户看到的字符串，后者返回程序员看到的字符串
	__repr__()是为程序调试服务的。
	解决办法是在定义一个__repr__().	
	通常 __str__()和 __repr__()代码都是一样的，所以，可以偷懒写成：
class Student(object):
    def __init__(self, name):
        self.name = name
    def __str__(self):
        return 'Student object (name=%s)' % self.name
    __repr__ = __str__

'''
>>> print(s)
Student object(name  Alex)

__iter__()：如果一个类想被用于for...in循环，类似list或者tuple，就必须实现一个
__iter__()方法。该方法返回一个迭代对象，for循环就会不断调用该迭代对象的 __next__()
方法拿到循环的戏一个值，知道遇到StopIteration错误退出循环。
#斐波那契数列
class Fib(object):
	def __init__(self):
		self.a, self.b = 0, 1    #初始化两个计数器

	def __iter__(self):
		return self				#实例本身是迭代对象，返回自身

	def __next__(self):
		#计算下一个值
		self.a, self.b = self.b, self.a + self.b		
		if self > 100: #退出循环的条件
			raise StopIteration()
		return self.a 			#返回下一个值
		
for n in Fib():
	print(n)

Output:
1
1
2
3
5
8
13
21
34
55
89

__getitem__():使class像list一样取特定位置的值
#斐波那契数列
class Fib(object):
    def __init__(self):
        self.a, self.b = 0, 1    #初始化两个计数器

    def __iter__(self):
        return self             #实例本身是迭代对象，返回自身

    def __next__(self):
        #计算下一个值
        self.a, self.b = self.b, self.a + self.b        
        if self.a > 100: #退出循环的条件
            raise StopIteration()
        return self.a           #返回下一个值

    def __getitem__(self, n):
        a, b = 1, 1
        for x in range(n):
            a, b = b, a + b
        return a    
        
f = Fib()
print(f[5]) 
Output:8

对于list中的切片功能，在class中不能直接用。因为 __getitem__()传入的参数可能是一个
int，也可能是一个切片对象slice，所以要进行判断：

class Fib(object):

	def __getitem__(self, n):	
		if isinstance(n, int):			#如果是int，n是索引
			a, b = 1, 1
			for x in range(n):
				a, b = b, a + b
			return a
		if isinstance(n, slice):			#n是切片
			start = n.start
            stop = n.stop
            if start is None:
                start = 0
            a, b = 1, 1
            L = []
            for x in range(stop):
                if x >= start:
                    L.append(a)
                a, b = b, a + b
            return L

f = Fib()
print(f[0: 5])
print(f[4: 7])

Output:[1, 1, 2, 3, 5]
	   [5, 8, 13]
#但没有对step参数进行处理
此外，如果把对象看成dict，__getitem__()的参数也可能是一个可以作key的object，
例如str。与之对应的是 __setitem__()方法，把对象视作list或dict来对集合赋值。最后，
还有一个 __delitem__()方法，用于删除某个元素。

__getattr__():正常情况下，当我们调用类的方法或属性时，如果不存在，就会报错。
写一个 __getattr__()方法，动态返回一个属性。
class Student(object):

    def __init__(self):
        self.name = 'Michael'
>>> s = Student()
>>> print(s.name)
Michael
>>> print(s.score)
Traceback (most recent call last):
  ...
AttributeError: 'Student' object has no attribute 'score'        

#添加__getattr__()方法
class Student(object):

    def __init__(self):
        self.name = 'Michael'

    def __getattr__(self, attr):
        if attr=='score':
            return 99
当调用不存在的属性时，比如score，Python解释器会试图调用
__getattr__(self, 'score')来尝试获得属性，我们就有机会返回score的值：
>>> s = Student()
>>> s.name
'Michael'
>>> s.score
99 

返回函数也是完全可以的：
class Student(object):

    def __getattr__(self, attr):
        if attr=='age':
            return lambda: 25  
只是调用方式要变为：
>>> s.age()
25 
'''
	注意，只有在没有找到属性的情况下，才调用__getattr__，已有的属性，
	比如name，不会在__getattr__中查找。
	此外，注意到任意调用如s.abc都会返回None，这是因为我们定义的__getattr__默认
	返回就是None。要让class只响应特定的几个属性，我们就要按照约定，抛出
	AttributeError的错误：
class Student(object):
    def __getattr__(self, attr):
        if attr=='age':
            return lambda: 25
        raise AttributeError('\'Student\' object has no attribute \'%s\'' % attr)
'''   

__call__(): 任何类，只需要定义一个_ _call__()方法，就可以直接对实例进行调用。
class Student(object):
    def __init__(self, name):
        self.name = name

    def __call__(self):
        print('My name is %s.' % self.name)

>>> s = Student('Michael')
>>> s() # self参数不要传入
My name is Michael.

怎么判断一个变量是对象还是函数呢？其实，更多的时候，我们需要判断一个对象是否能被
调用，能被调用的对象就是一个Callable对象，比如函数和我们上面定义的带有
 __call__()的类实例:
>>> callable(Student())
True
>>> callable(max)
True
>>> callable([1, 2, 3])
False
>>> callable(None)
False
>>> callable('str')
False
通过 callable()函数，我们就可以判断一个对象是否是“可调用”对象。 


5.使用枚举类
普通定义常量：
JAN = 1
FEB = 2
MAR = 3
...
NOV = 11
DEC = 12

好处是简单，缺点是int类型，并且仍然是变量。
更好的方法是为这样的枚举类型定义一个class类型，每个常量都是class的一个唯一实例。
Python提供了Enum类来实现这个功能：
from enum import Enum
Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 
						'Sep', 'Oct', 'Nov', 'Dec'))

可以直接使用Month.Jan来引用一个常量，或者枚举它的所有成员：
for name, member in Month.__members__.items():
	print(name, '=>', member, ',', member.value)
#value属性是自动赋给成员的int常量。默认从1开始计数。
Output:
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派生自定义类：
from enum import Enum

@unique				#@unique装饰器可以帮助检查保证没有重复值
class Weekday(Enum):
	Sun = 0  #Sun的value设定为0
	Mon = 1
	Tue = 2
	Wen = 3
	Thu = 4
	Fri = 5
	Sta = 6

访问这些枚举类型（既可以用成员名称引用枚举常量，也可以直接根据value的值获取）：
>>> day1 = Weekday.Mon
>>> print(day1)
Weekday.Mon
>>> print(Weekday.Tue)
Weekday.Tue
>>> print(Weekday['Tue'])
Weekday.Tue
>>> print(Weekday.Tue.value)
2
>>> print(day1 == Weekday.Mon)
True
>>> print(day1 == Weekday.Tue)
False
>>> print(Weekday(1))
Weekday.Mon
>>> print(day1 == Weekday(1))
True
>>> Weekday(7)
Traceback (most recent call last):
  ...
ValueError: 7 is not a valid Weekday
>>> for name, member in Weekday.__members__.items():
...     print(name, '=>', member)
...
Sun => Weekday.Sun
Mon => Weekday.Mon
Tue => Weekday.Tue
Wed => Weekday.Wed
Thu => Weekday.Thu
Fri => Weekday.Fri
Sat => Weekday.Sat	

6.使用元类
动态语言和静态语言最大的不同，就是函数和类的定义，不是编译时定义的，而是
运行时动态创建的。                                         
type():查看一个类型或者变量的类型。
我们说class的定义是运行时动态创建的，而创建class的方法就是使用 type()函数。

class Hello(object):
	def hello(self, name = 'world'):
		print('Hello, %s' % name)

#载入hello模块,依次执行该模块的所有语句
#执行结果就是动态创建出一个Hello的class对象
>>> from hello import Hello 	
>>> h = Hello()
>>> h.hello()
Hello, world.
>>> print(type(Hello))
<class 'type'>
>>> print(type(h))
<class 'hello.Hello'>

type()函数可以返回一个对象的类型，又可以创建出新的类型。

#通过type()创建Hello类
def fn(self, name = 'world'):
	print('Hello, %s' % name)

#创建Hello类
Hello = type('Hello', (object), dict(hello = fn))

要创建一个class对象，type()函数依次传入三个参数：
1.class的名称
2.继承的父类的集合（python支持多继承，如果只有一个父类，写成tuple的单元素写法）
3.class的方法名称与函数绑定（上例将函数fn绑定到方法名hello上）

通过 type()函数创建的类和直接写class是完全一样的，因为python解释器遇到class
定义时，仅仅是扫描一下class定义的语法，然后调用 type()函数创建出class。	

metaclass（元类）:
当我们定义了类以后，就可以根据这个类创建出实例，所以：先定义类，然后创建实例。
但是如果我们想创建出类呢？那就必须根据metaclass创建出类，所以：先定义metaclass，
然后创建类。连接起来就是：先定义metaclass，就可以创建类，最后创建实例。
所以，metaclass允许你创建类或者修改类。
换句话说，你可以把类看成是metaclass创建出来的“实例”。