随笔- 71 文章- 17 评论- 0 阅读- 5345

三元表达式

三元表达式：偷懒写法，减少代码行数
三元表达式雏形

 # 获取用户输入的用户名 如果是jason就打印欢迎 否则打印滚蛋
# 一般编写
username = input('username>>>:').strip()
if username == 'jason':
    print('welcome')
else:
    print('go back')
 
# 三元表达式雏形
username = input('username>>>:').strip()
if username == 'jason':print('welcome')
else:print('go back')
 
# 三元表达式完整
username = input('username>>>:').strip()
print('welcome') if username == 'jason' else print('go back')

三元表达式语法结构：值1 if 条件 else 值2（注意：没有冒号）
- 如果if后面的条件成立，则使用if前面的值
- 如果if后面的条件不成立，则使用else后面的值

 # 编写一个函数，比较两个数的大小，返回较大的数
# 一般编写
def max_num(a, b):
    if a > b:
    	return a
    else:
        return b
res = max_num(1, 10)
print(res) # 10
 
# 三元表达式编写
def max_num(a, b):
    return a if a > b else b
res = max_num(1, 10)
print(res) # 10

三元表达式：仅限于二选一的情况并且不建议嵌套使用

 res = 123 if 10 > 5 else (222 if 0 else (666 if 1 == 2 else 666)) # 不建议嵌套使用

注意：在python中代码不是精简的越少越好，在精简的过程中还要保证代码的可读性

生成式

列表生成式

概念：列表生成式是python内置的一种创建列表的方法，通过在[]内部执行一行for循环语句，将for循环所遍历到的元素添加到列表中
特点：
1. 比普通的采用append方法生成列表要快
2. 列表生成式编写的代码更加简洁
3. 通过添加if else 语句，列表生成式也能对列表里的元素进行限制
语法结构：
- [表达式 for 变量 in 列表] 先执行for循环，然后将一个个的数据值交给for循环前面处理
- [表达式 for 变量 in 列表 if 条件] 先执行for循环，然后将一个个的数据值交给if判断，结果为True则最后交给for循环前面处理
注意：列表生成式中只能出现for和if

 # 给列表中所有的数据值加上_NB的后缀
name_list = ['jason', 'kevin', 'oscar', 'jerry', 'tony']
# 1.定义一个新的列表
new_list = []
# 2.循环原列表中所有的数据值
for name in name_list:
    # 3.拼接_NB后缀
    new_name = name + '_NB'
    # 4.追加到新列表中
    new_list.append(new_name)
    print(new_list)
    
    
"""一行代码解决列表生成式"""
# 先执行for循环 然后将一个个的数据值交给for循环前面处理
new_list = [name + '_NB' for name in name_list]
print(new_list)
# 先执行for循环 然后将一个个的数据值交给if判断 结果为True则最后交给for循环前面处理
new_list = [name + '_NB' for name in name_list if name != 'jason']
print(new_list)

字典生成式

概念：python的字典生成式通过在大括号{} 内执行一行for循环语句创建一个新的字典，大括号内的语句需要指定键值对的key与value，这两项值都是for循环语句中变量
语法结构：
- {key: values for 变量名 in 数据集} 或 {key: values for 变量名 in 数据集 if 条件}
- 跟列表生成式相似

 new_dict = {i: 'jason' for i in range(10)}
print(new_dict) # {0: 'jason', 1: 'jason', 2: 'jason', 3: 'jason', 4: 'jason', 5: 'jason', 6: 'jason', 7: 'jason', 8: 'jason', 9: 'jason'}
 
new_dict = {i: 'jason' for i in range(10) if i == 6}
print(new_dict)  # {6: 'jason'}

集合生成式

概念：python集合生成式与列表生成式几乎是一模一样的，只需要将[]替换为{} 即可，在{}内执行一个for循环语句，for循环所遍历的元素自动添加到集合之中

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

注意：元组没有生成式，它是后面重点讲解的迭代器知识(生成器)

 new_tuple = (i for i in range(10))
print(new_tuple) # <generator object <genexpr> at 0x000001E62B8ED740>

匿名(lambda)函数

概念

匿名函数，也称为lambda函数，是没有定义名称的函数

作用

创始一个匿名函数对象，同 def 类似，但不提供函数名，只是一个表达式，lambda比函数简单且可以随时创建和销毁，有利于减少程序的偶合度。lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数

语法结构

lambda 形参:返回值
ambda函数可以具有任意数量的参数，但只能有一个表达式，不用写return，返回值就是该表达式的结果。Lambda函数可在需要函数对象的任何地方使用

