函数进阶装B操作

三元表达式

条件成立时的返回值 if 条件 else 条件不成立时的返回值

x = 10
y = 20

print(f"x if x > y else y: {x if x > y else y}")
x if x > y else y: 20

dog_name = 'crazy_dog1'

# if dog_name == 'crazy_dog':
#     print('疯狂舔🐕')
# else:
#     print('溜了')

# 三元表达式/列表推导式/字典生成式 只是让你的代码更少了，但是逻辑没有变化
print('疯狂舔🐕') if dog_name == 'crazy_dog' else print('666')

# 三元表达式只支持双分支结构

列表推导式

[expression for item1 in iterable1 if condition1
for item2 in iterable2 if condition2
...
for itemN in iterableN if conditionN
]
类似于
res=[]
for item1 in iterable1:
    if condition1:
        for item2 in iterable2:
            if condition2
                ...
                for itemN in iterableN:
                    if conditionN:
                        res.append(expression)
print(F"[i for i in range(10)]: {[i for i in range(10)]}")
[i for i in range(10)]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(F"[i**2 for i in range(10)]: {[i**2 for i in range(10)]}")
[i**2 for i in range(10)]: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

下面只是秀操作，不推荐使用，否则只有你自己看得懂了。

50三元表达式与列表推导式.jpg?x-oss-process=style/watermark

name_list = ['nick', 'sean', 'jason', 'tank']

print(
    f"[name if name=='nick' else name+'sb' for name in name_list]: {[name if name=='nick' else name+'sb' for name in name_list]}")
[name if name=='nick' else name+'sb' for name in name_list]: ['nick', 'seansb', 'jasonsb', 'tanksb']

# lt = [0,1,2,3,4]


# lt = []
# for i in range(10):
#     lt.append(i**2)
#
# print(lt)


# lt = [i ** 2 for i in range(10)]
# print(lt)

dic = {'a': 1, 'b': 2}

lt = [(k, v) for (k, v) in dic.items()]
print(lt)

字典生成式

print({i: i**2 for i in range(10)})
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

zip()方法

keys = ['name', 'age', 'gender']
values = ['nick', 19, 'male']

res = zip(keys, values)
print(F"zip(keys,values): {zip(keys,values)}")

info_dict = {k: v for k, v in res}
print(f"info_dict: {info_dict}")
zip(keys,values): <zip object at 0x11074c088>
info_dict: {'name': 'nick', 'age': 19, 'sex': 'male'}

通过解压缩函数生成一个字典

info_dict = {'name': 'nick', 'age': 19, 'gender': 'male'}
print(f"info_dict.keys(): {info_dict.keys()}")
print(f"info_dict.values(): {info_dict.values()}")

res = zip(info_dict.keys(), info_dict.values())
print(F"zip(keys,values): {zip(info_dict.keys(),info_dict.values())}")

info_dict = {k: v for k, v in res}
print(f"info_dict: {info_dict}")
info_dict.keys(): dict_keys(['name', 'age', 'gender'])
info_dict.values(): dict_values(['nick', 19, 'male'])
zip(keys,values): <zip object at 0x1105cefc8>
info_dict: {'name': 'nick', 'age': 19, 'gender': 'male'}

dic = {'a': 1, 'b': 2}

# new_dic = {k * 2: v ** 2 for k, v in dic.items()}
# print(new_dic)

# 字典生成式一般与zip(拉链函数--》列表里面包了元组)连用
z = zip(['a', 'b', 'c', 'd'], [1, 2, 3, 4])  # 压缩方法，Python解释器的内置方法
# for k,v in z:
#     print(k,v)

dic = {k: v ** 2 for k, v in zip(['a', 'b', 'c', 'd'], [1, 2, 3, 4])}  # 不能写这种代码
print(dic)

生成器

生成器： 自定义迭代器， 生成器就是迭代器（自己造出来的）

一、yield关键字

迭代器对象： 具有_iter_, _*_next__的方法

yield的英文单词意思是生产，在函数中但凡出现yield关键字，再调用函数，就不会继续执行函数体代码，而是会返回一个值。

52生成器-停止.jpg?x-oss-process=style/watermark

def func():
    print(1)
    yield
    print(2)
    yield


g = func()
print(g)
<generator object func at 0x10ddb6b48>

生成器的本质就是迭代器，同时也并不仅仅是迭代器，不过迭代器之外的用途实在是不多，所以我们可以大声地说：生成器提供了非常方便的自定义迭代器的途径。并且从Python 2.5+开始，[PEP 342：通过增强生成器实现协同程序]的实现为生成器加入了更多的特性，这意味着生成器还可以完成更多的工作。这部分我们会在稍后的部分介绍。

