上周内容总结

上周内容总结

*与**在形参和实参的作用

  • 形参

    一个星号：打破形参数量限制，接收多余的位置实参将其组成元组赋值给星号后面的变量名

    俩个星号：打破形参数量限制，接收多余的关键字实参将其组成字典赋值给俩个星号后面的变量名

    def func(x,*args, **kwargs):  #  x = 1   args = （2，3，4） kwargs ={'name':'jason'}
    print(args)
    print(kwargs)
func(1，2，3，4,name ='jason')

  • 实参

    一个星号:相当于将星号后面的变量名绑定的数据用for循环取出按照顺序放入实参中

    俩个星号：用于字典类型将字典类型的键值对以关键字参数传给形参。

    # s = 'hello'
# func(*s)  # ('h', 'e', 'l', 'l', 'o')   {}
'''func('h','e','l','l','o')'''
# d = {'1': 'jason', '2': 18}
# func(*d)  # ('1', '2') {}
'''func('1','2')'''

# d1 = {'username': 'jason', 'pwd': 123}
# func(**d1)  # ()  {'username': 'jason', 'pwd': 123}
# func(username='jason', pwd=123)  # ()  {'username': 'jason', 'pwd': 123}

命名关键字参数

  • 应用场景

    # def func(a,b,*args):
#     pass
# func(1,2)
# func(a=1,b=2)
# func(1,b=222)
'''需要形参在传实参的时候 必须按照关键字参数才可以'''
# 在形参*args的后面
# def func(a, b, *args, c):
#     print(a, b, args, c)
# func(1,2,3,4,5,6,7)  # 报错
# func(1, 2, 3, 4, 5, 6, c=666)
# 如果形参中还有**kwargs 那必须在它的前面
def func(a,b,*args,c,**kwargs):
    pass
func(1,2,3,4,5,6,c=123,name='jason')

名称空间

  • 什么是名称空间

    就是用来存放变量名与数据值之间绑定关系的地方

  • 名称空间的分类

    • 内置名称空间

      python解释器运行就会立即创建的空间，

      写代码过程中可以直接使用的名字都在改空间里

    • 全局名称空间

      py文件运行代码过程产生的名字都会存入改空间

      普通代码里面的变量名、分支结构里面的变量名

      循环结构里面的变量名、定义函数的函数名、定义类的类名

    • 局部名称空间

      函数体代码运行过程中产生的名字都会存入该空间

  • 名称空间的存活周期

    • 内置名称空间

      python解释器运行时创建

      python解释器关闭时销毁

    • 全局名称空间

      py文件运行时创建

      py文件结束时销毁

    • 局部名称空间

      函数体代码运行时创建

      函数体代码结束时销毁

名字的查找顺序

查找名字之前一定要先看当前在那个名称空间里

名字的查找顺序时不能颠倒的默认情况下只能是，局部>>>全局>>>内置

  • 当前在全局名称空间

    全局名称空间>>>内置名称空间

  • 当前在局部名称空间

    局部名称空间>>>全局名称空间>>>内置名称空间

名称空间的作用域

  • 内置名称空间

    在程序任意位置都可以使用（全局有效）

  • 全局名称空间

  • 在程序任意位置都可以使用（全局有效）

  • 局部名称空间

    在各自局部空间可以使用（局部有效）

局部名称空间的复杂情况

  • 各自局部名称空间默认情况下不能彼此共享名字

    def func1():
    name = 'jason'
    print(age)

def func2():
    age = 18
    print(name)
func1()
func2()
# 2.特殊情况
# x = 1
#
#
# def func1():
#     x = 2
#     def func2():
#         x = 3
#         def func3():
#             print(x)  特例
#             # x = 4
				 # print(x)
#         func3()
#     func2()
# func1()

name = 'jason'
def func():
    print(name)
    name = 'jasonNB'
func()
# 函数在定义阶段其实名字的查找顺序就已经固定死了

global与nonloal关键字

  • global

    在局部空间如果想要修改全局名称空间中的不可变类型需要用到global关键字声明

    money = 999

def func():
    global money  
    money = 1000
    print(money)
