20200220--python学习第13天

今日内容

　　作业题（21题）

　　推导式

　　装饰器

　　模块【可选】

内容回顾

　　1.函数

　　　　a.参数

　　　　　　def func(a1,a2):pass

　　　　　　def func(a1,a2=None):pass 默认参数推荐使用不可变类型，慎用可变类型，如列表

　　　　　　def func(*args,**kwargs):pass 万能参数

　　　　　　注意：位置参数>关键字参数，所以位置参数一定在关键字参数的前面

　　　　　　面试题：函数可以作为参数　　　　　　　　

　　　　　　　　def func(arg):
    　　　　　　　　arg()
　　　　　　　　def show():
    　　　　　　　　pass
　　　　　　　　func(show)
　　　　　　函数的参数传递的是什么【内存地址=引用or值】
　　　　　　

　　　　　　v = [11,22,33,44]
　　　　　　def func(arg):
    　　　　　　print(id(arg)) #输出列表的内存地址

　　　　　　print(id(v)) #输出列表的内存地址
　　　　　　func(v)  #两次输出的结果一致，所有参数传递的是内存地址
　　　　　　*args和**kwargs的作用

　　　　b.返回值

　　　　　　常见数据类型可以返回

　　　　　　函数也可以返回

　　　　　　　　def func():
    　　　　　　　　def inner():
        　　　　　　　　pass
    　　　　　　　　return inner

　　　　　　　　v = func()

　　　　　　特殊情况

　　　　　　　　默认没有返回值为None

　　　　　　　　return 1,2,3等价于return (1,2,3,)

　　　　c.执行参数

　　　　　　函数不被调用，其内部代码永远不会执行。

示例一：　　　

def func():
    return i
func_list=[]
for i  in range(10):
    func_list.append(func)
print(i)  #输出结果为9
v1 = func_list[0]()  #输出结果为9
v2 = func_list[4]()  #输出结果为9
print(v1,v2)

示例二：

func_list=[]
for i in range(10):
    func_list.append(lambda : i)  #函数不被调用，内部永远不知道执行什么
print(func_list)  #输出还有10个lambda函数的列表
v1= func_list[2]()
v2= func_list[4]()
print(v1,v2)  #输出结果为9， 9　　　

 

　　　　　　执行函数时，会新创建一块内存保存自己函数执行的信息==》闭包

示例一：

def base():
    return i
def func(arg):
    def inner():
        return arg()
    return inner
base_list = []
func_list = []
for i in range(10):
    base_list.append(base)
    func_list.append(func(i))
#1 base_list和func_list中分别保存的是什么
#base_list中存储是10个base函数
#func_list中存储是10个inner函数，特别要说的是每个inner是在不同的地址创建的，都是一个变量i,形成一个闭包

#2如果循环打印什么？
for item in base_list:
    v = item() #执行base函数
    print(v)  #每次返回结果都是9

for data in func_list:
    v = data() #执行inner函数
    print(v)   #返回结果为：0，1，2，3，4，5，6.。。。。

　　　　d.总结

　　　　　　传参：位置参数 > 关键字参数

　　　　　　函数不被调用，其内部代码永远不运行

　　　　　　每次调用函数时，都会为此调用开辟一块内存，内存可以保存自己以后想用的值

　　　　　　函数是作用域，如果自己作用域中没有，则往上级作用域找。

2.内置与匿名函数

　　　内置函数

　　　匿名函数即lambda函数

3.模块

　　random

　　hashlib

　　getpass

内容详细

1.作业题讲解

2.装饰器

v = 1
v = 2 #表示重新赋值
#########################################
def func():
    pass
v = 10
v = func

#########################################
def base():
    print(1)

def bar():
    print(2)
bar = base
bar()  #执行的是base函数

#########################################
def func():
    def inner():
        pass
    return inner
v = func()
print(v) #v即inner函数

#########################################
def func(arg):
    def inner():
        print(arg)
    return inner
v1 = func(1)  #v1是inner函数，是一个闭包，其中arg = 1
v2 = func(2)  #v2是inner函数，是一个闭包，其中arg = 2

#########################################
def func(arg):
    def inner():
        arg()
    return inner
def f1()
    print(123)

v1 = func(f1) #v1是一个inner函数，其中arg =f1函数
v1() #相当于执行inner函数，即执行f1函数，输出123

#########################################
def func(arg):
    def inner():
        arg()
    return inner
def f1():
    print(123)
    return 666
v1 = func(f1) #执行func函数，并将f1函数作为参数传递 ，v1相等于inner函数
result = v1() #执行inner函数，并执行f1函数，输出123，返回666，但没有接收，其结果为None
print(result)  #输出None

#########################################
def func(arg):
    def inner():
        return arg()
    return inner
def f1():
    print(123)
    return 666
v1 = func(f1) #执行func函数，并将f1函数作为参数传递 ，v1相等于inner函数
result = v1() #执行inner函数，并执行f1函数，输出123，返回666接收
print(result)  #输出666

