1. 装饰器介绍

python中的装饰器相当于java中的注解。

1.1 装饰器定义

装饰器是在闭包的基础上，将函数作为外部函数的唯一的形参传入进去。

  1. 装饰器格式：
  2.     def decorator(fn):
  3.         def inner():
  4.             fn()
  5.         return inner
  6. 调用方式：
  7.     fn=decorator(fn)  # 此时fn=inner,而不是fn=inner()
  8.     fn()    # fn() == inner()
  10. 语法糖格式: 将@装饰器 写到被装饰的函数前面。
  11.     @decorator
  12.     def fn(x)：
  13.         print(x)
  15.     fn()

1.2 带参装饰器

  1. def func(flog):
  2.     def decorator(fn):
  3.         def inner(num1,num2):
  4.             if flag == 1:
  5.                 fn(num1,num2)
  6.             else:
  7.                 result = 0
  8.             return result
  9.     return inner
  10. return decorator
  12. @func(1)
  13. def fn(num1,num2):
  14.     result = num1+num2
  15.     return result
  17. result = fn(1,2)
  18. print(result)
  23. 装饰器错误原因：装饰器的外部函数形参只有一个函数参数
  24. def decorator(fn,flag):
  25.     def inner(num1,num2):
  26.         if flag ==1:
  27.             result = fn(num1,num2)
  28.         else:
  29.             result = 0
  30.         return result
  31. return inner

1.3 多个装饰器的使用

  1. def make_div(func):
  2.     """对被装饰的函数的返回值 div标签"""
  3.     def inner(*args, **kwargs):
  4.         return "<div>" + func() + "</div>"
  5.     return inner
  8. def make_p(func):
  9.     """对被装饰的函数的返回值 p标签"""
  10.     def inner(*args, **kwargs):
  11.         return "<p>" + func() + "</p>"
  12.     return inner
  15. # 装饰过程: 1. content = make_p(content) 2. content = make_div(content)
  16. # content = make_div(make_p(content))
  17. @make_div
  18. @make_p
  19. def content():
  20.     return "人生苦短"
  22. result = content()
  24. print(result)

多个装饰器可以对函数进行多个功能的装饰，装饰顺序是由内到外的进行装饰

1.4 类装饰器

  1. class Check(object):
  2.     def __init__(self, fn):
  3.         # 初始化操作在此完成
  4.         self.__fn = fn
  6.     # 实现__call__方法，表示对象是一个可调用对象，可以像调用函数一样进行调用。
  7.     def __call__(self, *args, **kwargs):
  8.         # 添加装饰功能
  9.         print("请先登陆...")
  10.         self.__fn()
  13. @Check   # comment=Check(comment)
  14. def comment():
  15.     print("发表评论")
  18. comment()

1. 迭代器

1.1 可迭代对象

Python中可迭代对象(Iterable)并不是指某种具体的数据类型，它是指能够执行for …in 循环语句遍历的对象。

  1. 常见的可迭代对象包括：
    • 集合数据类型，如list、tuple、dict、set、string，range；
    • 生成器(generator)，包括生成器和带yield的生成器函数(generator function)
  2. iter方法的作用是让对象可以用for … in循环遍历
  3. for … in语句其实做了两件事：第一件事是调用iter()获得一个可迭代器，第二件事是循环调用next()。
  4. 如何判断一个对象是可迭代对象呢？具体判断方法如下： ```python from collections import Iterable #导入Iterable 模块

a = isinstance(变量, Iterable) #判断一个变量是否为可迭代对象返回True表明是可迭代对象 print(a)

True/False ```

1.2 迭代器

一个对象只要实现了_iter()，next()方法，就是迭代器。

  • 迭代是Python最强大的功能之一，是访问集合元素的一种方式。
  • 迭代器是一个可以记住遍历的位置的对象。
  • 迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

  • 迭代器有两个基本的方法：iter() 和 next()。

    1. >>> list=[1,2,3,4]
    2. >>> it = iter(list)    # 创建迭代器对象
    3. >>> print (next(it))   # 输出迭代器的下一个元素
    4. 1
    5. >>> print (next(it))
    6. 2
    7. >>>

    1.3 自定义迭代器

    自定义迭代器需要在类中定义_iter()，next()方法
    StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况，在 next() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。 ```python class Reverse(object): def init(self, data):

    1.   self.data = data
    2.   self.index = len(data)

    def iter(self):

    1.   return self

    def next(self):

    1.   if self.index == 0:
    2.       raise StopIteration
    3.   self.index -= 1
    4.   return self.data[self.index]

rev = Reverse([1,2,3,4,5]) for x in rev: print(x)

```

2. 生成器

生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。