2019-03-18-day013-装饰器与内置函数

上周回顾

函数:

• def 函数名():
• 缩进 函数体

闭包:

a = 50
def func():
    a = 10
    def avg():
        print(a)

函数名的使用:

1. 当做值被赋值给变量
2. 当做返回值
3. 可以当做参数传递
4. 可以当做容器内的元素

递归:

1. 自己调用自己
2. 有明确的结束条件

名称空间

• 内置空间
• 全局空间
• 局部空间

加载顺序

1. 内置
2. 全局
3. 局部

取值顺序

1. 局部
2. 全局
3. 内置

global nonlocal

• global :嵌套函数内,修改全局变量,如果没有这个变量就创建一个
• nonlocal : 修改局部变量,修改离它最近的变量,最近的没有继续向上走,直到局部顶层, 顶层没有就报错

三元运算符

c = a if a>b else b

推导式:

• 列表 [i for i in range(3)]
• 集合 {i for i in range(3)}
• 字典 {i:i+1 for i in range(3)}
• 生成器 (i for i in range(3))

迭代器:

• 能用for循环的就是可迭代对象 , 具有__iter__()方法可迭代对象
• 具有__iter__() 和 next() 就是一个迭代器
  迭代器的特性: 惰性机制,一次性,只能从上向下

生成器:

• 生成器,yield 生成器就是函数的变异,
• return 结束函数
• yield 返回值的功能,挂起(记录执行到了那一行)
• yield 可以写多个
• send('值') 这个值可以赋值给yield
• 第一次触发生成器的时候,使用send 但是send的值必须是None

建议 第一触发生成器的时候,使用__next__()

def func():
    yield 1
print(func())  # 生成器的地址

函数的参数:

• 动态位置参数
• 动态默认参数
• 位置参数
• 默认参数

实参的角度

• 位置参数
• 关键字参数
• 位置 > 动态位置 > 默认参数 > 动态默认参数

函数的返回值:

• return 返回多个是元祖形式
• return 字符串,数字,布尔值,列表,元祖,字典,集合,函数名,
• return 可以写多个,但是只执行第一个,执行完第一个后就结束函数

函数的注释:

def func():
    """
    注册
    :return:
    """
    print(1)
print(func.__doc__)

函数的执行过程:

1. 定义函数
2. 调用函数
3. 执行函数体
4. 返回函数的返回值,没写return 默认返回None

打散 -- 聚合

li = [1,2,3,4]
*li # 1 2 3 4
dic ={'1':2,'2':3}
**dic '1'=2,'2'=3
*dic '1' '2'
print(*dic)

装饰器-装饰用的工具

开放封闭原则:

• 开放对扩展
• 封闭修改源代码
• 改变了人家调用方式

计算一个函数使用多长时间

import time
print(time.time())
import time
def func():
    start_time = time.time()  # 代码运行之前的时间
    print('这是一个func函数')
    time.sleep(3)  # 阻塞,睡一下, 1 是睡一秒
    print(time.time() - start_time)  # 代码运行后的时间
func()

嵌套一

import time
def func():
    print('这是func函数')
    time.sleep(1)
def func1():
    print('这是func1函数')
    time.sleep(2)
def func2():
    print('这是func2函数')
    time.sleep(3)
def times():
    start_time = time.time()  # 代码运行之前的时间
    func2()
    print(time.time() - start_time)  # 代码运行后的时间
times()

嵌套二

import time
def func():
    def inner():
        time.sleep(2)
        print('这是inner函数')
    return inner
inner = func()
inner()

嵌套三

def warpper():
    print('这是新功能!')
    func()
def func():
    print(1)
warpper()
def func():
    print('这是主功能')
def warpper(f):
    print('这是新功能!')
    return f
func = warpper(func)
func()

嵌套四

def func(): # 我
    print('这是主功能!')
def warpper(f):  # 太白
    def inner():
        f()
        print('这是新功能!')
        # 扩展的功能
    return inner
func = warpper(func)
func()

嵌套五

import time
def func(*args,**kwargs): # 我
    print(args)
    print('这是主功能!')
    time.sleep(1)
def warpper(f):  # 太白
    def inner(*args,**kwargs):  # 带点礼
        start_time = time.time()
        f(*args,**kwargs)
        end_time = time.time()
        print('%s函数的运行时间:%s'%(f.__name__,end_time - start_time))
        # 扩展的功能
    return inner
func = warpper(func)  # 问太白
func(5) # 带的礼进去了

语法糖和函数名称

