python自学入门（打卡十一）2022-11-27

一些内置函数：例如all any enumerate

print(all([0,"哈哈哈",""])) #False 看作and
print(any([0,"哈哈哈",""])) #True  看着or

#拿到索引和值
list=["张三","张望"]
for index,item in enumerate(list):
    print(index,item)#0 张三 1 张望

for i in range(len(list)):
    print(i,list[i]) #0 张三 1 张望

s="哈希值"
print(hash(s)) #一定是一个数字【计算】，转换为内存地址进行数据存储-->字典（集合）哈希表
print(id(s)) #直接拿到内存地址
print(dir(s)) #当前数据能执行哪些操作
print(help(str)) #数据类型str的应用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

函数：
1.可以作为返回值返回
2.可以作为参数互相传递
函数名实际上就是一个变量名，都表示一个内存地址

在函数外面访问函数里面的内容，必须return

def func():
    a=10086
    return a
c1=func() #接收返回值a
print(c1) #10086
#
1
2
3
4
5
6

把一个函数当成变量进行返回

def func1():
    def func2():
        print(111)
    return  func2 #返回函数，注意没有()
c2=func1() #接收的返回值就是函数 func2()
c2() #执行函数 打印出111
1
2
3
4
5
6

def an():
    print(123)
an() #123
bn=an
bn() #123
1
2
3
4
5

代理模式（将函数作为入参）

def func(an): #an收到的是一个函数
    an() #执行函数
def target():
    print("hello")
func(target) #将函数作为入参.输出hello
1
2
3
4
5

global 在局部，引入全局变量
nonlocal 在局部，引入外层的局部变量

a=10
b=10
def func():
    global a
    a=20
    b=20
func()
print(a,b) #a=20 b=10
1
2
3
4
5
6
7
8
9

#向外找一层，有则引用，如果没有继续在局部往外找
def func():
    a=10
    def func2():
        nonlocal a
        a=20
    func2()
    print(a)
func() #20
1
2
3
4
5
6
7
8
9

“”“”
#闭包:内层函数对外层函数的局部变量的使用
#1.可以让一个变量常驻于内存
#2.可以避免全局变量被修改 “”"

def func():
    a=10
    def inner():
        nonlocal a #引入外层的局部变量
        a+=1
        return  a
    return  inner #返回inner函数
ret = func() #ret来接收执行func()而返回的函数inner
r1=ret() #r1来接收执行inner()返回的变量a
r2=ret()
print(r1,r2) #11 12
1
2
3
4
5
6
7
8
9
10
11

#装饰器 本质是一个闭包
#作用：在不改变原有函数调用的情况下，给函数新增功能

def func(game):
    def inner(): #封装并返回inner函数
        print("打开外挂")
        game()
        print("关闭外挂")
    return inner

@func  #相当于 play_dnf = func(play_dnf)
def play_dnf():
    print("this is dnf")

@func  #相当于 play_lol = func(play_lol)
def play_lol():
    print("this is lol")

play_lol() #相当于执行的是inner()
play_dnf()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

通用装饰器：

#通用装饰器的写法
def wrapper(fn):     #wrapper装饰器 fn目标函数
    def inner(*args,**kwargs):  #兼容所有入参
        #在执行目标函数之前,,,要执行的东西
        print("在执行目标函数之前,,,要执行的东西")
        ret = fn(*args,**kwargs)  #执行目标函数
        #在执行目标函数之后,,,要执行的东西
        print("在执行目标函数之后,,,要执行的东西")
        return ret
    return  inner

@wrapper
def target():
    print("执行目标函数")

target()     #执行封装的inner方法

#运行结果
#在执行目标函数之前,,,要执行的东西
#执行目标函数
#在执行目标函数之后,,,要执行的东西
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

一个函数被多个装饰器装饰:

#通用装饰器的写法
def wrapper1(fn):     #wrapper装饰器 fn目标函数
    def inner(*args,**kwargs):  #兼容所有入参
        #在执行目标函数之前,,,要执行的东西
        print("111在执行目标函数之前,,,要执行的东西")
        ret = fn(*args,**kwargs)  #执行目标函数
        #在执行目标函数之后,,,要执行的东西
        print("111在执行目标函数之后,,,要执行的东西")
        return ret
    return  inner


def wrapper2(fn):     #wrapper装饰器 fn目标函数
    def inner(*args,**kwargs):  #兼容所有入参
        #在执行目标函数之前,,,要执行的东西
        print("222在执行目标函数之前,,,要执行的东西")
        ret = fn(*args,**kwargs)  #执行目标函数
        #在执行目标函数之后,,,要执行的东西
        print("222在执行目标函数之后,,,要执行的东西")
        return ret
    return  inner

@wrapper1
@wrapper2 
#先执行挨着函数的装饰器，返回wrapper2里的inner[wrapper2 目标 wrapper2]。
#再被wrapper1装饰，返回wrapper1里的inner
#[wrapper1 wrapper2 目标 wrapper2 wrapper1 ]
def target():
    print("执行目标函数")

target()     #执行封装的inner方法

打印结果：
111在执行目标函数之前,,,要执行的东西
222在执行目标函数之前,,,要执行的东西
执行目标函数
222在执行目标函数之后,,,要执行的东西
111在执行目标函数之后,,,要执行的东西
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

装饰器实战：

#创建一个登录验证装饰器
login_flag = False
def wrapper(fn):
    def inner(*args,**kwargs):
        global login_flag
        #判断是否已登录，未登录则先登录；已登录则直接执行后续操作
        if login_flag == False:
            #登录账号密码是否正确
            print("请先登录---------")
            while 1:
                username = input("请输入账号 \n")
                pwd = input("请输入密码 \n")
                if username == "admin" and pwd == "123":
                    print("登录成功")
                    login_flag = True  #修改登录状态为已登录
                    break
                else:
                    print("登录失败")
        #添加员工
        ret = fn(*args,**kwargs)
        #运行目标函数后，执行的内容
        print("下一步操作...")
        return ret
    return  inner


@wrapper
def add_user():
    print("准备添加员工")

@wrapper
def edit_user():
    print("准备编辑员工")

add_user()
edit_user()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

待学习：
迭代器、生成器
推导式
匿名函数
剩余内置函数：sorted map filter 等