Python基础知识回顾——02(更新中)

1. 元祖

1.不可修改的特点。不能增删改，只能查。
2.tuple() 可以把列表强制转换为元祖类型，元祖不能增删改，只能通过list简介实现后强制类型转换。

元祖中内在的函数：index()、count()

元祖操作符号：+ * ：

2.拆装包

元祖个数多余变量个数：

# *+变量名 用来存储多余的数据，构成一个数组

对于列表和字符串也可以使用以上办法（* 变量名）来存储多与的参数，多余的参数会存到参数中以一个列表的形式。

*表达式 的解释：拆和装的过程

3. 元祖总结：

注意：sorted函数的返回值为list，可以使用tuple()强制类型转换为tuple

4. 字典：

4.1定义：

list中的元素两两存在才会转为dict

4.2字典的增删改查：

增：


注册案例（待完成）：
查：

对字典遍历：

查找：

删除：



关于删除函数的总结：

其他内置函数：

字符串回顾：

容器回顾

5.集合：

无序、不重复的特点
声明：

应用：

增删改查：
update() 增加多个元素

可变与不可变

不可变类型：


修改后地址发送改变。
可变类型：

类型转换

函数：

判断类型：.isinstance()函数

枚举类型：

拆装包在函数参数中的使用 *args（可变参数）

*agrs 默认准备元祖

结果是元祖。

参数为字典类型（可变参数）

调用时，必须写成key=value形式
** kwagrs 默认准备字典



标准的一个函数参数的定义：其中a,b是必须要有的，其他参数可缺省，且按顺序。

练习题1：

练习题2：

练习题3：

*将列表拆开
** 将字典拆开

全局变量与局部变量

回顾复习：

返回值

函数：

局部变量和全局变量

内部函数（嵌套函数）：

nonlocal 变量 来访问外层函数的变量。

闭包

将内部函数返回




闭包总结：



print(ff)的结果为hello

装饰器

装饰器特点：
1.函数A作为参数传入函数B 2.闭包的特点

• 有内层函数
• 内层函数调用外层函数变量
• 外层函数返回内存函数
• 有一个函数作为参数传入外层函数

仅仅定义两个函数，未调用函数，会打印两行。（这是因为加了@my_decorate）
加上@my-decorate后，会帮助我们做4件事：


结果就是先将house作为参数传给my_decorate然后执行；将内部函数地址返回给被装饰函数；被装饰函数调用后，就会调用内部函数。


结果：

实现了在原始函数的基础上的改进

当函数有参数时：

当参数个数是可变的时，使用*args:

当参数是关键字形式：

结果：

调用函数时，age不写，就会使用默认参数。

多个装饰器时：
装饰器中的参数总结：

装饰器带参数：

def outer(a):  # 第一层  用来接受装饰器的参数
    def decorate(func):  # 第二层  用来接受函数
        print("start")

        def wrapper(*args,**kwargs):
            func(*args,**kwargs)
            print("撞墙",a)
        
        print("end")

        return wrapper

    return decorate

@outer(5)
def func(time):
    print("时间为{},你好！".format(time))

func("2020-6-5")

结果：

start
end
时间为2020-6-5,你好！
撞墙 5

装饰器的应用：

# 使用装饰器实现付款前的登陆验证
import time

isLogin = False  # 设置初始登陆状态为flase

def login():
    username = input("请输入用户名:")
    password = input("请输入密码:")

    print("len(username)",len(username))
    print("len(password)",len(password))

    if(len(username) != 0 and len(password) != 0):
        return True
    else:
        return False


def decorate(func):
    
    print("初始化付款界面...")
    

    def wrapper(*args,**kwargs):
        global isLogin  # 修改不可变的全局变量  需要用global 修饰
        print("付款".center(80))
        if(isLogin):
            func(*args,**kwargs)
        else:
            print("需要登录")
            isLogin = login()        
            print("result:",isLogin)

    print("付款界面初始化成功！")

    return wrapper

@decorate
def pay(money):
    print("正在支付，需要支付{}元人民币".format(money))
    print("付款中")
    time.sleep(2)
    print("付款成功！！")

pay(5000)

pay(55)   # 只能完成这个pay  55

结果：

初始化付款界面...
付款界面初始化成功！
                                       付款
需要登录
请输入用户名:123
请输入密码:213
len(username) 3
len(password) 3
result: True
                                       付款
正在支付，需要支付55元人民币
付款中
付款成功！！

匿名函数

基本知识

lambda 表达式：

# 匿名函数  ：简化参数定义
# 格式：lambda  参数1 参数2 ... ：运算

s = lambda a,b:a+b
result = s(1,2)
print("result:",result)

匿名函数作为参数

# 匿名函数作为参数
def func1(a,b,func):
    print(a,b)
    print(func)
    result = func(a,b)
    print("result",result)
    
func1(1,2,lambda a,b: a+b)

结果：

1 2
<function <lambda> at 0x0000016B1DE7F400>
result 3

匿名函数与内置函数结合：

# 匿名函数  与内置函数结合

list2 = [{'a':2,'b':3},{'a':22,'b':3},{'a':21,'b':3},{'a':32,'b':3}]
ret = max(list2,key=lambda x: x['a'])  # 根据key = a 的value比较大小
print("result:",ret)

根据key = a 的value比较大小 返回列表中元素—一个字典
结果：

result: {'a': 32, 'b': 3}

Map函数

map(function, iterable, …)

# map 函数
list13 = [234,1235,324,6,7675,2]
result = map(lambda x: x%2,list13)
print("result:",list(result))  # result: [0, 1, 0, 0, 1, 0]

reudce函数

from functools import reduce

tuple1 = (2,3,4,5,6,7,2)
result3 = reduce(lambda x,y: x+y ,tuple1)
print(result3)  # 29

reduce函数中设置初始值 ：

tuple2 = (1,)
result4 = reduce(lambda x,y: x+y,tuple2,10)
result4 = reduce(lambda x,y: x+y,tuple2)  # 返回1
print(result4)  # 结果：11

filter函数

# 筛选age>50 
stu_list = [{"name":"aa","age":18},
{"name":"bb","age":129},
{"name":"cc","age":58},
{"name":"dd","age":188},]

result_list = filter(lambda x: x['age']>50,stu_list)  # 返回filter 对象
print(list(result_list))
# [{'name': 'bb', 'age': 129}, {'name': 'cc', 'age': 58}, {'name': 'dd', 'age': 188}

sorted函数

# 按照age排序
result = sorted(stu_list,key = lambda x: x['age'],reverse=True)
print("re:",result)

需要指定key ,类似的还有：max() min() sorted()

# max 
result1 = max(stu_list,key=lambda x: x['age'])
print(result1)