import time
def warpper(f):  # 接受被装饰的函数内存地址
    def inner(*args,**kwargs):  # 接受被装饰函数的参数
        start_time = time.time() # 新功能
        ret = f(*args,**kwargs)  # 调用被装饰的函数,被装饰参数带上
        end_time = time.time()
        print('%s函数的运行时间:%s'%(f.__name__,end_time - start_time))
        return ret               # 被装饰的函数返回值
    return inner
@warpper   # func = warpper(func)  语法糖
def func(*args,**kwargs):
    print(args)   # 打印被装饰的函数参数
    print('这是主功能!')
    time.sleep(1)
    return '大妈'  # 返回值
ret = func(5)  #ret = func(5)  == inner(5)  返回值  func(5)
print(ret)  # 被装饰的函数返回值

装饰器的函数名称

def func(a):
    """
    被装饰的函数
    :return:
    """
    print(a)  # 1
    print('我是被装饰的函数')
def warpper(f): # 接受一个被装饰的函数内存地址  # f == <function func at 0x0000023D5CE31E18>
    def inner(a):  # 接受一个被装饰的函数的参数 a = 1
        print('这是被装饰的函数调用之前')
        print(f.__name__)  # func
        f(a)  # 调用被装饰的函数   f(1) == func(1)
        print('这是被装饰的函数调用之后')
    return inner
func = warpper(func)  # 这样要满足人家规定的不改表调用方式
# func == <function warpper.<locals>.inner at 0x000001BAC19D99D8>
print(func.__name__)   # func = inner函数
func(5)  # 调用inner函数  func(1) == inner(1)
# print(func)

多个装饰器装饰同一个函数

执行顺序从上往下，返回值顺序从执行的函数先执行先返回

def warpper(f): # 接受一个被装饰的函数内存地址  # f == <function func at 0x0000023D5CE31E18>
    def inner(a):  # 接受一个被装饰的函数的参数 a = 1
        start_time = time.time()
        print('这是warpper')  # func
        f(a)  # 调用被装饰的函数   f(1) == func(1)
        print('这是warpper')
    return inner
def auto(f): # 接受一个被装饰的函数内存地址  # f == <function func at 0x0000023D5CE31E18>
    def inner(a):  # 接受一个被装饰的函数的参数 a = 1
        start_time = time.time()
        print('这是auto')  # func
        f(a)  # 调用被装饰的函数   f(1) == func(1)
        print('这是auto')
    return inner
def login_auot(f): # 接受一个被装饰的函数内存地址  # f == <function func at 0000023D5CE31E18>
    def inner(a):  # 接受一个被装饰的函数的参数 a = 1
        start_time = time.time()
        print('这是login_auto')  # func
        f(a)  # 调用被装饰的函数   f(1) == func(1)
        print('这是login_auto')
    return inner
@warpper      # func = warpper(func)
@login_auot   # func = login_auto(func)
@auto
def func(a):
    print(1)
func(1)
执行的时候 从最上层装饰器开始执行  中间执行被装饰的函数  返回的时候是从下往上走
@warpper        # 使用规范,装饰放在被装饰的函数离它最近正上方
def func(a):
    print('这是登录')
func(5)
@warpper
def reg(a):
    print('这是注册')
# reg(3)
def index():
    print('这是主页')
index()

###返回装饰器的被装饰函数名
```python
from functools import wraps
def warpper(f):
    @wraps(f)   #显示被装饰的函数
    def inner(*args,**kwargs):
        # print(f.__name__)
        print(f)
    return inner  #
def aa():
    print(1)
aa = warpper(aa)
print(aa.__name__)  # 显示被装饰的函数名
```

有参装饰器

def warpper(f): # 接受一个被装饰的函数内存地址  # f == <function func at 0x0000023D5CE31E18>
    def inner(a):  # 接受一个被装饰的函数的参数 a = 1
        start_time = time.time()
        print('这是warpper')  # func
        f(a)  # 调用被装饰的函数   f(1) == func(1)
        print('这是warpper')
    return inner
@warpper
def func():
    print(1)
func()
def func():
    print(1)
func = warpper(func)
func()

内置函数

Until Python 3.7.3-rc-link