"""
声明 局部名称空间中的money操作的是全局的money
正常情况下 局部名称空间里面出现新的名字会在局部名称空间中存储
但是有时候需要在局部名称空间中修改全局名称空间的名字
局部修改全局名称空间中不可变类型的数据 需要使用关键字global声明
如果是可变类型 则无需关键字声明
"""

  • nonloal关键字

    在内存局部空间内修改外层局部空间中的不可变类型

    def func1():
    x = 1
    l1 = [1,2]
    def func2():
        # nonlocal x
        x = 999
        l1.append(666)
    func2()
    print(x)
    print(l1)
func1()
"""
nonlocal 在内存局部名称空间修改外层局部名称空间中的不可变类型
"""

闭包函数简介

  • 什么是闭包函数

    定义在函数内部的函数，

    而且内部函数使用了外部函数名称空间中的名字称之为闭包函数

    基本使用

    def func(name ): 
    def index():
        print(name)
    return index
s =func（'jason'）
s（）

装饰器简介

  • 装饰器的本质

    在不改变被装饰对象的调用方式和内部代码的情况下给装饰对象添加新的功能

  • 装饰器原则

    对修改的封闭，对扩展的开放

  • 知识储备

    获取时间戳，统计时间。

    import time

# print(time.time())  # 1656987566.7260265
'''时间戳(秒数):当前距离1970年1月1日0时0分0秒所经历的秒数'''
# 实际应用>>>:统计代码的运行时间
# start_time = time.time()  #  100
# for i in range(1000):
#     print(i)
# end_time = time.time()
# print('for循环的执行时间是:%s'%(end_time - start_time))
time.sleep(3)
'''让程序原地等待三秒'''
print('等待3秒')

装饰器的推到流程

  • 需求

    将下列代码在不改变被装饰对象原有的调用方式和内部代码的情况下给装饰对象添加新的统计时间功能。

    def index():
    time.sleep(3)
    print('from index')
    '''统计index函数的执行时间'''
start_time = time.time()  # 在调用index函数之前获取一下时间戳
index()  # 调用index函数
end_time = time.time()
print(end_time - start_time)
 """
缺陷
    如果有多个index需要统计时间 则需要重复编写代码
    解决措施:
        封装成函数
"""

  • 装饰器的初始阶段

    """
# def get_time():
#     start_time = time.time()  # 在调用index函数之前获取一下时间戳
#     index()  # 调用index函数
#     end_time = time.time()
#     print('函数的执行时间是:',end_time - start_time)
"""
缺陷
    如果有多个不同的函数需要统计时间 那么上述的解决措施不够完善
    解决措施: 
        给函数体添加形参(动态传参)  
"""

  • 装饰器的优化阶段

    def home():
    time.sleep(5)
    print('from home')

def get_time(xxx):
    start_time = time.time()  # 在调用index函数之前获取一下时间戳
    xxx(*args,**kwargs)  # 调用index函数
    end_time = time.time()
    print('函数的执行时间是:',end_time - start_time)
# get_time(index)
# get_time(home)
"""
缺陷
    不同形参个数的函数无法兼容统计
    解决措施:
        *args  **kwargs
    但是在我们目前的代码中无法实现(暂且忽略)
