Python(6)：序列推导式+迭代器+可迭代对象+生成器+闭包+装饰器

一、推导式

1.列表推导式

• 形式1：变量名=[表达式 for 变量 in 列表 ]
• 形式2：变量名=[表达式 for 变量 in 列表 if 条件 ]

---

例题1：求平方

a = [1, 2, 3, 4, 5]  # 
# ------------------------------------------------方法一
b = [i * i for i in a]
print(b)
# ------------------------------------------------方法二
x = map(lambda c: c * c, a)
print(list(x))
# ---------------------------------------------------方法三
def pingfang(a):
    return a * a
d = [pingfang(i) for i in a]
print(d)

结果：[1, 4, 9, 16, 25]

---

例题2：推导式求大于2的奇数

a=[1,2,3,4,576,8,9,7]
b=[i for i in a if i%2==1 and i>2]#if一个条件
c=[i for i in a if i%2==1 if i>2]#if条件下又一个if
print(b)#[3, 9, 7]
print(c)#[3, 9, 7]

---

例题3：还原序列

a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
c = [[3 * i + j + 1 for j in range(3)] for i in range(3)]

print(c)#-------------[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

---

2.字典推导式

k,v值互换：

a={1:2,3:4}
b={v:k for k,v in a.items()}
print(b)#——----------------------------{2: 1, 4: 3}

#方法二
c={k:v for k,v in zip('abc','123')}
print(c)#--------------------------{'a': '1', 'b': '2', 'c': '3'}

字典的get方法

a={1:2,3:4}
print(a.get(1))
print(a.get(1,'0'))#查找到就返回自己的
print(a.get(5))#没查找到会返回none
print(a.get(5,'8'))#没查找到会返回自己写的指定值

3.集合推导式

自动去重

a = {1, 2, 3, 4, 1, 2, 4}
b = {i * i for i in a}

print(b) # {16, 1, 4, 9}

二、可迭代对象

1. 实现了__iter__方法的对象就叫做可迭代对象
2. __iter__方法的作用就是返回一个迭代器对象。直观理解就是能用for循环进行迭代的对象就是可迭代对象。比如：字符串，列表，元祖，字典，集合等等，都是可迭代对象。

三、迭代器

1.迭代器的特点

• 迭代是Python最强大的功能之一，是访问集合元素的一种方式。
• 迭代器是一个可以记住遍历的位置的对象。
• 迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
• 迭代器有两个基本的方法：iter() 和 next()。
• 字符串，列表或元组对象都可用于创建迭代器：

我们创建一个迭代器

迭代器对象可以使用常规for语句进行遍历

2.类中的迭代器

1.把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__() 。
2.__iter__() 方法返回一个特殊的迭代器对象， 这个迭代器对象实现了 __next__() 方法并通过 StopIteration 异常标识迭代的完成。
3.__next__() 方法（Python 2 里是 next()）会返回下一个迭代器对象。

创建一个返回数字的迭代器，初始值为 1，逐步递增 1：

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self

  def __next__(self):
    x = self.a
    self.a += 1
    return x

myclass = MyNumbers()
myiter = iter(myclass)

print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))

StopIteration
StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况，在 next() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。

在 20 次迭代后停止执行：

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self

  def __next__(self):
    if self.a <= 20:
      x = self.a
      self.a += 1
      return x
    else:
      raise StopIteration

myclass = MyNumbers()
myiter = iter(myclass)

for x in myiter:
  print(x)

四、生成器

• 使用了 yield 的函数被称为生成器（generator）。
• 跟普通函数不同的是，生成器是一个返回迭代器对的象函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。
• 在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行next() 方法时从当前位置继续运行。

以下实例使用 yield 实现斐波那契数列：

# 斐波那契数列指的是这样一个数列：1，1，2，3，5，8，13，21，34，55，89...
# 这个数列从第3项开始，每一项都等于前两项之和。

# 生成器函数 - 斐波那契
def fibonacci(n):
    a, b = 0, 1
    for count in range(1, n + 1):
        a, b = b, a + b
        yield a


f = fibonacci(10)  # f 是一个迭代器，由生成器返回生成

while True:
    try:
        print(next(f), end=",")
    except StopIteration:
        break

五、闭包

闭包函数要有三个要求：

1. 闭包函数必须有内嵌函数
2. 内嵌函数必须要引用外层函数的变量
3. 闭包函数返回内嵌函数的地址

看这个例子：

def fun1():
    name = '张三'

    def inner():
        print(name)

    return inner


if __name__ == '__main__':
    f = fun1()
    f()

判断一个函数是不是闭包

def fun1():
    name = '张三'

    def inner():
        print(name)

    print(inner.__closure__)
    return inner


if __name__ == '__main__':
    f = fun1()
    f()

如果是闭包的话会返回一个cell对象，不是闭包返回None

六、装饰器

装饰器可以在不修改原函数及其调用方式的情况下对原函数功能进行拓展。我们使用的装饰器语法格式为：@装饰器名称

1.单个装饰器

def fun1(f):
    def inner():
        print('---------------')
        f()
        print('************')

    return inner


@fun1
def f():
    print('哎呦，你干嘛')


if __name__ == '__main__':
    f()

2.多个装饰器

def fun1(f):
    def inner():
        print('我是装饰器1的上半部分')
        f()
        print('我是装饰器2的下半部分')

    return inner


def fun2(f):
    def inner():
        print('我是装饰器2的上半部分')
        f()
        print('我是装饰器2的下半部分')

    return inner


@fun1
@fun2
def f():
    print('我是大帅哥')


if __name__ == '__main__':
    f()

3.property装饰器

静态属性：@property。作用就是把类的函数属性，封装成类似数据属性。再调用函数printmassage 时候，必须不带（）执行。

简单来说就是把不带参数的类中方法当属性使用

class Student(object):
    school = 'szu'

    @property
    def printmassage(self):
        print('aaaa')


if __name__ == '__main__':
    s1 = Student()
    s1.printmassage