多层装饰器、万能装饰器、匿名函数、匿名函数作为参数、列表推导式、集合推导式、字典推导式、生成式

最新推荐文章于 2024-06-10 15:06:19 发布

小段小段积极向上

最新推荐文章于 2024-06-10 15:06:19 发布

阅读量242

点赞数 1

分类专栏： python 文章标签： python

本文链接：https://blog.csdn.net/dyx0910/article/details/124252194

版权

python 专栏收录该内容

23 篇文章 0 订阅

订阅专栏

多层装饰器

"""
多层装饰器器：谁离函数近先装饰谁
"""
#定义装饰器
def zhuang1(func):
    print("我是装饰器1")

    def inner():
        print("刷漆")
        func()
    return inner
def zhaung2(func):
    print("我是装饰器2")
    def inner():
        print("铺地板")
        func()
    return inner

#定义一个被装饰的函数
@zhaung2
@zhuang1
def house():
    print("毛坯房")
house()
None

万能装饰器

# 万能装饰器当被装饰的函数，参数为多值参数的时候,可以使用这种形式
# 万能装饰器也可以用来装饰普通的函数
# 定义装饰器
def set_func(func):
    def call_fun(*args, **kwargs):
        print("添加额外功能")
        return func(*args, **kwargs)

    # 返回原先函数的返回值
    return call_fun

#被装饰的函数
@set_func
def test(*args, **kwargs):
    print(args) # 元组   (1, 2, 3, 4, 5, "a", "b", "c",)
    print(kwargs) # 字典 {"num":2}
    print("tdsjasjflasj")

var = test(1, 2, 3, 4, 5, "a", "b", "c", num=2)
print(var)

普通装饰器

def set_func(func):
    def call_fun(*args, **kwargs):
        print("添加额外功能")
        return func(*args, **kwargs)

    # 返回原先函数的返回值
    return call_fun
@set_func # 糖衣
def man():
    print("好好上班！")
man()

匿名函数: 简化函数定义

不再使用def来定义函数 而是使用lambda

格式:lambda 参数1参数2...:运算

def func_name():
    pass

#可以使用匿名函数的方式来定义函数---->不需要再考虑函数的命名
def add(a,b):
    result =a+b
    return result

var1 = add(1,2)
print(var1)

#相当于定义了add函数
var2 = lambda a,b:print(a+b)#a和b是参数 print(a+b)是返回值 var2来接收返回值
var2(1,2) #通过var2传递参数

匿名函数作为参数

def func1(x,y,func):
    print(x,y) #1,2
    print(func) #<function <lambda> at 0x000001DFB361A290>
    s = func(x,y)
    print(s) #3
#调用func1
func1(1,2,lambda a,b:a+b)

列表推导式

"""
#通过旧的列表利用推导式生成新的列表
格式：
[表达式 for 变量 in 旧列表]
或者[表达式 for 变量 in 旧列表 if 条件]
"""
names = ['tom','lily','lucy','jack','ka']

new_names = []
for name in names:#for循环遍历names列表
if len(name) > 3:
new_names.append(name)
print(new_names)

#用name来生成一个新列表，条件是先遍历names列表，拿去字符串长度大于3的元素
new_names1 = [name for name in names if len(name) > 3]

print(new_names1)

列表推导式练习

"""
#案例2：将1-100之间能被3整除的数字，组成一个新的列表
"""
#做一个1-100之间的集合
new_li = []
for i in range(1,101):
if i % 3 == 0:
new_li.append(i)

print("正常的书写方式------>",new_li)

new_li1 = [i for i in range(1,101) if i % 3 == 0]
print("列表推导式的方式------>",new_li1)

print(new_li == new_li1) #True
print(new_li is new_li1) #False

列表推导式练习2

"""
# 案例3：要求0-5之间的偶数、奇数，构成一个元组    列表
# [(偶数,奇数),(偶数,奇数),(偶数,奇数)]
# eg: [(0,1),(0,3),(0,5),,,,(4,5)]
"""
def func():
    new_list = []
    for i in range(5):
        # 偶数
        if i % 2 == 0:
            for j in range(5):
                if j % 2 != 0:
                    new_list.append((i, j))

    return new_list

print(func())

new_list1 = [(x, y) for x in range(5) if x % 2 == 0 for y in range(5) if y % 2 != 0]
print(new_list1)

"""
# 案例4：
list1 = [[1,2,3],[4,5,6],[7,8,9],[1,3,5]] #得出----> [3,6,9,5]
"""
list1 = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [1, 3, 5]]
new_list = []
for li in list1:
new_list.append(li[-1])
print(new_list)

new_list = [li[-1] for li in list1]
print(new_list)