"""

  • 装饰器的完整阶段

    import time

"""针对有参无参函数如何兼容问题"""
def outer(xxx):  # 定义一个函数，设置一个形参xxx用来绑定被装饰的对象。
    def get_time(*args, **kwargs):  # 定义一个内层函数用来间接调用装饰的对象,形参中用*和**的作用来兼容有参或者无参的装饰对象。
        start_time = time.time()  # 在调用被装饰对象之前获取一下时间戳
        res = xxx(*args, **kwargs)  # 调用outer形参中接受的被装饰对象，并将被装饰的对象返回值赋值给res，
        end_time = time.time()   # 调用被装饰对象之后获取一下时间戳
        print('函数的执行时间是:', end_time - start_time)  # 算出前后的时间差。
        return res # 将被装饰对象的返回值返回给get_time。
    return get_time # 将函数get_time功能当作返回值返回给outer函数
def home():
    time.sleep(2)
    print('from home')
    return '执行home函数之后的返回值'
def index(name):
    time.sleep(1)
    print('from index')
    return '执行index函数之后的返回值'
home = outer(home)
xxx = home()
print(xxx)
index = outer(index)
res = index('jason')
print(res)

  • 装饰器的终极阶段之语法糖

    from functools import wraps
def outer(func_name):
    @wraps(func_name)  # 仅仅是为了让装饰器不容易被别人发现 做到真正的以假乱真
    def inner(*args, **kwargs):
        print('执行被装饰对象之前可以做的额外操作')
        res = func_name(*args, **kwargs)
        print('执行被装饰对象之后可以做的额外操作')
        return res
    return inner

# import time
# def home():
#     time.sleep(1)
#     print('from home')
#     return 'home返回值'


# home = outer(home)
# res = home()
# print(res)
"""
执行home函数之前需要添加校验用户身份的功能
"""

# 装饰器语法糖
import time

@outer  #  home = outer(真正的函数名home)
def home():
    '''我是home函数!!!'''
    time.sleep(1)
    print('from home')
    return 'home返回值'

# help(home)
# print(home)
home()

# def index():
#     '我是index函数 我的功能很强大'
#     pass
#
# help(index)

  • 装饰器模板

    from functools import wraps
def outer(func_name):
    @wraps(func_name)  # 仅仅是为了让装饰器不容易被别人发现 做到真正的以假乱真
    def inner(*args, **kwargs):
        print('执行被装饰对象之前可以做的额外操作')
        res = func_name(*args, **kwargs)
        print('执行被装饰对象之后可以做的额外操作')
        return res
    return inner

多层装饰器

  • 什么是多层装饰器

    多层装饰器指的是将几个装饰器在不改变装饰对象原有的调用方式和内部代码的情况下同时装饰一个装饰对象上面来实现增加多种不同的功能。

    def outter1(func1):  # 7.func1= wrapper2  先调用outter1（wrapper2）加括号，括号内填入它下面的函数名，此时它下面是@outter2，@outter2的结果是wrapper2
    print('我是outter1号')  # 8.打印此代码
    def wrapper1(*args, **kwargs):# 10.调用index相当于调用wrapper1 执行wrapper1
        print('我是wrapper1号')  # 11 打印此代码。
        res1 = func1(*args, **kwargs) # 12.调用func1 此时的func1就是outter1里面的形参绑定的是outter2的返回值wrapper2  那么开始调用wrapper2
        return res1  #9. 此时outter1的返回值是wrapper1，然后它上面没有语法糖了将用index来接收它的返回值。
    return wrapper1

def outter2(func2): # 4.func2 = wrapper3   先调用outter2（wrapper3）加括号，括号内填入它下面的函数名，此时它下面是@outter3 @outter的结果是wrapper3
    print('我是outter2号')  # 5. 打印此代码
    def wrapper2(*args, **kwargs):  # 13.根据上面第11步的代码调用wrapper2，执行wrapper2
        print('我是wrapper2号')  # 14. 打印此代码
        res2 = func2(*args, **kwargs) # 15.调用func2 此时的func2就是outter2里面的形参绑定的是outter3的返回值wrapper3  那么开始调用wrapper3
        return res2  # 6.此时outter2的返回值是wrapper2，他的顶上还有一个语法糖@outter1
    return wrapper2

def outter3(func3):  # 1.func3=index   先调用outter3（index）加括号，括号内填入紧跟它下面的函数名index，将outter3的返回值赋值给变量名index。
    print('我是outter3号')  # 2.打印此代码
    def wrapper3(*args, **kwargs):  # 16.根据上面第14步开始调用wrpper3，执行wrpper3。
        print('我是wrapper3号')  # 17. 打印此代码
        res3 = func3(*args, **kwargs)  # 18.调用func3 此时的func3就是outter3里面的形参绑定的是真正的index 那么等于调用index
        return res3
    return wrapper3  # 3.此时outter3的返回值是wrapper3，那么顶上还有一个语法糖@outter2

#单层语法糖
@outter3  #  @outter3  等同于  index = outter3（index）
def index():
    print('from index')
index()
"""
语法糖功能
        会自动将其下面紧挨着的函数名当作参数传递给@符号后面的函数名（加括号调用）
