در این مطلب، ویدئو مولدهای پایتون و استفاده از کلمه کلیدی Yield با زیرنویس فارسی را برای دانلود قرار داده ام. شما میتوانید با پرداخت 15 هزار تومان ، این ویدیو به علاوه تمامی فیلم های سایت را دانلود کنید.اکثر فیلم های سایت به زبان انگلیسی می باشند. این ویدئو دارای زیرنویس فارسی ترجمه شده توسط هوش مصنوعی می باشد که میتوانید نمونه ای از آن را در قسمت پایانی این مطلب مشاهده کنید.
مدت زمان فیلم: 00:11:55
تصاویر این ویدئو:
قسمتی از زیرنویس این فیلم:
00:00:00,000 –> 00:00:02,550
سلام من جو جیمز هستم در این ویدیو
2
00:00:02,550 –> 00:00:04,950
یاد می گیریم که از کلمه کلیدی yield برای
3
00:00:04,950 –> 00:00:07,470
ساختن ژنراتورهای خودمان در پایتون استفاده
4
00:00:07,470 –> 00:00:08,760
کنیم. کد این
5
00:00:08,760 –> 00:00:10,980
نوت بوک مشتری را در سایت github خود به اشتراک می گذارم و
6
00:00:10,980 –> 00:00:12,900
لینک زیر را در زیر پست می کنم.
7
00:00:12,900 –> 00:00:15,839
نظرات و اینجا در بالای صفحه من همچنین
8
00:00:15,839 –> 00:00:17,970
پیوندهایی را به اسناد رسمی
9
00:00:17,970 –> 00:00:20,160
در وب سایت پایتون
10
00:00:20,160 –> 00:00:22,890
و همچنین یک آموزش بسیار خوب دیگر
11
00:00:22,890 –> 00:00:25,109
که پیدا کردم در اینجا برای شما مفید باشد،
12
00:00:25,109 –> 00:00:27,930
ارسال کردم، بنابراین من پیوندی به این مطلب ارسال می کنم که یک
13
00:00:27,930 –> 00:00:30,150
مولد پایتون چه کاربردی دارد. عملکرد به عنوان
14
00:00:30,150 –> 00:00:32,640
تابع استاندارد در پایتون که
15
00:00:32,640 –> 00:00:36,239
شامل کلمه کلیدی yield است، بنابراین شما
16
00:00:36,239 –> 00:00:38,280
می خواهید یاد بگیرید که کلمه کلیدی yield
17
00:00:38,280 –> 00:00:40,079
18
00:00:40,079 –> 00:00:41,610
19
00:00:41,610 –> 00:00:44,670
چه کاری انجام می دهد.
20
00:00:44,670 –> 00:00:48,989
21
00:00:48,989 –> 00:00:50,789
تابع در اینجا به این شکل خواهد بود،
22
00:00:50,789 –> 00:00:53,460
فقط تعریف میکند که ژنراتور من آن را صدا میزند
23
00:00:53,460 –> 00:00:57,210
ما X را برابر با 1 قرار میدهیم در حالی که درست است،
24
00:00:57,210 –> 00:00:58,890
به عبارت دیگر این حلقه به
25
00:00:58,890 –> 00:01:03,059
طور نامحدود ادامه میدهد و X را به دست میآورد و سپس
26
00:01:03,059 –> 00:01:05,250
این بازده درست مانند حالت بازگشت
27
00:01:05,250 –> 00:01:06,869
عمل میکند. اما کاری که
28
00:01:06,869 –> 00:01:09,210
عبارت return انجام میدهد این است که دستور return
29
00:01:09,210 –> 00:01:13,140
پشته فراخوانی را برای این
30
00:01:13,140 –> 00:01:15,570
تابع میبندد، بنابراین تمام وضعیت این تابع در پایتون ذخیره نمیشود،
31
00:01:15,570 –> 00:01:18,360
32
00:01:18,360 –> 00:01:21,090
اما با کلمه کلیدی yield cute در اینجا
33
00:01:21,090 –> 00:01:23,549
میگوییم hey Python I need. شما برای
34
00:01:23,549 –> 00:01:25,799
باز نگه داشتن این تابع من از شما می
35
00:01:25,799 –> 00:01:28,229
خواهم این حالت را حفظ کنید می خواهم
36
00:01:28,229 –> 00:01:30,570
وضعیت این تابع و همه
37
00:01:30,570 –> 00:01:32,460
مقادیر متغیر و همه چیز را در این
38
00:01:32,460 –> 00:01:35,250
تابع ذخیره کنید تا بتوانم
39
00:01:35,250 –> 00:01:37,380
در نقطه ای از زمان به آن برگردم و بنابراین وقتی ضربه زدیم
40
00:01:37,380 –> 00:01:39,689
این کلمه کلیدی yield در اینجا X را به دست می دهد،
41
00:01:39,689 –> 00:01:42,420
ما برای اولین بار مقدار x را که در
42
00:01:42,420 –> 00:01:43,920
حال حاضر 1 است از طریق
43
00:01:43,920 –> 00:01:46,860
حلقه برمی گردانیم و سپس وقتی به این تابع برمی گردیم،
44
00:01:46,860 –> 00:01:48,509
درست
45
00:01:48,509 –> 00:01:51,299
بعد از این خط بازده ظاهر می شویم. دوباره به
46
00:01:51,299 –> 00:01:53,759
X افزایش میدهیم و سپس دوباره به
47
00:01:53,759 –> 00:01:55,860
پشت بالای حلقه
48
00:01:55,860 –> 00:01:58,619
while میرویم در حالی که درست است، دوباره X را افزایش میدهیم، بنابراین
49
00:01:58,619 –> 00:02:00,869
X را افزایش میدهیم و سپس X افزایش X
50
00:02:00,869 –> 00:02:02,490
و سپس X را هر بار از طریق این
51
00:02:02,490 –> 00:02:05,899
حلقه میدهیم، بنابراین هر بار شما این تابع را صدا می زنید
52
00:02:05,899 –> 00:02:10,288
X از صفحه ذخیره می شود زمان گذشته،
53
00:02:10,288 –> 00:02:12,030
بنابراین اساساً نحوه کار ژنراتور
54
00:02:12,030 –> 00:02:13,680
دقیقاً مانند یک
55
00:02:13,680 –> 00:02:15,659
تابع است، با این تفاوت که هرگز بسته نمیشود،
56
00:02:15,659 –> 00:02:18,299
باز میماند و از کلمه کلیدی yield استفاده میشود تا
57
00:02:18,299 –> 00:02:20,250
به پایتون بگوید این تابع را باز نگه دارد
58
00:02:20,250 –> 00:02:21,900
و حالت و همه مقادیر متغیر
59
00:02:21,900 –> 00:02:26,010
را ذخیره کند، به طوری که یک بازده ساده است.
60
00:02:26,010 –> 00:02:27,390
تابعی که فقط
61
00:02:27,390 –> 00:02:28,170
62
00:02:28,170 –> 00:02:31,109
یک مقدار افزایشی از X را با شمارش بالا
63
00:02:31,109 –> 00:02:33,989
از خط تولید می کند، اکنون چندین
64
00:02:33,989 –> 00:02:35,639
راه مختلف برای استفاده از این ژنراتورها وجود دارد،
65
00:02:35,639 –> 00:02:38,790
بنابراین بیایید ببینیم چگونه می توانیم انجام دهیم که
66
00:02:38,790 –> 00:02:41,750
می توانیم از ژنراتور با یک حلقه for استفاده کنیم، بنابراین
67
00:02:41,750 –> 00:02:46,709
در اینجا یک حلقه for وجود دارد. برای من در چاپ ژنی من،
68
00:02:46,709 –> 00:02:48,720
بنابراین تمام کاری که میخواهیم انجام دهیم این است که فقط
69
00:02:48,720 –> 00:02:52,139
مقدار I را چاپ کنیم و سپس
70
00:02:52,139 –> 00:02:54,659
نیم ثانیه بخوابم و سپس چشم دیگری را چاپ کنم
71
00:02:54,659 –> 00:02:57,329
همانطور که در این حلقه برای تکرار میشویم،
72
00:02:57,329 –> 00:02:58,590
خواهید دید که ما خواهید دید ‘فقط میخواهم یک
73
00:02:58,590 –> 00:03:01,079
دسته از مقادیر I را چاپ کنم، بنابراین هر مقداری که
74
00:03:01,079 –> 00:03:03,599
از ژنراتور خود در اینجا دریافت میکنیم،
75
00:03:03,599 –> 00:03:06,120
یک ژن شی مولد ایجاد کردم که برابر با
76
00:03:06,120 –> 00:03:07,650
ژنراتور من است که
77
00:03:07,650 –> 00:03:11,069
نام تابع ما در اینجا است،
78
00:03:11,069 –> 00:03:13,169
اگر میخواهیم ژن ژنراتور من برابر با ژنراتور من است. برای
79
00:03:13,169 –> 00:03:15,090
انتخاب کردن با مقداری غیر از یک شروع کنید
80
00:03:15,090 –> 00:03:17,459
که من میتوانستم در آرگومان 5 یا
81
00:03:17,459 –> 00:03:19,290
100 یا هر چیز دیگری ارسال کنم، اما ما فقط
82
00:03:19,290 –> 00:03:21,120
با 1 شروع میکنیم که پیشفرض است و
83
00:03:21,120 –> 00:03:24,840
سپس این نوع ژن را چاپ میکند، به
84
00:03:24,840 –> 00:03:27,629
نظر شما چه نوع دادهای ژن خوب است.
85
00:03:27,629 –> 00:03:30,389
ژنراتور شی
86
00:03:30,389 –> 00:03:32,099
کلاس مولد شی کلاس شما می توانید ببینید
87
00:03:32,099 –> 00:03:34,919
که چه ژنی است بنابراین ما اساسا فقط
88
00:03:34,919 –> 00:03:39,209
ژن را به عنوان مولد من می نامیم درست ژن را
89
00:03:39,209 –> 00:03:41,040
برابر با ژنراتور من قرار می دهیم که
90
00:03:41,040 –> 00:03:43,290
نام این تابع است و اکنون یک
91
00:03:43,290 –> 00:03:46,439
شی مولد داریم که می توانیم می توانید
92
00:03:46,439 –> 00:03:50,400
با استفاده از یک حلقه for مورد بعدی را دریافت کنید، بنابراین
93
00:03:50,400 –> 00:03:55,379
اجازه دهید ابتدا این را اجرا کنیم و سپس
94
00:03:55,379 –> 00:03:59,609
این بوم را اجرا کنیم تا به ما بگوید که یک
95
00:03:59,609 –> 00:04:01,829
شی مولد است و اکنون در
96
00:04:01,829 –> 00:04:03,389
حلقه for تکرار می شود و
97
00:04:03,389 –> 00:04:05,699
هر نیمه نیم ثانیه می خوابد. یک ثانیه
98
00:04:05,699 –> 00:04:08,250
به فراخوانی تابع میرود
99
00:04:08,250 –> 00:04:11,849
و عدد صحیح بعدی را میگیرد و آن را برمیگرداند و آن را چاپ میکند
100
00:04:11,849 –> 00:04:13,889
و این کار به
101
00:04:13,889 –> 00:04:15,750
طور نامحدود ادامه مییابد، اساساً هیچ محدودیتی برای آن وجود ندارد،
102
00:04:15,750 –> 00:04:19,099
بنابراین من آن را به صورت دستی متوقف
103
00:04:19,099 –> 00:04:21,899
میکنم در غیر این صورت ادامه میدهم و ادامه میدهم
104
00:04:21,899 –> 00:04:23,550
، adva با استفاده از این چاه،
105
00:04:23,550 –> 00:04:27,030
حافظه کمتری مصرف میکند، زیرا میتوانیم
106
00:04:27,030 –> 00:04:29,610
دنبالهای از اعداد صحیح را فقط با استفاده از یک
107
00:04:29,610 –> 00:04:32,310
لیست به دست آوریم، نمیتوانیم از یک لیست برای به
108
00:04:32,310 –> 00:04:35,490
دست آوردن دنبالهای از اعداد صحیح استفاده کنیم، اما
109
00:04:35,490 –> 00:04:38,250
اگر نمیخواهید همه این اعداد را در حافظه ذخیره کنید،
110
00:04:38,250 –> 00:04:39,900
بنویسید. اگر
111
00:04:39,900 –> 00:04:42,570
لیست بسیار بزرگی از
112
00:04:42,570 –> 00:04:44,070
اعداد صحیح را میخواهید و نمیخواهید
113
00:04:44,070 –> 00:04:46,290
آنها را در حافظه ذخیره کنید، باید در حافظه ذخیره شود.
114
00:04:46,290 –> 00:04:48,150
115
00:04:48,150 –> 00:04:51,690
116
00:04:51,690 –> 00:04:54,000
پشته را فراخوانی کنید که باید
117
00:04:54,000 –> 00:04:55,830
در حافظه ذخیره شود و من در یک ثانیه به شما نشان خواهم داد
118
00:04:55,830 –> 00:04:57,330
که چقدر فضای
119
00:04:57,330 –> 00:04:59,640
حافظه را اشغال می کند، اما در مقابل
120
00:04:59,640 –> 00:05:01,980
اگر لیست بسیار بزرگی از اعداد یا
121
00:05:01,980 –> 00:05:06,270
اعداد صحیح داشته باشید، بسیار کوچک است، بنابراین مولد مقدار زیادی از
122
00:05:06,270 –> 00:05:08,640
حافظه را ذخیره می کند. اگر به
123
00:05:08,640 –> 00:05:13,320
دنباله بزرگی از اعداد نیاز دارید، اجازه دهید نگاهی
124
00:05:13,320 –> 00:05:14,910
به برنامه دیگری در اینجا بیندازیم برای
125
00:05:14,910 –> 00:05:16,860
ژنراتورهایی که از ژنراتور استفاده میکنند و
126
00:05:16,860 –> 00:05:20,160
اکنون هر بار در
127
00:05:20,160 –> 00:05:20,940
حلقه for،
128
00:05:20,940 –> 00:05:23,130
آنچه پایتون در پشت
129
00:05:23,130 –> 00:05:25,860
صحنه انجام میدهد این است که ما این کار را انجام میدهد. ژن در اینجا
130
00:05:25,860 –> 00:05:27,900
که ژنراتور من است a و آنچه که در
131
00:05:27,900 –> 00:05:30,630
واقع در پشت صحنه انجام می دهد، هر
132
00:05:30,630 –> 00:05:32,220
تکرار از طریق حلقه for است،
133
00:05:32,220 –> 00:05:33,960
این کار را انجام می دهد، تابع
134
00:05:33,960 –> 00:05:35,820
زیرخط زیر خط بعدی زیرخط
135
00:05:35,820 –> 00:05:40,530
در پایتون فراخوانی می شود و این
136
00:05:40,530 –> 00:05:43,410
مقدار بعدی را از آن ژنراتور دریافت
137
00:05:43,410 –> 00:05:45,150
می کند، کاری که پایتون در پشت صحنه