def func():
    print('from func 1')
    yield 'a'
    print('from func 2')
    yield 'b'


g = func()
print(F"g.__iter__ == g: {g.__iter__() == g}")

res1 = g.__next__()
print(f"res1: {res1}")

res2 = next(g)
print(f"res2: {res2}")

# next(g)  # StopIteration
g.__iter__ == g: True
from func 1
res1: a
from func 2
res2: b
def func():
    print('from func 1')
    yield 'a'
    print('from func 2')
    yield 'b'


g = func()
for i in g:
    print(i)

print(f"list(func()): {list(func())}")
from func 1
a
from func 2
b
from func 1
from func 2
list(func()): ['a', 'b']

# def func():
#     yield 456  # yield会使函数func()变成生成器对象，因此他就具有__iter__方法
#     print(789) # yield会停止函数，当运行下一次next才会继续运行下面的代码
#     yield 101112 # 一个yield对应一个next
#     print(131415)
#
# f = func()  # 生成器
# print(f)  # <generator object func at 0x000001F0E44237D8>
# f_iter = f.__iter__()
# print(f_iter.__next__())
# print(f_iter.__next__())
# print(f_iter.__next__())

yield的三个特性

  1. yield可以把函数变成生成器（自定制的迭代器对象，具有__iter__和__next__方法）
  2. yield可以停止函数，再下一次next再次运行yield下面的代码
  3. 有n个yield生成器就有n个元素，就可以next n次， 第n+1次next会报错

1.1 yield+return??**

既然生成器函数也是函数，那么它可以使用return输出返回值吗？

亲，既然你都选择自定义一个函数作为生成器，你还return干啥？如果这是在Python2中，Python解释器会赠送给你一个异常，但是在Python3中，他也不管你这种傻瓜行为了。

def i_wanna_return():
    yield 'a'
    yield 'b'
    return None
    yield 'c'


for i in i_wanna_return():
    print(i)
a
b

1.2 迭代器套迭代器

如果我需要在生成器的迭代过程中接入另一个生成器的迭代怎么办？写成下面这样好傻好天真。并且你这样做的意图是什么？？？

def sub_generator():
    yield 1
    yield 2
    for i in range(3):
        yield i


for i in sub_generator():
    print(i)
1
2
0
1
2
def sub_generator():
    yield 1
    yield 2
    yield from range(3)


for i in sub_generator():
    print(i)
1
2
0
1
2

二、协同程序

协同程序（协程）一般来说是指这样的函数：

  • 彼此间有不同的局部变量、指令指针，但仍共享全局变量；
  • 可以方便地挂起、恢复，并且有多个入口点和出口点；
  • 多个协同程序间表现为协作运行，如A的运行过程中需要B的结果才能继续执行。

协程的特点决定了同一时刻只能有一个协同程序正在运行（忽略多线程的情况）。得益于此，协程间可以直接传递对象而不需要考虑资源锁、或是直接唤醒其他协程而不需要主动休眠，就像是内置了锁的线程。在符合协程特点的应用场景，使用协程无疑比使用线程要更方便。

从另一方面说，协程无法并发其实也将它的应用场景限制在了一个很狭窄的范围，这个特点使得协程更多的被拿来与常规函数进行比较，而不是与线程。当然，线程比协程复杂许多，功能也更强大，所以我建议大家牢牢地掌握线程即可，是不是听了一脸懵逼，那么就别管他了，因为并发编程你会重新学习他。因此这一节里我也就不列举关于协程的例子了，以下介绍的方法了解即可。

由于Python2.5+对生成器的增强实现了协程的其他特点，在这个版本中，生成器加入了如下方法：

2.1 send(value):

send是除next外另一个恢复生成器的方法。Python2.5+中，yield语句变成了yield表达式，这意味着yield现在可以有一个值，而这个值就是在生成器的send方法被调用从而恢复执行时，调用send方法的参数。

def h():
    print('--start--')
    first = yield 5  # 等待接收 Fighting! 值
    print('1', first)
    second = yield 12  # 等待接收 hahaha! 值
    print('2', second)
    yield 13
    print('--end--')