我是outter3号
我是wrapper3号
from index
"""
# 多层语法糖
@outter1   # (变量名index) = outter1(wrapper2)
@outter2   # wrapper2 = outter2(wrapper3)
@outter3   # wrapper3 = outter3(真正的函数名index)
def index():  # 19.调用 执行index
    print('from index')  # 20. 打印此代码
index()

"""
我是outter3号
我是outter2号
我是outter1号
我是wrapper1号
我是wrapper2号
我是wrapper3号
from index
"""

有参装饰器

  • 什么是有参装饰器

    当一个装饰器内部需要向局部空间获取参数时前面俩个函数无法为其提供传参，

    那么就需要在最外部的函数上面再包一层函数给其加上形参

    def login_auth(func_name):
    def inner(*args, **kwargs):
        username = input('username>>>:').strip()
        password = input('password>>>:').strip()
        if username == 'jason' and password == '123':
            res = func_name(*args, **kwargs)
            return res
        else:
            print('用户权限不够 无法调用函数')
    return inner

"""
需求:在装饰器内部可以切换多种数据来源
	列表
	字典
	文件
"""
def outer(condition,type_user):  # 那么只能在外层在包一层函数，这里用于接受内层所需参数
    def login_auth(func_name):  # 这里是用于接受被装饰对象的函数名，不能再填写其他形参。
        def inner(*args, **kwargs):  # 这里是用于接收被装饰对象所需的参数，也不能填写其他形参。
            username = input('username>>>:').strip()
            password = input('password>>>:').strip()
            # 应该根据用户的需求执行不同的代码
            if type_user =='jason':print('VIP')
            if condition == '列表':
                print('使用列表作为数据来源 比对用户数据')
            elif condition == '字典':
                print('使用字典作为数据来源 比对用户数据')
            elif condition == '文件':
                print('使用文件作为数据来源 比对用户数据')
            else:
                print('去你妹的 我目前只有上面几种方式')
        return inner
    return login_auth
@outer('文件','jason')
def index():
    print('from index')
index()
"""
我们以后遇到的最复杂的装饰器就是上面的 不会比上面更复杂 
目的仅仅是为了给装饰器代码传递更多额外的数据
"""

递归函数

  • 什么是递归函数

    • 递推

      一层层往下寻找答案

    • 回溯

      根据已知条件推导最终结果

    函数直接或者间接调用自己称之为递归函数

    1. 直接调用

      在本体函数体代码内部添加一个本体函数名加括号来直接调用。

      def index():
    print('from index')
	 index()
index()
# 这样会一直循环下去会
# 直到循环次数达到python解释器中的最大限制后报错，才停止！！

    2. 间接调用

      在俩个不同的函数替代码内部田间对方的函数名加括号来间接调用

       def index():
    print('from index')
    func()
 def func():    
    print('from func')
    index()
func()
# 这样也会一直循环下去会
# 直到循环次数达到python解释器中的最大限制后报错，才停止！！

    3. python中允许函数的最大递归调用次数

      官方出的限制是1000用代码去验证可能有些偏差在（997、998......）

      #示例1：自定义计算python中允许的限制次数
count = 1
 def index():
    print('from index')
     global count
    count += 1  # count = count + 1
    print(count)
    index()
index()
# 示例2：
import sys
print(sys.getrecursionlimit())  # 1000  获取递归最大次数
sys.setrecursionlimit(2000)  # 自定义最大次数
print(sys.getrecursionlimit())

递归函数的应用场景

  • 每次调用的时候都必须要比上一次简单

  • 并且递归函数最终都必须要有一个明确的结束条件

    # 示例：
l1 = [1, [2, [3, [4, [5, [6, [7, [8, [9, [10, ]]]]]]]]]]
# 循环打印出列表中所有的数字
# 1.for循环l1里面所有的数据值
# 2.判断当前数据值是否是数字 如果是则打印
# 3.如果不是则继续for循环里面所有数据值
# 4.判断当前数据值是否是数字 如果是则打印
# 5.如果不是则继续for循环里面所有数据值
# 6.判断当前数据值是否是数字 如果是则打印

def get_num(l1):
    for i in l1:
        if isinstance(i,int):
            print(i)
        else:
            get_num(i)
get_num(l1)

算法之二分法

  • 什么是算法

    算法就是解决问题的方法

    算法永远都在精进，但很少有最完美的算法。

  • 二分法

    二分法是所有算法里简单的算法，也有人说二分法不是算法

    l1 = [11, 23, 32, 45, 65, 78, 90, 123, 432, 467, 567, 687, 765, 876, 999, 1131, 1232]


def get_num(l1, target_num):
    # 添加递归函数的结束条件
    if len(l1) == 0:
        print('不好意思 找不到')
        return
    # 1.先获取数据集中间那个数
    middle_index = len(l1) // 2
    middle_value = l1[middle_index]
    # 2.判断中间的数据值与目标数据值孰大孰小
    if target_num > middle_value:
        # 3.说明要查找的数在数据集右半边  如何截取右半边
        right_l1 = l1[middle_index + 1:]
        # 3.1.获取右半边中间那个数
        # 3.2.与目标数据值对比
        # 3.3.根据大小切割数据集
        # 经过分析得知 应该使用递归函数
        print(right_l1)
        get_num(right_l1, target_num)
    elif target_num < middle_value:
        # 4.说明要查找的数在数据集左半边  如何截取左半边
        left_l1 = l1[:middle_index]
        # 4.1.获取左半边中间那个数
        # 4.2.与目标数据值对比
        # 4.3.根据大小切割数据集
        # 经过分析得知 应该使用递归函数
        print(left_l1)
        get_num(left_l1, target_num)
    else:
        print('找到了', target_num)
        # get_num(l1, 999)
get_num(l1, 1000)

"""
二分法缺陷
	1.数据集必须是有序的
	2.查找的数如果在开头或者结尾 那么二分法效率更低!!!