函数名	函数解释
abs(x)	返回一个数的绝对值。实参可以是整数或浮点数。如果实参是一个复数，返回它的模。
all(iterable)	如果 iterable 的所有元素为真（或迭代器为空），返回 True 。
any(iterable)	如果iterable的任一元素为真则返回True。如果迭代器为空，返回False。
ascii(object)	就像函数 repr()，返回一个对象可打印的字符串.
bin(x)	将一个整数转变为一个前缀为“0b”的二进制字符串。
bool(x)	返回一个布尔值，True 或者 False。它只有 False 和 True 两个实例。
breakpoint(*args, **kws)	此函数会在调用时将你陷入调试器中.
bytearray([source[, encoding[, errors]]])	返回一个新的 bytes 数组。 bytearray 类是一个可变序列，包含范围为 0 <= x < 256 的整数。它有可变序列大部分常见的方法.
bytes([source[, encoding[, errors]]])	返回一个新的“bytes”对象， 是一个不可变序列，包含范围为 0 <= x < 256 的整数。bytes 是 bytearray 的不可变版本.
callable(object)	如果实参 object 是可调用的，返回 True，否则返回 False。如果返回真，调用仍可能会失败.
chr(i)	返回 Unicode 码位为整数 i 的字符的字符串格式。例如，chr(97) 返回字符串 'a',这是 ord() 的逆函数。
@classmethod	把一个方法封装成类方法。
compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)	将 source 编译成代码或 AST 对象。代码对象可以被 exec() 或 eval() 执行。
complex([real[, imag]])	返回值为 real + imag*1j 的复数，或将字符串或数字转换为复数。
delattr(object, name)	setattr() 相关的函数。实参是一个对象和一个字符串。该字符串必须是对象的某个属性。
dict(**kwarg)	创建一个新的字典。dict 对象是一个字典类。
dir([object])	如果没有实参，则返回当前本地作用域中的名称列表。如果有实参，它会尝试返回该对象的有效属性列表。
divmod(a, b)	它将两个（非复数）数字作为实参，并在执行整数除法时返回一对商和余数。对于混合操作数类型，适用双目算术运算符的规则。
enumerate(iterable, start=0)	返回一个枚举对象。iterable 必须是一个序列，或 iterator，或其他支持迭代的对象。
eval(expression, globals=None, locals=None)	实参是一个字符串，以及可选的 globals 和 locals。globals 实参必须是一个字典。locals 可以是任何映射对象。
exec(object[, globals[, locals]])	这个函数支持动态执行 Python 代码。object 必须是字符串或者代码对象。
filter(function, iterable)	用 iterable 中函数 function 返回真的那些元素，构建一个新的迭代器。
float(x)	返回从数字或字符串 x 生成的浮点数。
format(value[, format_spec])	将 value 转换为 format_spec 控制的“格式化”表示。
frozenset([iterable])	返回一个新的 frozenset 对象,它是不可变对对象。
getattr(object, name[, default])	返回对象命名属性的值。name必须是字符串。如果该字符串是对象的属性之一，则返回该属性的值。
globals( )	返回表示当前全局符号表的字典。这总是当前模块的字典（在函数或方法中，不是调用它的模块，而是定义它的模块。
hasattr(object, name)	该实参是一个对象和一个字符串。如果字符串是对象的属性之一的名称，则返回 True，否则返回 False。
hash(object)	返回该对象的哈希值（如果它有的话。哈希值是整数。它们在字典查找元素时用来快速比较字典的键。相同大小的数字变量有相同的哈希值（即使它们类型不同，如 1 和 1.0。
help([object])	启动内置的帮助系统（此函数主要在交互式中使用。
hex(x)	将整数转换为以“0x”为前缀的小写十六进制字符串。
id(object)	返回对象的“标识值”。该值是一个整数，在此对象的生命周期中保证是唯一且恒定的。两个生命期不重叠的对象可能具有相同的 id() 值。
input([prompt])	如果存在 prompt 实参，则将其写入标准输出，末尾不带换行符。接下来，该函数从输入中读取一行，将其转换为字符串（除了末尾的换行符）并返回。当读取到 EOF 时，则触发 EOFError。
int(x, base=10)	返回一个使用数字或字符串 x 生成的整数对象，或者没有实参的时候返回 0 。
isinstance(object, classinfo)	如果 object 实参是 classinfo 实参的实例，或者是（直接、间接或 虚拟）子类的实例，则返回 true。如果 object 不是给定类型的对象，函数始终返回 false。
issubclass(class, classinfo)	如果 class 是 classinfo 的子类（直接、间接或 虚拟 的），则返回 true。classinfo 可以是类对象的元组，此时 classinfo 中的每个元素都会被检查。其他情况，会触发 TypeError 异常。
iter(object[, sentinel])	返回一个 iterator 对象。根据是否存在第二个实参，第一个实参的解释是非常不同的。如果没有第二个实参，object 必须是支持迭代协议（有 __iter__() 方法）的集合对象，或必须支持序列协议（有 __getitem__() 方法，且数字参数从 0 开始）。
len(s)	返回对象的长度（元素个数）。实参可以是序列（如 string、bytes、tuple、list 或 range 等）或集合（如 dictionary、set 或 frozen set 等）。
list([iterable])	除了是函数，list 也是可变序列类型.
locals( )	更新并返回表示当前本地符号表的字典。在函数块而不是类块中调用 locals() 时会返回*变量。
map(function, iterable, ...)	产生一个将 function 应用于迭代器中所有元素并返回结果的迭代器。
max(iterable, *[, key, default)	返回可迭代对象中最大的元素，或者返回两个及以上实参中最大的。
memoryview(obj)	返回由给定实参创建的“内存视图”对象。
min(iterable, *[, key, default])	返回可迭代对象中最小的元素，或者返回两个及以上实参中最小的。
next(iterator[, default])	通过调用 iterator 的 __next__() 方法获取下一个元素。如果迭代器耗尽，则返回给定的 default，如果没有默认值则触发 StopIteration。
class object	返回一个没有特征的新对象。object 是所有类的基类。它具有所有 Python 类实例的通用方法。这个函数不接受任何实参。
oct(x)	将一个整数转变为一个前缀为“0o”的八进制字符串。结果是一个合法的 Python 表达式。
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)	打开 file 并返回对应的 file object。如果该文件不能打开，则触发 OSError。
ord(c)	对表示单个 Unicode 字符的字符串，返回代表它 Unicode 码点的整数。
pow(x, y[, z])	返回 x 的 y 次幂；如果 z 存在，则对 z 取余（比直接 pow(x, y) % z 计算更高效）。两个参数形式的 pow(x, y) 等价于幂运算符： x**y。
print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)	将 objects 打印到 file 指定的文本流，以 sep 分隔并在末尾加上 end。 sep, end, file 和 flush 如果存在，它们必须以关键字参数的形式给出。
class property	返回 property 属性。
range(start, stop[, step])	虽然被称为函数，但 range 实际上是一个不可变的序列类型.
repr(object)	返回包含一个对象的可打印表示形式的字符串。
reversed(seq)	返回一个反向的 iterator。
round(number[, ndigits])	返回 number 舍入到小数点后 ndigits 位精度的值。
set([iterable])	返回一个新的 set 对象，可以选择带有从 iterable 获取的元素。 set 是一个内置类型。
setattr(object, name, value)	此函数与 getattr() 两相对应。 其参数为一个对象、一个字符串和一个任意值。
slice(start, stop[, step])	返回一个表示由 range(start, stop, step) 所指定索引集的 slice 对象。
sorted(iterable, *, key=None, reverse=False)	根据 iterable 中的项返回一个新的已排序列表。
@staticmethod	将方法转换为静态方法。
str(object=b'', encoding='utf-8', errors='strict')	返回一个 str 版本的 object。
sum(iterable[, start])	从 start 开始自左向右对 iterable 中的项求和并返回总计值。 start 默认为 0。 iterable 的项通常为数字，开始值则不允许为字符串。
super([type[, object-or-type]])	返回一个代理对象，它会将方法调用委托给 type 指定的父类或兄弟类。
tuple([iterable])	虽然被称为函数，但 tuple 实际上是一个不可变的序列类型.
type(name, bases, dict)	传入一个参数时，返回 object 的类型。 返回值是一个 type 对象.
vars([object])	返回模块、类、实例或任何其它具有 __dict__ 属性的对象的 __dict__ 属性。
zip(*iterables)	创建一个聚合了来自每个可迭代对象中的元素的迭代器。
__import__(name, globals=None, locals=None, fromlist=(), level=0)	此函数会由 import 语句发起调用.