注意

lambda 表达式创建的函数只能包含一条表达式
由于lambda函数返回的是函数对象（构建的是一个函数对象），所以需要定义一个变量去接收，即匿名函数同样需要被调用才能执行，调用仍然使用()传参的方式实现
匿名函数同样可以定义有返回值没有返回值，有参数没有参数的情况

具体案例

 (lambda x: x + 1)(123) # 直接调用
res = lambda x: x + 1 # 命名调用
print(res(123))

应用场景

匿名函数通常都需要配合其他函数一起使用，用于减少代码
相比函数，lamba 表达式具有以下 2 个优势：
- 对于单行函数，使用 lambda 表达式可以省去定义函数的过程，让代码更加简洁
- 对于不需要多次复用的函数，使用 lambda 表达式可以在用完之后立即释放，提高程序执行的性能

重要内置函数

内置函数概念

Python内置函数是Python编程语言中预先定义的函数。嵌入到主调函数中的函数称为内置函数，又称内嵌函数。作用是提高程序的执行效率，内置函数的存在极大的提升了程序员的效率和程序的阅读。

max()函数

定义和用法：返回给定集合里最大的元素（最大值），可以指定排序的方法。如果值是字符串，则按字母顺序进行比较

 l1 = [223, 3423, 123, 24, 34, 35, 435, 3, 24, 3534, 53, 24, 234, 132, 4234, 456, 456, 5345, 4, 234, 345, 23, 2123432]
res = max(l1)
print(res)  # 2123432
 
 
# 值是字符串，按字母顺序进行比较 
# A-Z   65-90 
# a-z   97-122
dic = {
    'jason': 100,
    'aj': 123,
    'Bason': 9999999,
    'zero': 888
}
print(max(dic)) # zero
 
# 用key这个参数对字典的值进行判断
def index(k):
    return dic.get(k)
res = max(dic, key=index)
print(res)  # Bason

min()函数

定义和用法：返回给定集合里最小的元素（最小值），可以指定排序的方法。如果值是字符串，则按字母顺序进行比较

 l1 = [223, 3423, 123, 24, 34, 35, 435, 3, 24, 3534, 53, 24, 234, 132, 4234, 456, 456, 5345, 4, 234, 345, 23, 2123432]
res = min(l1)
print(res)  # 3
 
# 值是字符串，按字母顺序进行比较
# A-Z   65-90
# a-z   97-122
dic = {
    'jason': 100,
    'aj': 123,
    'Bason': 9999999,
    'zero': 888
}
print(min(dic)) # Bason
 
# 用key这个参数对字典的值进行判断
def index(k):
    return dic.get(k)
res = min(dic, key=index)
print(res)  # jason

map()函数

定义和用法：映射函数。使用指定的函数，处理可迭代对象，并将结果保存在一个map对象中

 l1 = [11, 22, 33, 44, 55, 66]
# 需求:将列表中所有的数据值自增20
# 方式1:for循环
l2 = []
for i in l1:
    l2.append(i+20)
print(l2)  # [31, 42, 53, 64, 75, 86]
# 方式2:列表生成式
l2 = [i + 20 for i in l1]  # 更简便了
print(l2)  # [31, 42, 53, 64, 75, 86]
# 方式3:map函数
def index(a):
    return a + 20
res = map(index, l1)
print(list(res)) # [31, 42, 53, 64, 75, 86]

filter()函数

定义和用法：过滤器，用法和map类似。在函数中设定过滤的条件，逐一循环对象中的元素，将返回值为True时的元素留下（注意，不是留下返回值！），形成一个filter类型的迭代器

 l1 = ['jason', 'kevin', 'oscar', 'tony']
# 需求:移除数据值里面的jason
# 方式1:for循环
l2 = []
for i in l1:
    if i != 'jason':
        l2.append(i)
print(l2)  # ['kevin', 'oscar', 'tony']
# 方式2:列表生成式
l2 = [i for i in l1 if i != 'jason']
print(l2)  # ['kevin', 'oscar', 'tony']
# 方式3:filter()
def index(a):
    return a != 'jason'
res = filter(index, l1)
print(list(res)) # ['kevin', 'oscar', 'tony']

reduce()函数

定义和用法：会对参数序列中元素进行累积。函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果

 l2 = [1, 2, 3]
# 需求:求列表中所有数据值的和
# 方式1:for循环
count = 0
for i in l2:
    count += i
print(count)  # 6
# 方式2:sum() sum可以求得数据集的总和，只能判断数字相关的类型
res = sum(l2)
print(res) # 6
# 方式3:reduce()   将很多单体 变成一个整体
from functools import reduce
 