"""

三元表达式

  • 基本语法结构

    值1 if 条件 else 值2

    如果条件成立则使用if前面的数据也就是值1

    如果条件不成立则使用else后面的数据也就是值2

    适用于二选一的情况下。

    name = input("请输入你的账号：")
res = "成功！" if name == 'jason' else "失败！"
print(res)

列表生成式

  • 需求将下列列表中每个数据值后面在多加一个字母o

    list1 = ['aaa', 'bbb', 'ccc', 'ddd', 'eee', 'fff', 'ggg']

  1. 首先，for循环能够实现

    list1 = ['aaa', 'bbb', 'ccc', 'ddd', 'eee', 'fff', 'ggg']
list2 = []  
# 先定义一个空列表
for data in list1:
#     # 使用for将列表每个值取出来
    new_data = data+'o'
#     # 将每个取出来的值拼接个字母o，并将产生的新值赋值给新的变量名
    list2.append(new_data)
#     #  将新的值使用列表的内置方法追加到新列表里
print(list2)
# ['aaao', 'bbbo', 'ccco', 'dddo', 'eeeo', 'fffo', 'gggo']

  2. 其次，列表生成式本质也是用for的来实现但比其更见简洁方便

    ist1 = ['aaa', 'bbb', 'ccc', 'ddd', 'eee', 'fff', 'ggg']
# # 2.再将每个数据值进行一个拼接  1. 先循环取出每个数据值
list2 = [data+'o'for data in list1]
print(list2)
# ['aaao', 'bbbo', 'ccco', 'dddo', 'eeeo', 'fffo', 'gggo']

  3. 列表生成式复杂版，加上if判断还可以增加筛选功能

    # 示例1：
list1 = ['aaa', 'bbb', 'ccc', 'ddd', 'eee', 'fff', 'ggg']
# 3. 将判断好的数据拿来拼接。1.循环获取每个数据值。 2.判断取出的是否是'aaa'如果不是将其舍去如果是将其拼接字母o
list2 = [data+'o'for data in list1 if data =='aaa']
print(list2)  # ['aaao']
# 示例2：
list1 = ['aaa', 'bbb', 'ccc', 'ddd', 'eee', 'fff', 'ggg']
# 3. 将判断好的数据拿来拼接。1.循环获取每个数据值。 2.判断取出的是否是'aaa'如果是将其舍去如果不是将其拼接字母o
list2 = [data+'o'for data in list1 if data !='aaa']
print(list2)  # ['bbbo', 'ccco', 'dddo', 'eeeo', 'fffo', 'gggo']

    如果是for循环加if判断同时出现的列表生成式是不能出现else的因为会产生歧义（for和if是都能使用else的）

字典生成式

  • 示例1

    """