g = h()
first = next(g)  # m 获取了yield 5 的参数值 5
# (yield 5)表达式被赋予了'Fighting!',  d 获取了yield 12 的参数值12
second = g.send('Fighting!')
third = g.send('hahaha!')  # (yield 12)表达式被赋予了'hahaha!'
print(f'--over--')
print(f"first:{first}, second:{second}, third:{third}")
--start--
1 Fighting!
2 hahaha!
--over--
first:5, second:12, third:13
  • 调用send传入非None值前，生成器必须处于挂起状态，否则将抛出异常。不过，未启动的生成器仍可以使用None作为参数调用send。
  • 如果使用next恢复生成器，yield表达式的值将是None。

2.2 close()

这个方法用于关闭生成器。对关闭的生成器后再次调用next或send将抛出StopIteration异常。

def repeater():
    n = 0
    while True:
        n = (yield n)


r = repeater()
r.close()
print(next(r))  # StopIteration

2.3 throw(type, value=None, traceback=None)

中断Generator是一个非常灵活的技巧，可以通过throw抛出一个GeneratorExit异常来终止Generator。Close()方法作用是一样的，其实内部它是调用了throw(GeneratorExit)的。我们看close的源代码：

def close(self):
    try:
        self.throw(GeneratorExit)
    except (GeneratorExit, StopIteration):
        pass 
    else:
        raise RuntimeError("generator ignored GeneratorExit") # Other exceptions are not caught

三、自定义range()方法

def my_range(start, stop, step=1):
    while start < stop:
        yield start
        start += 1


g = my_range(0, 3)
print(f"list(g): {list(g)}")
list(g): [0, 1, 2]

# 用生成器自定制一个range方法


# range(10)

# 1. 生成一个可迭代器对象 --- 》 我要把我的range函数变成一个可迭代对象（迭代器对象）
# 2. 丢一个10进去，然后通过for循环的迭代next会丢出0，1，2，3，4，5，6，7，8，9


# 有空搞这个,没空跳过
# def range(*args, step=1):
#     args = list(args)
#     if len(args) == 1:
#         count = 0
#         while count < args[0]:
#             yield count
#             count += step
#     elif len(args) == 2:
#         while args[0] < args[1]:
#             yield args[0]
#             args[0] += step

def range(x):
    count = 0
    while count < x:
        yield count
        count += 1


# g = range(10)
# print(g.__next__())
# print(g.__next__())
# print(g.__next__())
# print(g.__next__())
# print(g.__next__())
# print(g.__next__())
# print(g.__next__())
# print(g.__next__())

for i in range(10):
    print(i)

四、总结

yield:

  1. 提供一种自定义迭代器的方式
  2. yield可以暂停住函数，并提供当前的返回值

yield和return:

  1. 相同点：两者都是在函数内部使用，都可以返回值，并且返回值没有类型和个数的限制
  2. 不同点：return只能返回一次之；yield可以返回多次值

五、生成器表达式

  • 把列表推导式的[]换成()就是生成器表达式
  • 优点：省内存，一次只产生一个值在内存中
t = (i for i in range(10))
print(t)
print(f"next(t): {next(t)}")
<generator object <genexpr> at 0x1101c4888>
next(t): 0

5.1 生成器表达式和列表推导式

列表推导式相当于直接给你一筐蛋，而生成器表达式相当于给你一只老母鸡。

52生成器-土鸡.jpg?x-oss-process=style/watermark

# 生成器表达式
with open('52.txt', 'r', encoding='utf8') as f:
    nums = [len(line) for line in f]

print(max(nums))
1
# 列表推导式
with open('52.txt','r',encoding='utf8') as f:
    nums = (len(line) for line in f)

print(max(nums)) # ValueError: I/O operation on closed file.

匿名函数

一、有名函数

我们之前定的函数都是有名函数，它是基于函数名使用。

def func():
    print('from func')


func()
func()
func()
print(func)
from func
from func
from func
<function func at 0x10518b268>

二、匿名函数

匿名函数，他没有绑定名字，使用一次即被收回，加括号既可以运行。

lambda x, y: x+y
<function __main__.<lambda>(x, y)>
res = (lambda x, y: x+y)(1, 2)
print(res)
3

三、与内置函数联用

匿名函数通常与max()、sorted()、filter()、sorted()方法联用。

54匿名函数-薪资.jpg?x-oss-process=style/watermark

salary_dict = {
    'nick': 3000,
    'jason': 100000,
    'tank': 5000,
    'sean': 2000
}

1.如果我们想从上述字典中取出薪资最高的人，我们可以使用max()方法，但是max()默认比较的是字典的key。

  1. 首先将可迭代对象变成迭代器对象
  2. res=next(迭代器对象)，将res当做参数传给key指定的函数，然后将该函数的返回值当做判断依据