res = reduce(lambda x, y: x + y, l2, 100)
res = reduce(lambda x, y: x + y, l2, 100)
print(res) # 106

zip()函数

定义和用法：组合对象，将对象逐一配对

 n1 = [1, 2, 3]
n2 = ['jason', 'kevin', 'oscar']
res = zip(n1, n2)
print(res)  # <zip object at 0x000002A9E38C7F40>
print(list(res)) # [(1, 'jason'), (2, 'kevin'), (3, 'oscar')]
 
n1 = [1, 2, 3, 4]
n2 = [5, 6, 7, 8]
n3 = 'jack'
res = zip(n1, n2, n3)
print(list(res)) # [(1, 5, 'j'), (2, 6, 'a'), (3, 7, 'c'), (4, 8, 'k')]
 
 
n1 = [1, 2, 3, 4, 5, 6, 7]
n2 = [5, 6, 7, 8]
n3 = 'jason'
res = zip(n1, n2, n3)
print(list(res)) # [(1, 5, 'j'), (2, 6, 'a'), (3, 7, 's'), (4, 8, 'o')]

匿名函数集合内置函数使用

max/min()与lambda函数（匿名函数）集合使用

 dic = {
    'jason': 100,
    'aj': 123,
    'Bason': 9999999,
    'zero': 888
}
 
# max函数与lambda函数（匿名函数）集合使用
def index(k):
    return dic.get(k)
# res = max(dic, key=lambda k: dic.get(k))
res = max(dic, key=index)
print(res)  # Bason
 
# min函数与lambda函数（匿名函数）集合使用
def index(k):
    return dic.get(k)
# res = min(dic, key=lambda k: dic.get(k))
res = min(dic, key=index)
print(res)  # jason

map与lambda函数（匿名函数）集合使用

 l1 = [11, 22, 33, 44, 55, 66]
res = map(lambda x: x + 20, l1)
print(res)  # <map object at 0x000001954B581100>
print(list(res)) # [31, 42, 53, 64, 75, 86]

filter与lambda函数（匿名函数）集合使用

 l1 = ['jason', 'kevin', 'oscar', 'tony']
res = filter(lambda a: a != 'jason', l1)
print(res)  # <filter object at 0x00000195F21E6C70>
print(list(res))  # ['kevin', 'oscar', 'tony']

reduce与lambda函数（匿名函数）集合使用

 l2 = [1, 2, 3]
from functools import reduce
 
res = reduce(lambda x, y: x + y, l2, 100)
res = reduce(lambda x, y: x + y, l2, 100)
print(res) # 106

作业

多层装饰器

 装饰器本质是在不改变装饰对象原来的“调用方式”和“内部代码”的情况下给被装饰的对象添加功能
多层装饰器就是在一个装饰器上再添加一个或多个装饰器，然后多个装饰器语法糖装饰同一个函数的时候
语法糖会自动将下面紧挨着的函数名当做参数传递给@符号后面的函数名，语法糖从下往上依次执行装饰器内的代码
将外层的函数从上往上下依次执行到最后回到最开始的真正的函数名
然后再从上往下执行内部的函数，最后回到要执行的那个函数

有参装饰器

 编写一个装饰器时，当这个装饰器内部需要外界传入额外的数据来控制代码的分支或循环
而给函数体代码传值有两种方式，一个是通过形参传值，另一个是闭包函数
在装饰器的外部函数的括号内只能用来接收被装饰的函数名，不能填写其他形参
装饰器的内部函数也不能填写其他形参，所以就需要给原来的装饰器模板再套用一层闭包函数
将需要传入的参数设置为形参（可以多个参数）
返回值为原外层函数，加语法糖时就直接添加额外的数据

posted on 2022-07-07 21:06 念白SAMA 阅读(74) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 第四周整理笔记

· 闭包函数、装饰器

· 三元表达式、各生成式、匿名函数

· 【python基础】第20回三元匿名重要内置函数

· 匿名函数三元表达式各种生成式

阅读排行：
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· Manus的开源复刻OpenManus初探
· AI 智能体引爆开源社区「GitHub 热点速览」
· 三行代码完成国际化适配，妙~啊~
· .NET Core 中如何实现缓存的预热？

公告

昵称：念白SAMA
园龄： 2年8个月
粉丝： 5
关注： 3

+加关注

2025年3月

日

一

二

三

四

五

六

随笔档案

2022年12月(1)

2022年9月(1)

2022年8月(13)

2022年7月(21)

2022年6月(18)