در این مطلب، ویدئو برنامه نویسی AsyncIO و Asynchronous در پایتون با زیرنویس فارسی را برای دانلود قرار داده ام. شما میتوانید با پرداخت 15 هزار تومان ، این ویدیو به علاوه تمامی فیلم های سایت را دانلود کنید.اکثر فیلم های سایت به زبان انگلیسی می باشند. این ویدئو دارای زیرنویس فارسی ترجمه شده توسط هوش مصنوعی می باشد که میتوانید نمونه ای از آن را در قسمت پایانی این مطلب مشاهده کنید.
مدت زمان فیلم: 00:12:28
تصاویر این ویدئو:
قسمتی از زیرنویس این فیلم:
00:00:04,240 –> 00:00:09,120
[موسیقی]
2
00:00:09,120 –> 00:00:10,639
بچهها به چه اتفاقی میافتد خوش آمدید در
3
00:00:10,639 –> 00:00:12,160
ویدیوی امروز ما در مورد
4
00:00:12,160 –> 00:00:14,160
یکی از موضوعات درخواستی در این
5
00:00:14,160 –> 00:00:16,640
کانال صحبت میکنیم که همگامسازی در انتظار در پایتون
6
00:00:16,640 –> 00:00:16,960
یا
7
00:00:16,960 –> 00:00:19,279
برنامهنویسی ناهمزمان در پایتون است، پس
8
00:00:19,279 –> 00:00:21,199
بیایید خوب وارد آن شویم،
9
00:00:21,199 –> 00:00:22,880
پس اجازه دهید ما ابتدا در مورد اینکه
10
00:00:22,880 –> 00:00:25,039
برنامه نویسی ناهمزمان چیست برنامه
11
00:00:25,039 –> 00:00:26,640
نویسی ناهمزمان نیست،
12
00:00:26,640 –> 00:00:28,160
چند رشته ای نیست، همچنین
13
00:00:28,160 –> 00:00:30,080
چند پردازشی نیست،
14
00:00:30,080 –> 00:00:31,359
برنامه نویسی همزمان است و ما در
15
00:00:31,359 –> 00:00:32,960
مورد ایده کلی
16
00:00:32,960 –> 00:00:33,920
برنامه نویسی همزمان
17
00:00:33,920 –> 00:00:35,680
و کل الگوهای کدنویسی صحبت نمی
18
00:00:35,680 –> 00:00:37,920
کنیم، زیرا این کار شایسته یک سری به خودی خود
19
00:00:37,920 –> 00:00:39,200
ما در مورد اصول اولیه
20
00:00:39,200 –> 00:00:40,960
و نحوه پیاده سازی
21
00:00:40,960 –> 00:00:42,480
آنها در پایتون صحبت می کنیم،
22
00:00:42,480 –> 00:00:44,160
حالا بیایید به یک مثال سریع در اینجا نگاه
23
00:00:44,160 –> 00:00:46,160
کنیم، فرض کنیم یک تابع
24
00:00:46,160 –> 00:00:48,000
داریم که فراخوانی می شود، یک تابع
25
00:00:48,000 –> 00:00:49,600
دو داریم که فراخوانی می شود. و ما یک
26
00:00:49,600 –> 00:00:50,399
تابع
27
00:00:50,399 –> 00:00:53,039
سه داریم که فراخوانی می شود، بنابراین اگر این
28
00:00:53,039 –> 00:00:54,559
تابع، تابع اصلی
29
00:00:54,559 –> 00:00:56,719
که آن توابع در آن فراخوانی
30
00:00:56,719 –> 00:00:58,559
می شوند همزمان باشد، به این معنی است که ما می
31
00:00:58,559 –> 00:01:00,079
خواهیم فراخوانی کنیم. function1
32
00:01:00,079 –> 00:01:02,320
و ما میخواهیم تابع2 را فراخوانی کنیم
33
00:01:02,320 –> 00:01:03,600
وقتی تابع1
34
00:01:03,600 –> 00:01:06,640
برمیگردد یا در واقع خاتمه مییابد یا
35
00:01:06,640 –> 00:01:07,600
این مشکل را برمیگرداند
36
00:01:07,600 –> 00:01:10,159
احتمالاً عبارت درست در اینجا است، بنابراین ما
37
00:01:10,159 –> 00:01:12,000
فقط
38
00:01:12,000 –> 00:01:14,960
زمانی که function1 انجام میشود
39
00:01:14,960 –> 00:01:16,640
و پس از آن فراخوانی میکنیم تابع 3
40
00:01:16,640 –> 00:01:18,159
وقتی تابع 2 برمی گرداند
41
00:01:18,159 –> 00:01:20,640
، اگر از
42
00:01:20,640 –> 00:01:23,680
چند رشته ای یا چند پردازشی استفاده
43
00:01:23,680 –> 00:01:25,040
کنیم که شبیه
44
00:01:25,040 –> 00:01:26,640
برنامه نویسی ناهمزمان نیست، اکنون همگام است، زیرا در
45
00:01:26,640 –> 00:01:28,159
چند رشته ای سه
46
00:01:28,159 –> 00:01:29,439
رشته در این حالت تعریف
47
00:01:29,439 –> 00:01:31,040
می کنیم و همه آن توابع
48
00:01:31,040 –> 00:01:32,799
را همزمان یا تقریباً اجرا می کنیم. در عین
49
00:01:32,799 –> 00:01:34,240
حال سعی خواهیم کرد
50
00:01:34,240 –> 00:01:36,320
یا آنها را به طور همزمان اجرا کنیم یا
51
00:01:36,320 –> 00:01:37,840
حداقل توهم اجرای همزمان را ایجاد کنیم.
52
00:01:37,840 –> 00:01:39,680
53
00:01:39,680 –> 00:01:41,439
این هدف
54
00:01:41,439 –> 00:01:42,880
برنامه نویسی ناهمزمان با
55
00:01:42,880 –> 00:01:43,759
برنامه نویسی
56
00:01:43,759 –> 00:01:45,600
57
00:01:45,600 –> 00:01:47,680
58
00:01:47,680 –> 00:01:49,680
ناهمزمان نیست. برخی از داده ها از یک پایگاه داده
59
00:01:49,680 –> 00:01:51,119
از یک
60
00:01:51,119 –> 00:01:53,200
api یا به طور کلی فقط
61
00:01:53,200 –> 00:01:55,119
به خاطر اینکه منتظر بمانیم
62
00:01:55,119 –> 00:01:57,600
اگر این اتفاق بیفتد ما می خواهیم هیچ
63
00:01:57,600 –> 00:02:00,000
وقت cpu را هدر ندهیم و می خواهیم اجرای
64
00:02:00,000 –> 00:02:01,360
تابع 2 را شروع کنیم،
65
00:02:01,360 –> 00:02:02,960
حتی اگر این تابع
66
00:02:02,960 –> 00:02:04,399
هنوز برنگشته باشد، اما
67
00:02:04,399 –> 00:02:06,159
در حال حاضر کاری انجام نمی دهد، بنابراین ما فقط می توانیم
68
00:02:06,159 –> 00:02:08,080
یک کار را
69
00:02:08,080 –> 00:02:10,160
همزمان اجرا کنیم، ما هیچ
70
00:02:10,160 –> 00:02:12,160
چند پردازشی یا چند پردازشی انجام نمی دهیم. چند رشته ای،
71
00:02:12,160 –> 00:02:13,280
ما یک کار
72
00:02:13,280 –> 00:02:16,239
را همزمان انجام می دهیم، اما اگر تابع یک
73
00:02:16,239 –> 00:02:16,720
در حالت
74
00:02:16,720 –> 00:02:18,400
خواب یا انتظار یا
75
00:02:18,400 –> 00:02:19,760
غیرمولد باشد،
76
00:02:19,760 –> 00:02:21,680
می توانیم از آن زمان برای شروع
77
00:02:21,680 –> 00:02:22,959
اجرای تابع دو
78
00:02:22,959 –> 00:02:25,120
و شاید تابع سه استفاده کنیم، بنابراین این
79
00:02:25,120 –> 00:02:27,760
ایده اصلی برنامه نویسی ناهمزمان
80
00:02:27,760 –> 00:02:29,200
است. برای انجام
81
00:02:29,200 –> 00:02:30,800
برنامه نویسی ناهمزمان در پایتون باید
82
00:02:30,800 –> 00:02:31,840
کتابخانه ای به نام
83
00:02:31,840 –> 00:02:35,040
async io وارد کنیم، بنابراین async
84
00:02:35,040 –> 00:02:38,400
o را وارد کنیم و اکنون برای تعریف یک تابع
85
00:02:38,400 –> 00:02:40,080
به عنوان ناهمزمان، زیرا قرار
86
00:02:40,080 –> 00:02:41,440
نیست فقط بگوییم کل برنامه
87
00:02:41,440 –> 00:02:43,360
ناهمزمان است، فقط توابع خاصی
88
00:02:43,360 –> 00:02:44,959
قرار است ناهمزمان باشد،
89
00:02:44,959 –> 00:02:47,040
ما باید از کلمه کلیدی async استفاده
90
00:02:47,040 –> 00:02:48,959
کنیم، بنابراین می خواهیم بگوییم async
91
00:02:48,959 –> 00:02:50,720
def و یک نام تابع در این مورد من می
92
00:02:50,720 –> 00:02:52,239
خواهم main را انتخاب کنم، ما
93
00:02:52,239 –> 00:02:53,519
یک تابع اصلی خواهیم داشت
94
00:02:53,519 –> 00:02:55,519
که در حال انجام است. ناهمزمان بودن و
95
00:02:55,519 –> 00:02:56,959
اگر فقط آن تابع اصلی را داشته باشیم،
96
00:02:56,959 –> 00:02:58,400
مطمئناً کل برنامه ناهمزمان خواهد بود،
97
00:02:58,400 –> 00:02:59,760
98
00:02:59,760 –> 00:03:02,080
اما این ایده است حالا بیایید یک
99
00:03:02,080 –> 00:03:03,519
تابع بسیار اساسی را در اینجا انجام دهیم، می گوییم
100
00:03:03,519 –> 00:03:04,239
print a
101
00:03:04,239 –> 00:03:07,280
و می گوییم چاپ ب و
102
00:03:07,280 –> 00:03:08,640
در این بین ما قرار است بخوابیم اما
103
00:03:08,640 –> 00:03:10,560
با زمان نمیخوابیم
104
00:03:10,560 –> 00:03:11,680
. بخوابیم با
105
00:03:11,680 –> 00:03:15,360
async میخوابیم i o dot sleep بنابراین async io dot
106
00:03:15,360 –> 00:03:18,000
بخوابیم برای یک ثانیه حالا مهم
107
00:03:18,000 –> 00:03:20,080
اینجاست که به آن نیاز داریم.
108
00:03:20,080 –> 00:03:21,440
اگر یک تابع ناهمزمان را فراخوانی می
109
00:03:21,440 –> 00:03:23,120
کنیم باید آن را با یک کار انجام دهیم که
110
00:03:23,120 –> 00:03:23,840
باید
111
00:03:23,840 –> 00:03:26,799
منتظر آن باشیم یا باید async io dot را
112
00:03:26,799 –> 00:03:27,200
اجرا کنیم،
113
00:03:27,200 –> 00:03:28,799
در این مورد یک انتظار می گوییم
114
00:03:28,799 –> 00:03:30,400
که اساساً به این معنی است که ما ما
115
00:03:30,400 –> 00:03:32,400
باید منتظر بمانیم تا این عبارت تمام شود
116
00:03:32,400 –> 00:03:34,879
و قبل از اینکه این تماس در اینجا تمام شود،
117
00:03:34,879 –> 00:03:36,560
ما هیچ کار دیگری انجام نمی دهیم،
118
00:03:36,560 –> 00:03:38,080
این مهم است زیرا
119
00:03:38,080 –> 00:03:39,760
همانطور که یاد گرفتیم در برنامه نویسی ناهمزمان،
120
00:03:39,760 –> 00:03:42,239
اگر چیزی
121
00:03:42,239 –> 00:03:44,480
باعث اتلاف وقت شود، ادامه می دهیم. بنابراین در این
122
00:03:44,480 –> 00:03:46,000
مورد ما یک را چاپ می
123
00:03:46,000 –> 00:03:47,760
کنیم و سپس مجبور به w می شویم ait چون اینجا می
124
00:03:47,760 –> 00:03:50,239
گوییم منتظر این چیز باشید
125
00:03:50,239 –> 00:03:52,480
و بعد از اینکه
126
00:03:52,480 –> 00:03:53,680
کار انجام
127
00:03:53,680 –> 00:03:55,120
شد برای اجرای تابع اصلی باید b را چاپ کنیم،
128
00:03:55,120 –> 00:03:56,959
باید بگوییم async
129
00:03:56,959 –> 00:04:00,000
io dot run main و بسیار مهم
130
00:04:00,000 –> 00:04:01,360
است که در واقع main را صدا کنیم.
131
00:04:01,360 –> 00:04:03,120
ما فقط به آن اشاره نمی کنیم، همانطور که
132
00:04:03,120 –> 00:04:04,319
در چند رشته ای انجام
133
00:04:04,319 –> 00:04:05,920
می دهیم، بلکه در واقع تابع را فراخوانی می کنیم،
134
00:04:05,920 –> 00:04:07,599
بنابراین از این پرانتزها در اینجا استفاده می کنیم و همچنین
135
00:04:07,599 –> 00:04:09,599
اینطور نیست که بگوییم هدف
136
00:04:09,599 –> 00:04:11,599
برابر با main در یک رشته است، ما در واقع
137
00:04:11,599 –> 00:04:12,879
تابع را در اینجا فراخوانی می کنیم. من فقط
138
00:04:12,879 –> 00:04:14,959
به آن اشاره نمی
139
00:04:14,959 –> 00:04:16,320
کنم، بنابراین من این را اجرا می کنم و شما
140
00:04:16,320 –> 00:04:18,238
یک برنامه بسیار ابتدایی را
141
00:04:18,238 –> 00:04:21,358
یک ثانیه و سپس b می بینید،
142
00:04:21,358 –> 00:04:23,680
بنابراین
143
00:04:23,680 –> 00:04:25,040
برنامه نویسی واقعا ناهمزمان نیست، بنابراین اینجا چه
144
00:04:25,040 –> 00:04:27,120
کار باید انجام دهیم، اجازه دهید معرفی کنیم. یک
145
00:04:27,120 –> 00:04:28,880
تابع دوم، فرض کنید یک
146
00:04:28,880 –> 00:04:30,960
تابع ناهمزمان دیگر
147
00:04:30,960 –> 00:04:32,639
داریم که فقط تابع دیگری را فراخوانی می
148
00:04:32,639 –> 00:04:34,240
کنیم
149
00:04:34,240 –> 00:04:35,520
و در اینجا می
150
00:04:35,520 –> 00:04:36,720
خواهیم چیز دیگری را در اینجا
151
00:04:36,720 –> 00:04:37,840
چاپ کنیم، یک
152
00:04:37,840 –> 00:04:40,639
و سپس دو
153
00:04:41,680 –> 00:04:43,360
یک دو و در بین ما میروم
154
00:04:43,360 –> 00:04:45,759
بخوابم، فرض کنید منتظر
155
00:04:45,759 –> 00:04:48,400
async io d است در حالت خواب، اکنون
156
00:04:48,400 –> 00:04:50,639
در اینجا دو ثانیه میخوابیم،
157
00:04:50,639 –> 00:04:53,040
اگر جلو برویم و آن
158
00:04:53,040 –> 00:04:54,240
تابع را
159
00:04:54,240 –> 00:04:56,240
بهجای خوابیدن در اینجا فراخوانی کنیم، میتوانیم
160
00:04:56,240 –> 00:04:58,800
پیش برویم و بگوییم منتظر عملکرد دیگری باشید،
161
00:04:58,800 –> 00:05:00,320
اما این خیلی
162
00:05:00,320 –> 00:05:02,160
ناهمزمان نخواهد بود، زیرا در واقع این تابع
163
00:05:02,160 –> 00:05:02,960
همزمان است.
164
00:05:02,960 –> 00:05:04,800
برنامه نویسی همزمان چرا
165
00:05:04,800 –> 00:05:06,800
چون ما در حال چاپ a
166
00:05:06,800 –> 00:05:08,560
هستیم منتظر تابعی هستیم که
167
00:05:08,560 –> 00:05:10,400
همان فراخوانی آن به صورت همزمان
168
00:05:10,400 –> 00:05:12,800
است، می گوییم خوب این کار را تا زمانی که
169
00:05:12,800 –> 00:05:14,000
همه این کارها انجام
170
00:05:14,000 –> 00:05:16,560
نشده است اجرا نکنید تا واقعا ناهمزمان نباشد اما
171
00:05:16,560 –> 00:05:17,600
اینگونه است میتوانیم
172
00:05:17,600 –> 00:05:19,520
برنامهنویسی همزمان را در یک
173
00:05:19,520 –> 00:05:21,039
تابع ناهمزمان
174
00:05:21,039 –> 00:05:23,440
انجام دهیم، بنابراین چه کنیم، اما اگر
175
00:05:23,440 –> 00:05:24,320
بخواهیم کاری را
176
00:05:24,320 –> 00:05:25,759
با تابع اصلی در اینجا انجام دهیم، میخواهیم
177
00:05:25,759 –> 00:05:27,759
a را چاپ کنیم و سپس میخواهیم آن تابع را فراخوانی کنیم و به این
178
00:05:27,759 –> 00:05:30,080
ترتیب یکی را چاپ کنیم، اما
179
00:05:30,080 –> 00:05:32,560
وقتی این تابع در اینجا خواب است، ما
180
00:05:32,560 –> 00:05:34,400
از قبل میخواهیم این کار را انجام دهیم، بنابراین ما
181
00:05:34,400 –> 00:05:36,960
از قبل میخواهیم b چاپ کنیم
182
00:05:36,960 –> 00:05:38,320
و وقتی این کار انجام شد،
183
00:05:38,320 –> 00:05:40,880
دو چاپ میکنیم تا این کار را انجام دهیم، باید با
184
00:05:40,880 –> 00:05:41,440
185
00:05:41,440 –> 00:05:43,199
وظایف کار کنیم تا در ابتدا در اینجا چه کاری انجام دهیم.
186
00:05:43,199 –> 00:05:44,720
از تابع این است که
187
00:05:44,720 –> 00:05:46,320
میخواهیم بگوییم
188
00:05:46,320 –> 00:05:49,600
uh task برابر است با async io
189
00:05:49,600 –> 00:05:52,720
dot create task و ما
190
00:05:52,720 –> 00:05:53,520
یک
191
00:05:53,520 –> 00:05:55,919
تابع دیگر ایجاد میکنیم، بنابراین ما
192
00:05:55,919 –> 00:05:58,240
دوباره تابع را در اینجا فراخوانی میکنیم
193
00:05:58,240 –> 00:06:01,360
و این کار اکنون زمانبندی شده است و
194
00:06:01,360 –> 00:06:02,880
اساساً این یعنی
195
00:06:02,880 –> 00:06:04,639
نوشتن آن به این صورت اساساً به این معنی است
196
00:06:04,639 –> 00:06:07,199
که وقتی مدت زمان بیکاری داریم،
197
00:06:07,199 –> 00:06:09,039
آن وظیفه را فراخوانی می کنیم،
198
00:06:09,039 –> 00:06:10,880
بنابراین من حتی مطمئن نیستم که آیا آن را
199
00:06:10,880 –> 00:06:12,880
صدا می کند اگر فقط