1.描述符（）：将某种特殊类型的类的实例，指派给另一个类的属性。 描述符就是将某种特殊类型的类的实例指派给另一个类的属性 特殊类型的要求，至少实现以下三个方法： get(self, instance, owner) 用于访问属性，它返回属性的值 set(self, instance, value) 将在属性分配操作中调用，不返回任何内容 delete(self, instance) 控制删除操作，不返回任何内容 注：instance指的就是另一个类的实例对象。owner指的就是另一个类的类本身。value指的是实例对象的值。(描述符就是一个类，实现至少三种方法的任意类）
将描述性类MyDecriptor，指派给Test的属性
>>> class MyDescriptor:
def __get__(self, instance, owner):
print("getting...", self, instance, owner)
def __set__(self, instance, value):
print("setting...", self, instance, value)
def __delete__(self, instance):
print("deleting...", self, instance)
>>> class Test:
x = MyDescriptor()
>>> test = Test()
>>> test.x
getting...
>>> test
>>> test.x = 'fuck'
setting... fuck
>>> del test.x
deleting...
test.x 就是取值操作，使用的是“__get__”函数。返回值包括MyDecriptor类实例对象，Test的实例对象test以及所属的类。
test.x = 'lalala' 是赋值操作，使用的是“__set__”函数，返回值包括 MyDecriptor类实例对象，Test的实例对象test以及被赋予的值。
del test.x 就是删除操作
还可以使用属性类型的方法。通过使用 property()，可以轻松地为任意属性创建可用的描述符。创建 property() 的语法是 property(fget=None, fset=None, fdel=None, doc=None)，其中： fget：属性获取方法 fset：属性设置方法 fdel：属性删除方法 doc：docstring
class Person(object):
def __init__(self):
self._name = ''
def fget(self):
print ("Getting: %s" % self._name)
return self._name
def fset(self, value):
print ("Setting: %s" % value)
self._name = value.title()
def fdel(self):
print ("Deleting: %s" %self._name)
del self._name
name = property(fget, fset, fdel, "I'm the property.")
>>> p = Person()
>>> p.name = 'haha'
Setting: haha
>>> p.name
Getting: Haha
'Haha'
>>> del p.name
Deleting: Haha
自己实现property()函数
>>> class MyProperty:
def __init__(self, fget=None, fset=None, fdel=None):
self.fget = fget
self.fset = fset
self.fdel = fdel
def __get__(self, instance, owner):
return self.fget(instance)
def __set__(self, instance, value):
self.fset(instance, value)
def __delete__(self, instance):
self.fdel(instance)
#以上代码就是一个描述符类的代码
>>> class C:
def __init__(self):
self._x = None
def getX(self):
return self._x
def setX(self, value):
self._x = value
def delX(self):
del self._x
x = MyProperty(getX, setX, delX)
>>> c=C()
>>> c.x = 'fuck'
>>> c.x
'fuck'
2.迭代器 迭代器通常指 序列：字符串 字典 列表 元组….迭代器可以理解为一个对数据的打包
# 列表的迭代
list = [12, 35, 67, 89]
for i in list:
print(i, end=' ')
print("\n")
#字典的迭代
dict1 ={"lmf": "1", "cym": "2", "czh": "3"}
for i in dict1: # 迭代的是键
print(i, dict1[i])
12 35 67 89
lmf 1
cym 2
czh 3
迭代操作的内置函数：
iter() 得到容器对象的迭代器
next() 返回下一个值 如果没有下个值，就会抛出一个异常
str = "wlytlj"
a = iter(str) # iter获取迭代器对象返回给 a
while True:
try:
i = next(a)
except StopIteration: # 没有next以后抛出stopIteration异常 捕捉异常 结束死循环
break
print(i)
关于迭代的魔法方法
_ _ iter _ _() ：返回迭代器本身 return self
_ _ next _ _() ：决定了迭代器的迭代规则
class Fib():
def __init__(self, n= 10):
self.a = 0
self.b = 1
self.n = n
def __iter__(self):
print("iter...")
return self
def __next__(self):
print("next...", end=" ")
self.a, self.b = self.b, self.a+self.b
if self.a >self.n:
raise StopIteration # 抛出异常
return self.a
fib = Fib()
for i in fib:
print(i)
iter...
next... 1
next... 1
next... 2
next... 3
next... 5
next... 8
next... 13
next...
3.生产器 生成器 是迭代的一种方法，在普通的函数里加一个 yield 语句就可以实现 模仿协同程序 ( 协同程序： 可以运行的独立函数调用，函数可以暂停或挂起，并在需要的时候从程序离开的地方继续或者重新开始 ) 生成器是一个特殊的函数，调用可以中断或者暂停，并且通过yield返回一个生成器对象。 yield关键字，可以这样理解：当函数运行到这一行的时候，程序会从这里暂停，yield相当于return会返回，当下次迭代时候，则会从yield的下一行代码开始执行。
迭代器实现依赖于可迭代对象，并不一定使用到了生成器函数
但是使用了生成器函数的对象，其对象是可迭代的
4.推导式 
#列表推导式 40以内 可以被2 整除，不能被3整除的数字
list = [i for i in range(100) if not(i % 2) and (i % 3)]
print(list)
#字典推导式 10以内被2 整除的情况
dic = {i : (i %2) == 0 for i in range(10)}
print(dic)
#集合推导式 找出一个列表里可以被2整除的数字，组成一个集合
myset = {i for i in [1,3,2,1,2,6,5,3,4,1,2,3] if (i % 2) == 0}
#元组 生成器推导式
tup = (i for i in range(10) if i%2)
print(tup)
print('\n', sum(i for i in range(10) if i % 2)) #将生成器对象作为函数参数
#读取生成器
for i in tup:
print(i, end=' ')
并行迭代：简单来说就是程序可以同时迭代多个序列 
>>>for each in zip(name,old): # 从字面理解,就是把二个对象压缩成一个到一个对象
print(each)
('tang', '12')
('liu', '24')
('mei', '23')
('yejieyi', '25')
>>>for a,b in zip(name, old):
print(a,'is',b,'years old')
tang is 12 years old
liu is 24 years old
mei is 23 years old
yejieyi is 25 years old
5.装饰器