1. for循环依次取出range里面的定义好数量的数据
2. 每次取出的数据当作字典的k，jason默认为字典的v组织成一个k：v键值对
3.依次循环组织成一个新的字典dict1
"""
dict1 = {i: 'jason' for i in range(10)}
print(dict1)
"""
{0: 'jason', 1: 'jason', 2: 'jason',
 3: 'jason', 4: 'jason',5: 'jason', 6: 'jason',
  7: 'jason', 8: 'jason', 9: 'jason'}
"""

  • 示例2

    """
1. for循环依次取出range里面的定义好数量的数据
2. 判断取出来的值是否不等于1如果不成立那么说明这个数据是1将直接丢弃
3.如果成立则将取出的数据当作字典的k，jason默认为字典的v组织成一个k：v键值对
3.依次循环组织成一个新的字典dict2
"""
dict2 = {i: 'jason' for i in range(10) if i != 1}
print(dict2)
"""
{0: 'jason', 2: 'jason', 3: 'jason', 4: 'jason',
5: 'jason', 6: 'jason', 7: 'jason', 8: 'jason', 9: 'jason'}

"""

集合生成式

  • 示例

    """
1. for循环依次取出range里面的定义好数量的数据
2.将每次取出的数据赋值给i
3.将i的数据值添加进集合里依次循环得到一个新的合集
"""

set1 = {i for i in range(10)}
print(set1)  # {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

匿名函数

  • 什么是匿名函数

    匿名函数可以简单的理解为没有函数名的函数

    不同于正常函数的是它可以不需要定义函数名直接写入格式调用

  • 语法结构

    关键字 lambda 参数：返回值

    # 1.直接调用

print((lambda x: x + 100)(3))  # 103

# 2.间接调用

res = (lambda x: x + 100)(30)
print(res)  # 130
"""
匿名函数通常都需要配合其它函数一起使用，用于减少代码
对于单行函数，使用 lambda 表达式可以省去定义函数的过程，让代码更加简洁
"""

匿名函数的应用场景

  • 匿名函数可以配合一些内置函数使用

    • 示例1

      内置函数max

      作用：求出数据最大值

      # 1.需求将下列列表中的数据求出最大值
list1 = [1,6,8,7,6,55,98,55,146,88]
print(max(list1))  # 146

# 求出下列字典中每个人对应工资的最大值
dict1 = {'jason': 100,
         'tony': 6000,
         'tom': 200,
         'zero': 36,
         }
print(max(dict1))  # zero

"""
max的底层原理相当于用个for循环来比较这个字典的中数据的大小
而for循环再针对字典做运算的时候是只针对字典的K做运算V不参与
那么得出的结论就是这个字典的k，
字符串在做比较字符串做比较的时候是根据字符编码中的ACSSI码表来比较
ASCCI码表中 A-Z 对应的是65-90 a-z对应的是97-122 
而这个时候想要得出字典k对应的v的最大值可以运用函数
"""
# 方式1 自定义函数
def statistics(data):
    return dict1.get(data)
print(max(dict1, key=statistics))  # tony

# 方式2 匿名函数
print(max(dict1,key=lambda x:dict1.get(x)))  # tony
"""
1.循环这个字典依次取出每个k将拿到的k交给函数statistics
2.函数statistics拿到k后将它的V取出交给max来比较
3.依次循环比较得到结果 tony的工资最高
"""

    • 示例2

      内置函数map

      作用：（映射）将处理好的数据以之前的位置放入一个新的列表中 。

      # 1. 需求将下列列表中的数据值都自增30
list1 = [1, 6, 7, 8, 55, 55, 88, 98, 146]
# 方式1 for循环可以实现
list2 = []
for i in list1:
    i += 30
    list2.append(i)
print(list2)
# [31, 36, 37, 38, 85, 85, 118, 128, 176]

# 方式2 列表生成式
list2 = [i + 30 for i in list1]
print(list2)
# [31, 36, 37, 38, 85, 85, 118, 128, 176]

# 方式3 map+自定义函数、map+匿名函数。
# 自定义函数
def add_to(x):
    return x+30
new_list = map(add_to,list1)
print(list(new_list))
# [31, 36, 37, 38, 85, 85, 118, 128, 176]
# 匿名函数
new_list = map(lambda x: x + 30, list1)
print(list(new_list))
# [31, 36, 37, 38, 85, 85, 118, 128, 176]

    • 示例3

      内置函数min

      作用：求出数据中最小值

      dict1 = {'jason': 100,
         'tony': 6000,
         'tom': 200,
         'zero': 36,
         }
print(min(dict1,key=lambda x:dict1.get(x)))  # zero

    • 示例4

      内置函数filter

      作用：将某个指定的数据值移除

      # 1.将字符串a从列表中那个移除
# 列表的内置方法也能实现，如remove、pop，不过过于繁琐。
list1 = ['a', 'b', 'v', 'a', 'u', 'p', 'i', 'l', 'a', 't', 'n']
# 方式1 for循环
list2 = []
for i in list1:
    if i != 'a':
        list2.append(i)
print(list2)
# ['b', 'v', 'u', 'p', 'i', 'l', 't', 'n']

# 方式2列表生成式
list2 = [i for i in list1 if i != 'a']
print(list2)
# ['b', 'v', 'u', 'p', 'i', 'l', 't', 'n']

# 方式3 filter+自定义函数、 filter+匿名函数。
# filter+自定义函数
def my_remove(x):
    return x != 'a'


list2 = filter(my_remove, list1)
print(list(list2))
# ['b', 'v', 'u', 'p', 'i', 'l', 't', 'n']

# filter+匿名函数
list2 = filter(lambda x: x != 'a', list1)
print(list(list2))
# ['b', 'v', 'u', 'p', 'i', 'l', 't', 'n']

    • 示例5

      内置函数

      作用：将单个数据整合成一个整体

      # 1. 需求将下列列表中的字符串整合到一起
list1 = ['n', 'a', 'm', 'e', '.', 't', 'x', 't', ]
# u = ''
# # 方式1 for循环
 for i in list1:
    u += i
print(u)  # name.txt
# 方式2.reduce+匿名函数
 from functools import reduce
 list2 = reduce(lambda x, y: x + y, list1)
 print(list2)  # name.txt

    • 示例6

      内置函数zip

      作用：可以将多个装有不同类型的整体按照位置拼接到元组里

      l1 = 'abcdefg'
l2 = [11, 22, 66, 88, 44, 666, 444]
l3 = {'kk': 11, 'qq': 22, 'ii': 33, 'rr': 44, 'hh': 55, }
l4 = (1, 2, 3, 4, 5, 6, 7, 9)

l5 = dict(zip(l1, l2, ))
#如果想要做成字典类型可以根据字典的类型转换
print(l5)
# {'a': 11, 'b': 22, 'c': 66, 'd': 88, 'e': 44, 'f': 666, 'g': 444}

"""
将不同数据类型的数据根据位置拼接组成多个元组的形式
元组的数量取决于你想要拼接的多个数据长度的最小值来决定
zip的底层原理也是基于for循环的原理
将所放入的数据根据位置一一对应循环取出组成元组依次循环
"""
posted @ 2022-07-11 20:56  瓮小辉  阅读(22)  评论(0)    收藏  举报