"""
案例5：
列表推导式之 if...else

调整员工的 salary
if salary 大于5000 加200，低于5000 加500
"""
dict1 = {'name': 'Tom', 'salary': 5000}
dict2 = {'name': 'lucy', 'salary': 8000}
dict3 = {'name': 'jack', 'salary': 4500}
dict4 = {'name': 'lily', 'salary': 3000}
salary_list = [dict1, dict2, dict3, dict4]
for i in salary_list:
    # print(i["salary"] )
    if i["salary"] > 5000:
        i["salary"] += 200

    elif i["salary"] < 5000:
        i["salary"] += 500

print(salary_list)

dict1 = {'name': 'Tom', 'salary': 5000}
dict2 = {'name': 'lucy', 'salary': 8000}
dict3 = {'name': 'jack', 'salary': 4500}
dict4 = {'name': 'lily', 'salary': 3000}
salary_list = [dict1, dict2, dict3, dict4]

new_list = [i["salary"] + 200 if i["salary"] > 5000 else i["salary"] + 200 for i in salary_list]

print(new_list) # [5200, 8200, 4700, 3200]
print(salary_list)

n = 0
for i in new_list: # 遍历 # [5200, 8200, 4700, 3200]
    salary_list[n]["salary"] = i # 遍历原理的旧字典的列表，挨个给每个元素赋值
                                  # [{'name': 'Tom', 'salary': 5000}, {'name': 'lucy', 'salary': 8000}, {'name': 'jack', 'salary': 4500}, {'name': 'lily', 'salary': 3000}]
    n += 1

print(salary_list)

集合推导式

"""
类似于列表推导式，在列表推导式的基础上添加了一个去除重复项的功能
"""
list1 = [1,2,1,3,5,2,1]
new_set = {x for x in list1}

print(new_set)

#添加条件对小于5的元素进行+1操作
new_set2 = {i+1 if i < 5 else i for i in new_set}
print(new_set2)

字典推导式

"""
案例：
需求：对字典的key和value进行交换
"""
#定义一个字典
dict1 = {'a':'A','b':'B','c':'D'}
dict2 = {value:key for key,value in dict1.items()}
print(dict2)

#dict1.items() 字典解封装
print(dict1.items())#数据类型：dict_items
#dict_items([('a', 'A'), ('b', 'B'), ('c', 'D')])

for i in dict1:
print(i)

生成式

# 将 1-20的数字进行 *3的操作

new_list = [i * 3 for i in range(5)]
print(new_list) #[0, 3, 6, 9, 12]
"""
当我们再调用 new_list的时候，实际上，再内存中，会先创建该列表，
如果打印或者遍历列表，再从这个内存中取取值，进行相对于的操作

如果一个列表有 100万个元素，只需要对前10个元素进行操作，是否也需要给 100万个元素的列表开空间？
"""
#需求只取 new_list 的前 3 个值

var = new_list.__iter__() # 迭代器
print(var) # <list_iterator object at 0x000001265CED96F0>
print(var.__next__()) # 0
print(var.__next__()) # 3
print(var.__next__()) # 6
print(next(var)) # var.__next__() 等价于 next(var)
print(next(var))

#如果使用迭代器的次数，大于了集合元素的个数，系统报错： StopIteration

"""
案例：对于无限循环对象的处理
斐波那契数列
"""
def fib(length):
    a, b = 0, 1 #
    n = 0
    while n < length:
        yield b # yield 相当于 return b, 但是，yield 后面的
                 # 代码暂时先不执行，当下次迭代的时候，再继续执行(程序处于阻塞态)
        a, b = b, a + b
        n += 1
    # return print(b)

g = fib(100)
print(g.__next__())   # print(next(g)) 1
print(next(g)) # 1
print(next(g)) # 2
print(next(g)) # 3

生成式练习

def func():
    i = 0
    while i < 5:
        temp = yield i #看到函数中有yield 就是生成式
        print("temp----->",temp)

        i += 1
    return "没有更多数据了!"

result = func()
#print(result.__next__()) #输出结果是0 ----->yield i
#print(result.__next__()) #输出结果temp-----> None
                               # 1
print(result.send(None))#如果第一次生成内容使用的是send()，而且传值，会报错
                        # TypeError: can't send non-None value to a just-started generator
                        #这行代码相当于result.__next__()
print(result.__next__()) #没有传值的功能
print(result.send("第一个值"))
print(result.send("第二个值")) #send()有next()的功能，同时会向生成式中传递值
#print("result----->",result)

"""
迭代器和生成器都用来产生出具有巨大数量的列表、字典、集合等前面的一些值，而不需要一次性将这个巨大的列表、字典、集合加载到内存
可以使用迭代器result.__next__()方法或者result.next()，每执行一次，就产生一个值
#生成式
#函数的形式函数内部有关键字 yield就是一个生成式
#可以使用result.__next__()或者result.next()当函数需要再yield后面传递值的时候，可以使用result.send()
#如果第一次就用send()，则不能传值
"""