类与对象
类就是定义种类的东西的方式，它反映了在程序领域中的真实对象。对象则是类创建的实例。类是一种产生实例的工厂
class Foo:
def __init__(self):
pass
def buy(self)
pass
obj = Foo()
在上面，Foo就是一个类，而obj则是类创建的实例-->对象。
继承
在python中，实例从类中继承，而类继承于父类。
class Foo:
def __init__(self):
pass
def buy(self)
pass
class Foo1(Foo):
def buy(self):
print("buy")
当子类调用父类方法时，使用super()方法
class Foo1(Foo):
def __init__(self):
super().__init()
类的特性
静态字段：
静态字段存在类中，如
class Foo:
def __init__(self,name):
self.name = name
country = 'China'
country就是静态字段，self.name就是普通字段
普通字段属于对象，而静态字段则属于类(根据命令空间可知)。当对象在搜索属性时（obj.country)，会在对象内搜索属性，然后在其上所有可读的类（使用继承搜索流程）静态字段在内存中只保存一份，而普通字段第个对象都要保存一份。对象中共同的字段可以用静态字段，这样就不用重复创建字段，在类中保存一份。
静态方法
由类调用，通过staticmethod装饰；类方法，由类调用，至少有一个cls参数，执行类访问时，自动将调用该方法的类复制给cls。普通方法，由对象调用，至少有一个self参数，执行该方法时，自动将点号前面的对象（执行方法的对象）赋给self。
class Foo:
@staticmethod #静态方法
def func(arg1, arg2):
print(arg1, arg2)
@classmethod #类方法
def func1(cls):
print(cls)
def func2(self): #普通方法
print("normal method")
obj = Foo()
obj.func(1,2)
obj.func1()
obj.func2()
相同点，对于所有方法而言，均属于类中，所以只在内在中保存一份
不同点，方法调用者不同，调用方法传入的参数也不同。
方法当作字段访问
class Foo:
@property
def show(self):
print('show')
Foo.show
当方法作字段时，可以像字段那样进行修改,但是需要装饰
class Foo
@property
def show(self):
print('show')
@end.setter
def show(self):
pass
obj = Foo()
obj.end= '123'
成员修饰符
私有成员，只能内部访问，只能自己访问，子类也不能访问
class Foo:
__name = '...' #私有成员
def fetch():
print(__name)
Foo.fetch()
但是可以通过 _类名__name 访问
对象后面加括号：
obj = Foo()
obj() #执行对象的__call__ 方法
索引与分片
对实例的索引和分片运算，调用__getitem__方法。赋值使用__setitem__方法。
class Foo:
data = [1,2,3,4,5]
def __getitem__(self, index):
return self.data[index]
def __setitem__(self, index, value):
self.data[index] = value
def __delitem__(self, index):
pass
obj = Foo()
obj['abc'] = 'abc' #当通过索引赋值，则会调用__setitem__
del obj['abc'] #通过索引删除时，调用__delitem
ret = obj['abc'] #通过索引取值，调用__getitem__
_ __getitem__也可以是python中一种重载迭代的方式 。如果在类中定义了这个方法，则for在每次循环时都会调用_getitem_ 这个方法。 _
class Foo:
def __getitem__(self, index):
return self.data[index]
obj = Foo()
obj.data = [1,2,3,4,5]
for i in obj:
print(i, end=' ')
#结果----> 1 2 3 4 5
索引使用get/setitem 而点号使用get/settattr方法，在反射上用到这两个方法。判断和获取方法。而导入模块则用_import_()这个方法
属性引用
当进行点号运算时，则会调用__getattr__方法。
class Foo:
#重写__getattr__
def __getattr__(self, attrname):
if attrname == 'age':
return 40
else:
raise AttributeError,attrname
obj = Foo()
obj.age #return 40
obj.name #return error
而进行属性赋值时，则调用__setattr_方法
如obj.name='xxx'，则内部会调用self._setattr_('attr', value)。而赋值操作又会调用_setattr_，导致无穷递归循环。如果想使用这个方法，则要通过字典做索引运算来做赋值。
class Foo:
def _setattr__(self, attr, value):
self.__dict__[attr] = value
obj = Foo()
obj.name='xxoo' #赋值操作调用__setattr__方法
迭代器对象
之前我们使用了__getitem__方法来迭代对象，但python中的所有迭代都使用__iter__方法。迭代环境是通过调用内置函数iter去尝试寻找__iter__方法来实现的，而这种方法应该返回一个迭代器对象，如果己经提供，python就会重复调用这个迭代器的next方法，直到发生异常。如果没有找到__iter__方法，则会调用 __getitem__方法。
class Foo:
def __init__(self, start, stop):
self.value = start - 1
self.stop = stop
def __iter__(self):
return self
def __next__(self):
if self.stop == self.value:
raise StopIteration
self.value += 1
return self.value ** 2
obj = Foo(1,5)
for i in obj:
print (i) #结果 --->1,4,9,16,25
X = foo(1,10)
I = iter(X)
next(I) #1
next(I) #4