salary_dict = {
    'nick': 3000,
    'jason': 100000,
    'tank': 5000,
    'sean': 2000
}

print(f"max(salary_dict): {max(salary_dict)}")


def func(k):
    return salary_dict[k]


print(f"max(salary_dict, key=func()): {max(salary_dict, key=func)}")
# 'nick', v1 = func('nick')
# 'jason', v2 = func('jason')
# 'tank', v3 = func('tank')
# 'sean', v4 = func('sean')


print(
    f"max(salary_dict, key=lambda name: salary_dict[name]): {max(salary_dict, key=lambda name: salary_dict[name])}")
max(salary_dict): tank
max(salary_dict, key=func()): jason
max(salary_dict, key=lambda name: salary_dict[name]): jason

2.如果我们想对上述字典中的人，按照薪资从大到小排序，可以使用sorted()方法。

sorted()工作原理：

  1. 首先将可迭代对象变成迭代器对象
  2. res=next(迭代器对象)，将res当做参数传给第一个参数指定的函数，然后将该函数的返回值当做判断依据。
lis = [1, 3, 2, 5, 8, 6]
sorted(lis)
print(f"lis: {lis}")
print(f"sorted(lis,reverse=True): {sorted(lis,reverse=True)}")
lis: [1, 3, 2, 5, 8, 6]
sorted(lis,reverse=True): [8, 6, 5, 3, 2, 1]
salary_dict = {
    'nick': 3000,
    'jason': 100000,
    'tank': 5000,
    'sean': 2000
}

print(
    f"sorted(salary_dict, key=lambda name: salary_dict[name]): {sorted(salary_dict, key=lambda name: salary_dict[name])}")
sorted(salary_dict, key=lambda name: salary_dict[name]): ['sean', 'nick', 'tank', 'jason']

def sorted(iter, key=None, reverse=None):
    iter.sort()

    if key:
        # key 是一个函数对象
        lt = []
        lt2 = []
        for i in iter:
            res = key(i)
            lt.append(res)
            lt2.append(i)
        lt.sort()

        lt3 = []
        for i in lt:
            for j in lt2:
                if j[1] == i:
                    lt3.append(j)

        if reverse:
            lt3.reverse()
        return lt3

    if reverse:
        iter.reverse()
    return iter


print(sorted(salary_list, key=lambda i: i[1],
             reverse=None))  # [('sean', 2000), ('nick', 3000), ('tank', 5000), ('jason', 100000)]

3.如果我们想对一个列表中的某个人名做处理，可以使用map()方法。

map()工作原理：

  1. 首先将可迭代对象变成迭代器对象
  2. res=next(迭代器对象)，将res当做参数传给第一个参数指定的函数，然后将该函数的返回值作为map()方法的结果之一。

54匿名函数-傻逼.jpg?x-oss-process=style/watermark

name_list = ['jason', 'tank', 'sean']

res = map(lambda name: f"{name} sb", name_list)
print(f"list(res): {list(res)}")
list(res): ['jason sb', 'tank sb', 'sean sb']

4.如果我们想筛选除名字中含有'sb'的名字，我们可以使用filter()方法。

filter()工作原理：

  1. 首先将可迭代对象变成迭代器对象
  2. res=next(迭代器对象)，将res当做参数传给第一个参数指定的函数，然后filter会判断函数的返回值的真假，如果为真则留下。
name_list = ['nick', 'jason sb', 'tank sb', 'sean sb']

filter_res = filter(lambda name: name.endswith('sb'), name_list)
print(f"list(filter_res): {list(filter_res)}")
list(filter_res): ['jason sb', 'tank sb', 'sean sb']
posted @   Thousand_Mesh  阅读(114)  评论(0)  编辑  收藏  举报
编辑推荐：
· SQL Server 2025 AI相关能力初探
· Linux系列：如何用 C#调用 C方法造成内存泄露
· AI与.NET技术实操系列（二）：开始使用ML.NET
· 记一次.NET内存居高不下排查解决与启示
· 探究高空视频全景AR技术的实现原理
阅读排行：
· 阿里最新开源QwQ-32B，效果媲美deepseek-r1满血版，部署成本又又又降低了！
· AI编程工具终极对决：字节Trae VS Cursor，谁才是开发者新宠？
· 开源Multi-agent AI智能体框架aevatar.ai，欢迎大家贡献代码
· Manus重磅发布：全球首款通用AI代理技术深度解析与实战指南
· 被坑几百块钱后，我竟然真的恢复了删除的微信聊天记录！
点击右上角即可分享
微信分享提示
AI IDE Trae