下一个( cr )
输出：
协程已经启动！
ret_value = cr 。发送（“嗨” ）
打印（“'发送’返回：” ， ret_value ）
输出：
收到协程：嗨
“发送”返回：foo
我们必须先在生成器上调用 next，因为生成器需要启动。使用发送到尚未启动的生成器会导致异常。
要使用send 方法，生成器必须等待yield 语句，以便发送的数据可以被处理或分配给左边的变量。到目前为止我们还没有说：下一个调用也发送和接收。它总是发送一个 None 对象。“next”和“send”发送的值被分配给生成器内的一个变量：这个变量new_counter_val在下面的例子中被调用。
下面的示例通过添加一个send功能来修改上一章节中的生成器“计数” 。
发送的另一个例子
from random import choice
def song_generator ( song_list ):
new_song = None
while True :
if new_song != None :
if new_song not in song_list :
song_list 。追加（new_song ）
new_song = yield new_song
else ：
new_song = yield （选择（song_list ））
songs = [“她的 Şeyi Yak - Sezen Aksu” 、
“Bluesette - Toots Thielemans” 、
“六个马林巴琴 - Steve Reich” 、
“Riverside - Agnes Obel” 、
“Not for Radio - Nas” 、
“What’s going on - Taste” 、
“On Stream” - Nils Petter Molvær” 、
“La’ Inta Habibi - Fayrouz ” 、
“Ik Leef Niet Meer Voor Jou - Marco Borsato” 、
“Δέκα λεπτά - Αθηνά Ανδρεάδη” ]
radio_program = song_generator （歌曲）
下一个( radio_program )
输出：
‘河畔 - 艾格尼丝奥贝尔’
对于 我 在 范围（3 ）：
打印（下一个（radio_program ））
输出：
Bluesette - Toots Thielemans
六个马林巴斯 - 史蒂夫赖希
六个马林巴斯 - 史蒂夫赖希
广播节目。发送（“扭曲的天使 - 存档” ）
输出：
‘扭曲的天使 - 档案’
歌曲
输出：
[‘她的Şeyi Yak - Sezen Aksu’，
‘Bluesette - Toots Thielemans’，
‘六个马林巴斯 - 史蒂夫赖希’，
‘河畔 - 艾格尼丝奥贝尔’，
‘不适合广播 - Nas’，
“这是怎么回事 - 味道”，
‘On Stream - Nils Petter Molvær’，
“La’ Inta Habibi - Fayrouz”,
‘Ik Leef Niet Meer Voor Jou - Marco Borsato’，
‘Δέκα λεπτά - Αθηνά Ανδρεάδη’,
‘扭曲的天使 - 档案’]
到目前为止，我们可以通过发送一首新歌曲来改变歌曲交互器的行为，即标题加上表演者。我们现在将扩展生成器。我们可以发送新的歌曲列表。我们必须向新迭代器发送一个元组，或者是一个元组：
(, ） 或者
(“-歌曲列表-”, )
从 随机 导入 选择
def song_generator ( song_list ):
new_song = None
while True :
if new_song != None :
if new_song [ 0 ] == “-songlist-” :
song_list = new_song [ 1 ]
new_song = yield ( choice ( song_list ))
否则：
标题， 表演者 = new_song
new_song = 标题 + “ - ” + 表演
，如果 new_song 没有 在 song_list ：
song_list 。追加（new_song ）
new_song = yield new_song
else ：
new_song = yield （选择（song_list ））
歌曲 1 = [ “Après un Rêve - Gabriel Fauré”
“On Stream - Nils Petter Molvær” 、
“Der Wanderer Michael - Michael Wollny” 、
“Les barricades mystérieuses - Barbara Thompson” 、
“Monday - Ludovico Einaudi” ]
歌曲 2 = [ “Dünyad” Uszak - Pinhani” 、
“Again - Archive” 、
“If I
have a Hear - Fever Ray”、“每个你，每个我 - 安慰剂” 、
“熟悉的 - Angnes Obel” ]
radio_prog = song_generator ( song1 )
对于 我 在 范围（5 ）：
打印（下一个（radio_prog ））
输出：
Les barricades mystérieuses - 芭芭拉·汤普森
Après un Rêve - Gabriel FauréOn Stream - Nils Petter Molvær
Les barricades mystérieuses - 芭芭拉·汤普森
Les barricades mystérieuses - 芭芭拉·汤普森
Après un Rêve - Gabriel FauréOn Stream - Nils Petter Molvær
我们现在通过交换歌曲列表来改变广播节目：
radio_prog 。发送（（“-songlist-” ， song2 ））
输出：
《熟悉——安涅斯·奥贝尔》
对于 我 在 范围（5 ）：
打印（下一个（radio_prog ））
输出：
再次 - 存档
如果我听到了 - 发烧射线每一个你，每一个我 - 安慰剂
Dünyadan Uszak - Pinhani
Dünyadan Uszak - Pinhani
如果我听到了 - 发烧射线每一个你，每一个我 - 安慰剂
抛出方法
throw() 方法在生成器暂停时引发异常，并返回生成器生成的下一个值。如果生成器退出而没有产生另一个值，它会引发 StopIteration。生成器必须捕获传入的异常，否则异常将传播给调用者。
count之前示例中生成器的无限循环不断产生顺序数据的元素，但我们没有关于“计数器”变量的索引或状态的任何信息。我们可以count通过在throw方法中抛出异常来获取这些信息，即变量的状态。我们在生成器内部捕获此异常并打印“count”值的状态：
def count ( firstval = 0 , step = 1 ):
counter = firstval
while True :
try :
new_counter_val = yield counter
if new_counter_val is None :
counter += step
else :
counter = new_counter_val
except Exception :
yield ( firstval , step , counter )
在下面的代码块中，我们将展示如何使用这个生成器：
c = count ()
for i in range ( 6 ):
print ( next ( c ))
print ( “让我们看看迭代器的状态是什么：” )
state_of_count = c 。throw ( Exception )
print ( state_of_count )
print ( “now, we can continue:” )
for i in range ( 3 ):
print ( next ( c ))
输出：
0
1
2
3
4
5
让我们看看迭代器的状态是什么：
(0, 1, 5)
现在，我们可以继续：
5
6
7
我们可以通过定义我们自己的异常类 StateOfGenerator 来改进前面的例子：
class StateOfGenerator ( Exception ):
def __init__ ( self , message = None ):
self 。message = message
def count ( firstval = 0 , step = 1 ):
counter = firstval
while True :
try :
new_counter_val = yield counter
if new_counter_val is None :
counter += step
else :
counter = new_counter_val
除了 StateOfGenerator :
yield ( firstval , step , counter )
我们可以像这样使用之前的生成器：
c = count ()
for i in range ( 3 ):
print ( next ( c ))
print ( “让我们看看迭代器的状态是什么：” )
i = c 。throw ( StateOfGenerator )
print ( i )
print ( “now, we can continue:” )
for i in range ( 3 ):
print ( next ( c ))
输出：
0
1
2
让我们看看迭代器的状态是什么：
(0, 1, 2)
现在，我们可以继续：
2
3
4
产量来自
“yield from”自 Python 3.3 起可用！该yield from <expr>语句可以在生成器的主体内使用。<expr>必须是一个评估为可迭代的表达式，从中提取迭代器。迭代器运行到耗尽，即直到遇到StopIteration异常。该迭代器向生成器的调用者（即包含 yield from 语句的调用者）生成和接收值。
我们可以通过查看两台发电机从下面的例子中学习“GEN1”和“第二代”的是，yield from从gen2 被替换为“GEN1”的循环：
def gen1 ():
for char in “Python” :
yield char
for i in range ( 5 ):
yield i
def gen2 ():
yield from “Python”
yield from range ( 5 )
g1 = gen1 ()
g2 = gen2 ()
打印（“G1” ， 结束= “” ）
为 X 在 G1 ：
打印（X, end = ", " )
打印( " \n g2: " , end = ", " )
for x in g2 :
print ( x , end = ", " )
print ()
输出：
g1: , P, y, t, h, o, n, 0, 1, 2, 3, 4,
g2: , P, y, t, h, o, n, 0, 1, 2, 3, 4,
我们可以从输出中看到两个生成器是相同的。
yield from 语句的好处可以看作是将生成器拆分为多个生成器的一种方式。这就是我们在前面的示例中所做的，我们将在以下示例中更明确地演示这一点：
DEF 城市（）：
对于 城市 中 [ “柏林” ， “汉堡” ， “慕尼黑” ， “弗赖堡” ]：
收率 城市
DEF 平方（）：
对于 数 在 范围（10 ）：
产量 数 ** 2
DEF generator_all_in_one （） :
对于 城市 中的 城市():
以方块为单位的数量的产生 城市
():产生数量def
generator_splitted （）：
产率从 城市（）
从产率 平方（）
LST1 = [ EL 为 EL 在 generator_all_in_one （）]
LST2 = [ EL 为 EL 在 generator_splitted （）]
打印（LST1 == LST2 ）
输出：
真的
前面的代码返回 True 因为生成器generator_all_in_one和generator_splitted yield元素相同。这意味着如果<expr> fromyield from是另一个生成器，则效果与子生成器的主体在yield from语句点内联一样。此外，子生成器可以执行return带有值的语句，该值成为yield from表达式的值。我们用以下小脚本演示这一点：
def subgenerator ():
yield 1
return 42
def delegating_generator ():
x = yield from subgenerator ()
print ( x )
for x in delegating_generator ():
print ( x )
输出：
1
42
“PEP 380 – 委派给子生成器的语法”中的六点根据生成器协议描述了 yield from 表达式的完整语义：
-
迭代器产生的任何值都直接传递给调用者。
-
使用 send() 发送到委托生成器的任何值都会直接传递给迭代器。如果发送的值为 None，则调用迭代器的next () 方法。如果发送的值不是 None，则调用迭代器的 send() 方法。如果调用引发 StopIteration，则恢复委托生成器。任何其他异常都会传播到委托生成器。
-
除了 GeneratorExit 被抛出到委托生成器中的异常被传递给迭代器的 throw() 方法。如果调用引发 StopIteration，则恢复委托生成器。任何其他异常都会传播到委托生成器。
-
如果在委托生成器中抛出 GeneratorExit 异常，或者委托生成器的 close() 方法被调用，则迭代器的 close() 方法如果有则调用。如果此调用导致异常，则将其传播到委托生成器。否则，在委托生成器中引发 GeneratorExit。
-
yield from 表达式的值是迭代器终止时引发的 StopIteration 异常的第一个参数。
-
在生成器中返回 expr 会导致在退出生成器时引发 StopIteration(expr)。
递归生成器
以下示例是一个生成器，用于创建给定项目列表的所有排列。
对于那些不知道什么是排列的人，我们有一个简短的介绍：
正式定义：术语“排列”源自拉丁语动词“permutare”，意思是排列是有序列表元素的重新排列。换句话说：n 个元素的每一种排列都称为排列。
在以下几行中，我们向您展示了字母 a、b 和 c 的所有排列：
abc
ab
bac
bca
cab
cba
一组 n 个元素的排列数由 n!
啊！= n (n-1) (n-2) … 2 * 1
啊！称为 n 的阶乘。
可以使用任意对象列表调用置换生成器。此生成器返回的迭代器生成所有可能的排列：
def permutations ( items ):
n = len ( items )
if n == 0 : yield []
else :
for i in range ( len ( items )):
for cc in permutations ( items [: i ] + items [ i + 1 ) :]):
产量 [ items [ i ]] + cc
for p 在 置换（[ ‘R’ ，‘E’ ，‘d’ ）： 打印（‘’ 。加入（p ））
为 p 在 排列（列表（“游戏” ））： 打印（‘’ 。加入（p ） + ", " , end = “” )
输出：
红色的
数据
erd
编辑
dre
德
游戏，gaem，gmae，gmea，geam，gema，agme，agem，amge，ameg，aegm，aemg，mgae，mgea，mage，maeg，mega，meag，egam，egma，eagm，eamg，emga，emag，
前面的例子对于新手来说可能很难理解。一如既往，Python 提供了一个方便的解决方案。为此，我们需要模块itertools。Itertools 是一个非常方便的工具来创建和操作迭代器。
使用 itertools 创建排列：
导入 itertools
perms = itertools 。排列([ ‘r’ , ‘e’ , ‘d’ ])
列表( perms )
输出：
[（‘红色的’），
(‘r’, ‘d’, ‘e’),
(‘e’, ‘r’, ‘d’),
(‘e’, ‘d’, ‘r’),
(‘d’, ‘r’, ‘e’),
(‘d’, ‘e’, ‘r’)]
术语“排列”有时可以以较弱的含义使用。置换可以在这个较弱的含义中表示元素序列，其中每个元素只出现一次，但不需要包含给定集合的所有元素。所以从这个意义上说 (1,3,5,2) 是一组数字 {1,2,3,4,5,6} 的排列。例如，我们可以构建固定长度 k 的元素的所有序列，这些序列取自给定的大小为 n 的集合，其中 k ≤ n。
这些是集合 {“a”,“b”,“c”,“d”} 的所有 3 排列。
这些非典型排列也称为无重复序列。通过使用这个术语，我们可以避免与术语“排列”混淆。n 的这种 k 排列的数量表示为磷n,克 其值由乘积计算：
n·(n-1)·…(n-克+1)
通过使用阶乘符号，上述表达式可以写为：
磷n,克=n！/(n-克)！
用于创建 n 个对象的 k 排列的生成器看起来与我们之前的排列生成器非常相似：
def k_permutations ( items , n ):
if n == 0 :
yield []
else :
for item in items :
for kp in k_permutations ( items , n - 1 ):
if item not in kp :
yield [ item ] + kp
for kp 在 k_permutations ( “abcd” , 3 ) 中：
打印( kp )
输出：
[‘a’, ‘b’, ‘c’]
[‘a’, ‘b’, ‘d’]
[‘a’, ‘c’, ‘b’]
[‘a’, ‘c’, ‘d’]
[‘a’, ‘d’, ‘b’]
[‘a’, ‘d’, ‘c’]
[‘b’, ‘a’, ‘c’]
[‘坏的’]
[‘b’, ‘c’, ‘a’]
[‘b’, ‘c’, ‘d’]
[‘b’, ‘d’, ‘a’]
[‘b’, ‘d’, ‘c’]
[‘出租车’]
[‘c’, ‘a’, ‘d’]
[‘c’, ‘b’, ‘a’]
[‘c’, ‘b’, ‘d’]
[‘c’, ‘d’, ‘a’]
[‘c’, ‘d’, ‘b’]
[‘d’, ‘a’, ‘b’]
[‘d’, ‘a’, ‘c’]
[‘d’, ‘b’, ‘a’]
[‘d’, ‘b’, ‘c’]
[‘d’, ‘c’, ‘a’]
[‘d’, ‘c’, ‘b’]
发电机的发电机
我们斐波那契数列示例的第二个生成器生成一个迭代器，理论上可以生成所有的斐波那契数，即无限数。但是您不应该尝试使用以下行在列表中生成所有这些数字。
列表（斐波那契（））
这将非常快速地向您显示计算机的极限。在大多数实际应用中，我们只需要n和其他“无限”迭代器的第一个元素。在我们的示例中firstn，我们可以使用另一个生成器来创建n生成器的第一个元素generator：
def firstn ( generator , n ):
g = generator ()
for i in range ( n ):
yield next ( g )
以下脚本返回斐波那契数列的前 10 个元素：
def fibonacci ():
“”" A Fibonacci number generator “”"
a , b = 0 , 1
while True :
yield a
a , b = b , a + b
print ( list ( firstn ( fibonacci , 10 )))
输出：
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
练习
–
练习 1
编写一个计算运行平均值的生成器。
练习 2
编写一个 generator frange，它的行为类似于range但接受float值。
练习 3
3）编写一个生成器 trange，它生成一个从开始到停止逐步递增的时间元组序列。时间元组是一个由整数组成的 3 元组：（小时、分钟、秒）所以对 的调用trange可能如下所示：
trange((10, 10, 10), (13, 50, 15), (0, 15, 12) )
练习 4
写一个之前生成器的版本“rtrange”，它可以接收消息来重置起始值。
练习 5
编写一个程序，使用新编写的生成器“trange”，创建一个文件“times_and_temperatures.txt”。此文件的行包含格式中的时间hh::mm::ss和 10.0 到 25.0 度之间的随机温度。时间应该从 6:00:00 开始以 90 秒的步长递增。例如：
06:00:00 20.1 06:01:30 16.1 06:03:00 16.9 06:04:30 13.4 06:06:00 23.7 06:07:30 23.6 06:09:00 17.5 06:10:30 11.0
练习 6
编写一个名为“random_ones_and_zeroes”的生成器，它在每次迭代中返回一个比特流，即零或一。返回 1 的概率 p 在变量 p 中定义。生成器会将此值初始化为 0.5。换句话说，零和一将以相同的概率返回。
练习 7
我们Cycle在 Python 教程的本章开头编写了一个类。编写一个cycle执行相同任务的生成器。
我们练习的解决方案
练习 1 的解决方案
def running_average ():
total = 0.0
counter = 0
average = None
while True :
term = yield average
total += term
counter += 1
average = total / counter
ra = running_average () # 初始化协程
next ( ra ) # 我们有启动协程
为 值 在 [ 7 ， 13 17， , 231 , 12 , 8 , 3 ]:
out_str = "sent: {val:3d} , new average: {avg:6.2f} "
print ( out_str . format ( val = value , avg = ra . send ( value )) )
输出：
发送：7，新平均值：7.00
发送：13，新平均值：10.00
发送：17，新平均：12.33
发送：231，新平均值：67.00
发送：12，新平均：56.00
发送：8，新平均：48.00
发送：3，新平均：41.57
练习 2 的解决方案
DEF FRANGE （* ARGS ）：
“” “dfgdg ”“”
startval = 0
步长 = 1
如果 len个（ARGS ） == 1 ：
endval = ARGS [ 0 ]
的elif LEN （ARGS ） == 2 ：
startval ， endval = ARGS
的elif LEN （ARGS ） == 3 ：
startval ， endval ， 步长 = ARGS
否则：
TXT = “范围预期至多3个参数，得到了” + LEN （ARGS ）
加注 类型错误（TXT ）
值 = startval
因子 = - 1 如果 步长 < 0 别的 1
而 （值 - endval ） * （因子） < 0 ：
屈服 值
值 + = 步长
使用frange可能像这样：
for i in frange ( 5.6 ):
print ( i , end = ", " )
print ()
for i in frange ( 0.3 , 5.6 ):
print ( i , end = ", " )
print ()
for i in frange ( 0.3 , 5.6 , 0.8 ):
打印( i , end = ", " )
打印()
输出：
0, 1, 2, 3, 4, 5,
0.3, 1.3, 2.3, 3.3, 4.3, 5.3,
0.3, 1.1, 1.9000000000000001, 2.7, 3.5, 4.3, 5.1,
练习 3 的解答
def trange ( start , stop , step ):
“”"
trange(stop) -> 时间作为三元组（小时、分钟、秒）
trange(start, stop[, step]) -> time tuple
start: time tuple (hours, minute, seconds)
stop: time tuple
step: time tuple
返回从 start 到 stop 递增的时间元组序列
“”"
current = list ( start )
while current < list ( stop ):
yield tuple ( current )
秒 = 步骤[ 2 ] + 当前[ 2 ]
min_borrow = 0
hours_borrow = 0
if seconds < 60 :
current [ 2 ] = seconds
else :
current [ 2 ] = seconds - 60
min_borrow = 1
minutes = step [ 1 ] + current [ 1 ] + min_borrow
如果 分钟 < 60 :
当前[ 1 ] = 分钟
else :
当前[ 1 ] = 分钟 - 60
hours_borrow = 1
hours = step [ 0 ] + current [ 0 ] + hours_borrow
如果 hours < 24 :
current [ 0 ] = hours
else :
current [ 0 ] = 小时 - 24
输出：
覆盖时间范围.py
from timerange import trange
for time in trange (( 10 , 10 , 10 ), ( 19 , 53 , 15 ), ( 1 , 24 , 12 ) ):
print ( time )
输出：
(10, 10, 10)
(11, 34, 22)
(12, 58, 34)
(14, 22, 46)
(15, 46, 58)
(17, 11, 10)
(18, 35, 22)
练习 4 的解答
def rtrange ( start , stop , step ):
“”"
trange(stop) -> 时间作为三元组（小时、分钟、秒）
trange(start, stop[, step]) -> 时间元组
开始：时间元组(hours, minute, seconds)
stop: time tuple
step: time tuple
返回一个
时间元组__的序列，从 start 到 stop 逐步递增 可以通过发送一个新的“start”值来重置生成器。
“”"
current = list ( start )
而 当前 < 列表(停止)：
new_start = yield tuple ( current )
if new_start != None :
current = list ( new_start )
continue
seconds = step [ 2 ] + current [ 2 ]
min_borrow = 0
hours_borrow = 0
if seconds < 60 :
current [ 2 ] = seconds
else :
当前[ ] 2 = 秒 - 60
min_borrow = 1
分钟 = 步[ 1 ] + 当前[ 1 ] + min_borrow
如果 分钟 < 60 ：
当前[ 1 ] = 分钟
否则：
当前[ 1 ] = 分钟 - 60
hours_borrow = 1
小时 = 步[ 0 ] + 当前[0 ] + hours_borrow
如果 hours < 24 :
current [ 0 ] = hours
else :
current [ 0 ] = hours - 24
输出：
覆盖 rtimerange.py
from rtimerange import rtrange
ts = rtrange (( 10 , 10 , 10 ), ( 17 , 50 , 15 ), ( 1 , 15 , 12 ) )
for _ in range ( 3 ):
print ( next ( ts ))
print ( ts .发送(( 8 , 5 , 50 )))
for _ 在 范围( 3 ):
打印( next ( ts ))
输出：
(10, 10, 10)
(11, 25, 22)
(12, 40, 34)
(8, 5, 50)
(9, 21, 2)
(10, 36, 14)
(11, 51, 26)
练习 5 的解答
from timerange import trange
import random
fh = open ( “times_and_temperatures.txt” , “w” )
for time in trange (( 6 , 0 , 0 ), ( 23 , 0 , 0 ), ( 0 , 1 , 30 ) ):
random_number = 随机。randint ( 100 , 250 ) / 10
lst = 时间 + ( random_number ,)
输出 = " {:02d} : {:02d} : {:02d} {:4.1f} \n " 。格式( * lst )
fh 。写（输出）
您可以在我们关于加权概率的章节中找到有关此练习的更多详细信息和数学背景
练习 6 的解答
导入 随机
def random_ones_and_zeros ():
p = 0.5
而 True :
x = random 。随机（）
消息 = 收率 1 如果 X < p 别的 0
如果 消息 =！ 无：
p = 消息
X = random_ones_and_zeros （）
下一个（X ） ＃我们没有在返回值中感兴趣
为 p 在 [ 0.2 ， 0.8 ]:
print ( " \n我们将概率改为：" + str ( p ))
x 。send ( p )
for i in range ( 20 ):
print ( next ( x ), end = " " )
print ()
输出：
我们将概率更改为：0.2
1 0 0 0 1 0 0 1 1 0 1 0 1 0 0 0 1 1 0 0
我们将概率更改为：0.8
0 1 1 0 1 0 1 1 0 0 1 1 1 1 1 0 1 1 1 1
练习 7 的解答
“循环”生成器是“itertools”模块的一部分。以下代码是在itertools中的实现：
def cycle ( iterable ):
# cycle(‘ABCD’) --> ABCDABCDABCD …
saved = []
for element in iterable :
yield element
saved . 追加（元件）
，同时 保存：
用于 元件 中 保存的：
收率 元件
国家 = [ “德国” ， “瑞士” ， “奥” ]
country_iterator = 周期（国家）
对于 i in range ( 7 ):
打印( next ( country_iterator ))
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新
如果你觉得这些内容对你有帮助，可以扫码获取！！！（备注：Python）
s_and_zeros ():
p = 0.5
而 True :
x = random 。随机（）
消息 = 收率 1 如果 X < p 别的 0
如果 消息 =！ 无：
p = 消息
X = random_ones_and_zeros （）
下一个（X ） ＃我们没有在返回值中感兴趣
为 p 在 [ 0.2 ， 0.8 ]:
print ( " \n我们将概率改为：" + str ( p ))
x 。send ( p )
for i in range ( 20 ):
print ( next ( x ), end = " " )
print ()
输出：
我们将概率更改为：0.2
1 0 0 0 1 0 0 1 1 0 1 0 1 0 0 0 1 1 0 0
我们将概率更改为：0.8
0 1 1 0 1 0 1 1 0 0 1 1 1 1 1 0 1 1 1 1
练习 7 的解答
“循环”生成器是“itertools”模块的一部分。以下代码是在itertools中的实现：
def cycle ( iterable ):
# cycle(‘ABCD’) --> ABCDABCDABCD …
saved = []
for element in iterable :
yield element
saved . 追加（元件）
，同时 保存：
用于 元件 中 保存的：
收率 元件
国家 = [ “德国” ， “瑞士” ， “奥” ]
country_iterator = 周期（国家）
对于 i in range ( 7 ):
打印( next ( country_iterator ))
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-bLfU2hIM-1713801026099)]
[外链图片转存中…(img-usLgX1p7-1713801026100)]
[外链图片转存中…(img-aUHgoHFQ-1713801026101)]
[外链图片转存中…(img-xrYrRvHg-1713801026101)]
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新
如果你觉得这些内容对你有帮助，可以扫码获取！！！（备注：Python）
1618
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