总结

1.装饰器:

原则:

1. 对扩展开发
2. 对修改封闭
3. 不改变调用方式

def warpper(f): # 接受被装饰的函数
    def inner(*args,**kwargs): #接受参数
        ret = f(*args,**kwargs)
        return ret
    return inner
@warpper
def func():
    pass
func()
from functools import wraps
def log(flag):
    def warpper(f): # 接受被装饰的函数
        if flag:
            @wraps(f)
            def inner(*args,**kwargs): #接受参数
                """
                这是inner的注释
                :param args:
                :param kwargs:
                :return:
                """
                print('这是一个装饰器')
                ret = f(*args,**kwargs)
                return ret
            return inner
        else:
            return f
    return warpper
@log(True)  # func = log(False)
def func():
    """
    这是func函数
    :return:
    """
    print(1)
func()
print(func.__doc__)

装饰器:应用场景后期框中会大量出现, 面向对象会出现 登录认证的时候

内置函数:

• lambda 匿名函数 这个函数真的没有名字一行函数,不用纠结起什么名字,简单
• sorted() 可迭代对象 key=指定排序方式 可以调整排序方式
• filter() 函数,可迭代对象 过滤的规则在函数中写
• map() 函数,可迭代对象,将每个元素进行同样的操作

from functools import reduce

• reduce() 函数,可迭代对象 累计算
• 以上4个内置函数,都帮咱们提前实现了for循环