#########################################装饰器#####################
def func(arg):
    def inner():
        print("before")
        v = arg()
        print("after")
        return v
    return inner
def index():
    print('123')
    return '666'

#示例一
"""
v1 = index() #执行index函数，打印123并返回666赋值给v1
"""
#示例二
"""
v2 = func(index) #v2是inner函数，且arg= index函数
index = 666 #index变量被重新赋值
v3 = v2() #执行inner函数，打印before,执行arg函数，打印123，返回666赋值给v，打印after，返回值v=666gei v3
"""

#示例三
"""
v4 = func(index)  #v2是inner函数，且arg= index函数
index = v4  #index变量重新赋值为inner函数
index()  #执行inner函数
"""

#示例四
index = func(index)
index()

def func(arg):
    def inner():
        v = arg()
        return v
    return inner
#第一步：执行func函数并将下面的函数参数传递，相等于func(index)
#第二步：将func的返回值重新赋值给下面的参数名，相等于index = func(index)
@func
def index():
    print('123')
    return 666
print(index)

#装饰器：在不改版原函数内部代码的基础上，在函数执行之前和之后自动执行某个功能，应用如下：
#计算函数执行时间
import time
def wrapper(func):
    def inner():
        start_time = time.time()
        v = func()
        end_time = time.time()
        print(end_time-start_time)
        return v
    return inner

@wrapper
def func1():
    time.sleep(2)
    print(123)

@wrapper
def func2():
    time.sleep(1.5)
    print(123)

@wrapper
def func3():
    time.sleep(3)
    print(123)

func1()
func2()
func3()

 

总结

　　装饰器的目的：在不改变原函数代码的基础商，在函数执行前后自定义功能。

　　编写装饰器与应用　

#装饰器的编写
def x(func):
    def y():
        #前
        ret = func()
        #后
        return ret
    return y
#装饰器的应用
@x
def index():
    return 10
@x
def manager():
    pass
#执行函数，自动触发装饰器了
v= index()
print(v)

　　应用场景：想要为函数扩展功能是，可以选择用装饰器。

　　记住：

　　　　装饰器编写格式

　　　　　　def 外层函数(参数):
    　　　　　　def 内层函数(*args,**kwargs):
        　　　　　　return 参数(*args,**kwargs)
    　　　　　　return 内层函数

　　　　装饰器应用格式

　　　　　　@外层函数
　　　　　　def index():
    　　　　　　pass

　　　　　　index()

　　　　问题：为什么要加*args,**kwargs

3.推导式

　　列表推导式

　　　　推导式基本格式

　　　　　　

"""
#目的：方便生成一个列表
#格式：
v1 = [i for i in 可迭代对象]
v2 = [i for i in 可迭代对象 if 条件] #只有条件为真才进行append
"""
v1 = [i for i in 'alex'] #返回结果为：['a','l','e','x']
v2 = [i+100 for i in range(10)] #返回结果为：[100,101,102,103,104,105,106,107,108,109]
v3 = [99 if i>5 else 66 for i in range(10)]
#返回结果为：[66,66,66,66,66,66,99,99,99,99]

def func():
    return 100
v4 = [ func for i in range(10)] #返回结果为：含有10个func函数的列表

v5 = [ lambda :100 for i in range(10)] #返回结果为：含有10个lambda函数的列表
result = v5[9]() # 返回结果为100

def func():
    return i 
v6 = [ func for i in range(10)]  #含有10个func函数的列表
result= v6[5]() #返回结果为：9

v7 = [ lambda :i for i in range(10)] #含有10个lambda函数的列表
result = v7[5]() #返回结果为:9

v8 = [ lambda x:x*i for i in range(10)]  #含有10个lambda函数的列表
result = v8[0](2) #返回结果为：18

#面试题
def num():
    return [lambda x:x*i for i in range(4)]
#num()----> [lambda函数，lambda函数，lambda函数，lambda函数]
print([m(2) for m in num()])  #返回结果为：[6,6,6,6]

######################################筛选##################################
v9 = [i for i in range(10) if i >5] #返回结果为：[6,7,8,9]

　　集合推导式

　　v1 = { i for i in 'alex'} #返回结果为{'a','l','e','x'}
　　v2 = { i for i in 'alalex'} #返回结果为{'a','l','e','x'},注意集合具有去重的作用

　　字典推导式

 

　　v1 = { 'k'+str(i): i for i in range(10)} #返回结果为：{'k0':0,'k1':1.....}

今日总结

 　　装饰器（6**）

　　　　编写格式：双层嵌套函数

　　　　应用格式：@外层函数

　　　　理解：变量赋值

　　　　　　def func():

　　　　　　　　print(1)

　　　　　　v1 = func

　　　　　　func = 666

　　　　看看到底return的是什么

　　　　自己 > 上级作用域

　　背会：

　　　　@xx # index= func(index)

　　　　def index():

　　　　　　pass

　　　　index()

　　推导式（3**）

　　模块

　　　　import  time

　　　　v = time.time() #获取当前时间

　　　　time.sleep(2) #睡2秒