در این مطلب، ویدئو چند پردازش در پایتون | مبانی تا پیشرفته | آموزش – 1 با زیرنویس فارسی را برای دانلود قرار داده ام. شما میتوانید با پرداخت 15 هزار تومان ، این ویدیو به علاوه تمامی فیلم های سایت را دانلود کنید.اکثر فیلم های سایت به زبان انگلیسی می باشند. این ویدئو دارای زیرنویس فارسی ترجمه شده توسط هوش مصنوعی می باشد که میتوانید نمونه ای از آن را در قسمت پایانی این مطلب مشاهده کنید.
مدت زمان فیلم: 00:20:07
تصاویر این ویدئو:
قسمتی از زیرنویس این فیلم:
00:00:00,080 –> 00:00:02,320
سلام مردم آینده به نرمال نرد خوش آمدید
2
00:00:02,320 –> 00:00:03,439
3
00:00:03,439 –> 00:00:04,920
امروز می خواهم در مورد
4
00:00:04,920 –> 00:00:06,640
چند پردازش صحبت کنم و
5
00:00:06,640 –> 00:00:09,040
اینکه چگونه می توانید چند پردازش را در
6
00:00:09,040 –> 00:00:10,480
موارد دنیای واقعی
7
00:00:10,480 –> 00:00:13,440
با استفاده از پایتون پیاده سازی کنید، به من اعتماد کنید اگر می توانید از
8
00:00:13,440 –> 00:00:14,639
چند پردازش
9
00:00:14,639 –> 00:00:17,520
در مکان مناسب استفاده کنید، ممکن است
10
00:00:17,520 –> 00:00:18,880
سرعت کد شما را
11
00:00:18,880 –> 00:00:22,000
تا پنج برابر افزایش دهد. حداقل تا شش برابر،
12
00:00:22,000 –> 00:00:24,800
بله،
13
00:00:24,800 –> 00:00:26,480
اگر در کانال من تازه کار هستید، مفهوم بسیار مهمی است، لطفاً
14
00:00:26,480 –> 00:00:27,920
در کانال من مشترک شوید و نماد زنگ را بزنید
15
00:00:27,920 –> 00:00:28,320
16
00:00:28,320 –> 00:00:30,320
زیرا من به طور مرتب ویدیوهایی در مورد
17
00:00:30,320 –> 00:00:32,479
یادگیری ماشینی و پایتون میسازم،
18
00:00:32,479 –> 00:00:34,399
بنابراین بدون هیچ مقدمه دیگری، بیایید ابتدا
19
00:00:34,399 –> 00:00:35,680
شروع کنیم.
20
00:00:35,680 –> 00:00:37,920
از همه چیز من می خواهم
21
00:00:37,920 –> 00:00:39,360
مفهوم چند پردازش
22
00:00:39,360 –> 00:00:41,440
را توضیح دهم اگر شما فردی هستید که قبلاً
23
00:00:41,440 –> 00:00:43,120
مفهوم چند پردازش را می شناسید
24
00:00:43,120 –> 00:00:44,800
و فقط به
25
00:00:44,800 –> 00:00:46,559
پیاده سازی علاقه دارید، می توانید
26
00:00:46,559 –> 00:00:47,520
27
00:00:47,520 –> 00:00:48,960
برای درک بهتر این
28
00:00:48,960 –> 00:00:51,039
مفهوم که در اینجا دو مورد را آورده ام چند دقیقه صرف نظر کنید. نمودارها
29
00:00:51,039 –> 00:00:53,760
در سمت چپ ما
30
00:00:53,760 –> 00:00:55,840
آهسته برنامه نویسی معمولی را داریم
31
00:00:55,840 –> 00:00:58,079
و در سمت راست
32
00:00:58,079 –> 00:00:59,840
ما چند پردازش را داریم،
33
00:00:59,840 –> 00:01:01,680
بنابراین بیایید به t برسیم پردازش تکی
34
00:01:01,680 –> 00:01:03,039
روش عادی
35
00:01:03,039 –> 00:01:05,840
اجرای برنامه فرض کنید ما یک
36
00:01:05,840 –> 00:01:06,720
کد
37
00:01:06,720 –> 00:01:09,920
داریم و آن را به چهار تکه تقسیم کرده ایم.
38
00:01:09,920 –> 00:01:13,520
39
00:01:13,520 –> 00:01:16,479
40
00:01:16,479 –> 00:01:17,119
41
00:01:17,119 –> 00:01:19,920
42
00:01:19,920 –> 00:01:21,439
43
00:01:21,439 –> 00:01:24,640
پردازش تک به این صورت است که ابتدا
44
00:01:24,640 –> 00:01:27,680
cpu کار یک را انجام می دهد
45
00:01:27,680 –> 00:01:30,240
و بعد از اتمام آن
46
00:01:30,240 –> 00:01:31,439
به کار دو می رود
47
00:01:31,439 –> 00:01:33,840
سپس آن را تمام می کند و سپس به سه
48
00:01:33,840 –> 00:01:35,439
و سپس به چهار می رسد
49
00:01:35,439 –> 00:01:37,840
بنابراین کل زمان صرف شده برای اتمام
50
00:01:37,840 –> 00:01:38,640
برنامه
51
00:01:38,640 –> 00:01:41,600
حاصل جمع زمان برای
52
00:01:41,600 –> 00:01:43,119
همه تک تک مشاغل
53
00:01:43,119 –> 00:01:45,439
حالا تصور کنید این چهار شغل
54
00:01:45,439 –> 00:01:46,960
مستقل از یکدیگر هستند
55
00:01:46,960 –> 00:01:49,680
حالا منظورم از خوب مستقل
56
00:01:49,680 –> 00:01:50,720
چیست منظورم این است
57
00:01:50,720 –> 00:01:53,520
که ترتیب اجرا
58
00:01:53,520 –> 00:01:54,079
مهم نیست
59
00:01:54,079 –> 00:01:56,479
بنابراین مهم نیست که
60
00:01:56,479 –> 00:01:59,680
اول کار 2 را تمام کنیم یا کار 1 اول یا شغل 3 یا
61
00:01:59,680 –> 00:02:00,320
شغل 4
62
00:02:00,320 –> 00:02:03,759
خیلی خوب است، بنابراین در این سناریو وقتی مشاغل
63
00:02:03,759 –> 00:02:04,799
مستقل هستند
64
00:02:04,799 –> 00:02:08,000
و می توانند به طور موازی پردازش شوند،
65
00:02:08,000 –> 00:02:09,720
می توانیم از مفهوم
66
00:02:09,720 –> 00:02:11,200
چند پردازش استفاده کنیم،
67
00:02:11,200 –> 00:02:13,280
بنابراین آنچه در سمت راست اتفاق می افتد این
68
00:02:13,280 –> 00:02:15,200
است که ما
69
00:02:15,200 –> 00:02:17,760
چهار فرآیند داریم. بنابراین وقتی برنامه
70
00:02:17,760 –> 00:02:19,440
شروع به اجرا میکند،
71
00:02:19,440 –> 00:02:22,480
ما چهار فرآیند را شروع میکنیم و
72
00:02:22,480 –> 00:02:24,879
هر فرآیند از یک کار متفاوت مراقبت میکند،
73
00:02:24,879 –> 00:02:26,000
74
00:02:26,000 –> 00:02:28,640
بنابراین چه فایدهای دارد که در اینجا به
75
00:02:28,640 –> 00:02:30,000
طور موازی
76
00:02:30,000 –> 00:02:32,440
چهار کار را پردازش میکنیم، بنابراین در صورت
77
00:02:32,440 –> 00:02:34,879
چند پردازش، زمان صرف شده برای
78
00:02:34,879 –> 00:02:36,080
اتمام برنامه کامل
79
00:02:36,080 –> 00:02:39,280
است. زمان صرف شده توسط
80
00:02:39,280 –> 00:02:43,120
بزرگترین کار و در مورد ما شغل
81
00:02:43,120 –> 00:02:44,480
2 بیشترین زمان را می گیرد، به
82
00:02:44,480 –> 00:02:47,120
طوری که زمان صرف شده توسط کل
83
00:02:47,120 –> 00:02:47,920
برنامه است،
84
00:02:47,920 –> 00:02:50,000
بنابراین امیدوارم اکنون مفهوم چند پردازش را درک کرده باشید
85
00:02:50,000 –> 00:02:51,440
86
00:02:51,440 –> 00:02:53,519
اکنون یک اشتباه بسیار رایجی که مبتدیان مرتکب می
87
00:02:53,519 –> 00:02:55,840
شوند این است که آنها فکر می کنند
88
00:02:55,840 –> 00:02:58,720
ما فقط میتوانیم به
89
00:02:58,720 –> 00:02:59,840
90
00:02:59,840 –> 00:03:03,040
اندازه تعداد هستههای cpu در دسترس
91
00:03:03,040 –> 00:03:03,680
ما، چندین پردازش را به صورت موازی اجرا کنیم،
92
00:03:03,680 –> 00:03:06,239
اما این درست نیست، ما حتی میتوانیم
93
00:03:06,239 –> 00:03:07,280
چند پردازش را
94
00:03:07,280 –> 00:03:10,400
روی یک هسته به خوبی اجرا کنیم، در این صورت
95
00:03:10,400 –> 00:03:13,200
موازیسازی واقعی را نخواهیم داشت، اتفاقی که
96
00:03:13,200 –> 00:03:14,239
میافتد
97
00:03:14,239 –> 00:03:17,680
زمانی که یک کار انجام میدهد. i o کار مرتبط
98
00:03:17,680 –> 00:03:18,239
99
00:03:18,239 –> 00:03:20,720
پس از آن cpu توسط فرآیند به درستی استفاده نمی شود،
100
00:03:20,720 –> 00:03:21,760
101
00:03:21,760 –> 00:03:24,400
بنابراین در آن زمان یک فرآیند دیگر
102
00:03:24,400 –> 00:03:26,480
جایگزین فرآیند قبلی می شود
103
00:03:26,480 –> 00:03:30,080
و کار cpu خود را انجام می دهد و به این می گویند
104
00:03:30,080 –> 00:03:32,400
سوئیچینگ متنی n نکته بسیار
105
00:03:32,400 –> 00:03:33,760
مهم دیگری که در اینجا باید به آن اشاره کنم
106
00:03:33,760 –> 00:03:34,400
این است که
107
00:03:34,400 –> 00:03:37,599
هر یک از فرآیندها حافظه جداگانه ای دریافت می کنند
108
00:03:37,599 –> 00:03:40,560
بنابراین هیچ حافظه مشترکی وجود ندارد
109
00:03:40,560 –> 00:03:41,040
در حالی که
110
00:03:41,040 –> 00:03:44,159
در صورت چند رشته ای آنها در واقع
111
00:03:44,159 –> 00:03:46,879
به همان حافظه دسترسی دارند بنابراین بله این یک
112
00:03:46,879 –> 00:03:48,319
تفاوت بسیار مهم بین
113
00:03:48,319 –> 00:03:50,319
پردازش چندگانه است. و چند رشته ای،
114
00:03:50,319 –> 00:03:52,400
بنابراین امیدوارم این مفهوم
115
00:03:52,400 –> 00:03:53,439
برای شما کافی باشد،
116
00:03:53,439 –> 00:03:55,760
بنابراین بیایید وارد بخش کدنویسی شویم
117
00:03:55,760 –> 00:03:57,439
، ما با یک برنامه بسیار ساده شروع می
118
00:03:57,439 –> 00:03:58,080
119
00:03:58,080 –> 00:03:59,599
کنیم تا تفاوت
120
00:03:59,599 –> 00:04:01,840
بین پردازش چندگانه و پردازش واحد را نشان دهیم
121
00:04:01,840 –> 00:04:02,400
122
00:04:02,400 –> 00:04:05,599
و اینکه چگونه کار واقعاً کار می کند. ما در
123
00:04:05,599 –> 00:04:06,720
اینجا
124
00:04:06,720 –> 00:04:09,200
دو تابع مختلف خواهیم داشت که می توانید
125
00:04:09,200 –> 00:04:10,000
آنها را به عنوان
126
00:04:10,000 –> 00:04:13,200
دو کار متفاوت در نظر بگیرید،
127
00:04:13,200 –> 00:04:16,238
اولی تابعی است به نام شمارنده یک،
128
00:04:16,238 –> 00:04:19,358
بنابراین یک کار بسیار ساده را انجام می دهد و فقط مهم است،
129
00:04:19,358 –> 00:04:22,400
بنابراین در اینجا می توانید ببینید که من
130
00:04:22,400 –> 00:04:26,240
یک حلقه برای را اجرا می کنم. تعداد دفعات n
131
00:04:26,240 –> 00:04:29,199
و در هر مرحله شمارنده را افزایش می دهم
132
00:04:29,199 –> 00:04:30,400
133
00:04:30,400 –> 00:04:33,040
و پس از انجام شمارش، فقط
134
00:04:33,040 –> 00:04:33,919
135
00:04:33,919 –> 00:04:36,800
شمارنده 1 را چاپ می کنم در تابع دوم
136
00:04:36,800 –> 00:04:38,720
نام شمارنده 2 است و
137
00:04:38,720 –> 00:04:41,440
اکنون y2
138
00:04:41,840 –> 00:04:44,720
باشد. زیرا در اینجا در حلقه for میتوانید ببینید
139
00:04:44,720 –> 00:04:46,639
که من گام را 2 افزایش میدهم،
140
00:04:46,639 –> 00:04:50,720
بنابراین این تابع
141
00:04:50,720 –> 00:04:53,840
باید دقیقاً در نیمی از
142
00:04:53,840 –> 00:04:54,400
143
00:04:54,400 –> 00:04:57,840
زمان اولین تابع اجرا شود،
144
00:04:58,960 –> 00:05:01,680
بنابراین اکنون دو کار خود را داریم و
145
00:05:01,680 –> 00:05:03,440
ابتدا آن را به
146
00:05:03,440 –> 00:05:06,160
صورت متوالی اجرا میکنم. در اینجا من یک
147
00:05:06,160 –> 00:05:06,960
عدد بزرگ مانند
148
00:05:06,960 –> 00:05:10,160
2 ضربدر 10 را به توان 8 می آورم.
149
00:05:10,160 –> 00:05:12,400
سپس توابع شمارنده
150
00:05:12,400 –> 00:05:15,600
1 و شمارنده 2 را فراخوانی می کنم.
151
00:05:17,039 –> 00:05:20,880
اکنون برای اینکه ببینم چقدر زمان می برد
152
00:05:20,880 –> 00:05:25,520
باید کتابخانه زمان را وارد کنیم
153
00:05:25,520 –> 00:05:28,720
و سپس قبل از شروع
154
00:05:28,720 –> 00:05:29,600
برنامه
155
00:05:29,600 –> 00:05:32,320
ما یک متغیر به نام st را مقداردهی اولیه می کنیم
156
00:05:32,320 –> 00:05:32,960
157
00:05:32,960 –> 00:05:35,199
و بعد از اتمام اجرای برنامه،
158
00:05:35,199 –> 00:05:36,160
159
00:05:36,160 –> 00:05:39,520
متغیر دیگری به نام en را نیز مقداردهی اولیه می کنیم،
160
00:05:39,520 –> 00:05:41,919
بنابراین برای دیدن زمان صرف شده برای اتمام
161
00:05:41,919 –> 00:05:43,039
دو کار،
162
00:05:43,039 –> 00:05:45,360
فقط می توانیم تفاوت بین
163
00:05:45,360 –> 00:05:48,479
en و st
164
00:05:49,600 –> 00:05:53,840
را چاپ کنیم، بنابراین اجازه دهید این را اجرا کنیم. برنامه ریزی کنید
165
00:06:00,639 –> 00:06:03,199
تا هر دو کار انجام شوند و
166
00:06:03,199 –> 00:06:04,639
زمان صرف شده برای اتمام
167
00:06:04,639 –> 00:06:09,120
این دو کار حدود 13 ثانیه است
168
00:06:09,120 –> 00:06:10,960
و اکنون به شما نشان می دهم که چگونه می توانیم
169
00:06:10,960 –> 00:06:12,479
از چند پردازش در اینجا
170
00:06:12,479 –> 00:06:15,680
برای سرعت بخشیدن به برنامه خود استفاده کنیم،
171
00:06:18,800 –> 00:06:20,720
بنابراین اول از همه باید وارد کنیم
172
00:06:20,720 –> 00:06:21,919
کتابخانه ای به نام
173
00:06:21,919 –> 00:06:24,800
mul
174
00:06:25,520 –> 00:06:27,360
نکته بسیار مهم برای
175
00:06:27,360 –> 00:06:29,360
کاربران ویندوز مانند من
176
00:06:29,360 –> 00:06:31,280
این است که شما باید کد پردازش چندگانه خود را
177
00:06:31,280 –> 00:06:32,880
178
00:06:32,880 –> 00:06:35,199
در بلوک اصلی قرار دهید و اگر
179
00:06:35,199 –> 00:06:36,080
کاربر لینوکس
180
00:06:36,080 –> 00:06:39,520
هستید، نیازی به این نیست که به آن اهمیت
181
00:06:39,840 –> 00:06:44,639
دهید، بنابراین بلوک اصلی
182
00:06:47,039 –> 00:06:50,960
ما اینجاست. دو کار دریافت کردهاند، بنابراین در حالت
183
00:06:50,960 –> 00:06:53,680
ایدهآل باید دو فرآیند وجود داشته باشد که
184
00:06:53,680 –> 00:06:55,599
از این دو کار مراقبت
185
00:06:55,599 –> 00:06:58,720
میکنند، بنابراین در اینجا اولین فرآیند
186
00:06:58,720 –> 00:07:01,520
ما برای مقداردهی اولیه فرآیند اول است،
187
00:07:01,520 –> 00:07:02,720
در اینجا فرآیند
188
00:07:02,720 –> 00:07:06,080
چند پردازشی نحوی نقطه است و ما
189
00:07:06,080 –> 00:07:08,160
باید دو پارامتر را در اینجا
190
00:07:08,160 –> 00:07:11,759
هدف قرار دهیم و آرگومان هدف خواهد بود.
191
00:07:11,759 –> 00:07:15,120
تابعی که
192
00:07:15,120 –> 00:07:17,680
میخواهید در این فرآیند خاص انجام دهید، بنابراین در
193
00:07:17,680 –> 00:07:18,960
فرآیند p1
194
00:07:18,960 –> 00:07:22,160
من میخواهم تابع شمارنده یک را اجرا
195
00:07:22,160 –> 00:07:25,199
کنم و در
196
00:07:25,199 –> 00:07:28,000
آرگومانها شماره را در اینجا ارسال میکنم، لطفاً توجه داشته باشید که
197
00:07:28,000 –> 00:07:30,240
باید آرگومان را
198
00:07:30,240 –> 00:07:33,759
به صورت یک تاپل ارسال کنید. برای
199
00:07:33,759 –> 00:07:36,880
مقداردهی اولیه فرآیند دیگری به نام p2
200
00:07:36,880 –> 00:07:40,160
همان نحو در اینجا، اما در این
201
00:07:40,160 –> 00:07:45,840
مورد هدف، شمارنده 2 خواهد بود.
202
00:07:47,039 –> 00:07:49,599
بنابراین پس از اینکه فرآیندها مقداردهی اولیه شدند،
203
00:07:49,599 –> 00:07:51,759
باید فرآیندها را شروع کنیم،
204
00:07:51,759 –> 00:07:55,360
بنابراین بسیار زیاد است. شروع ساده p1 dot start و
205
00:07:55,360 –> 00:07:58,560
p2 dot start بعد از
206
00:07:58,560 –> 00:08:02,879
انجام این کار، باید به آنها بپیوندیم،
207
00:08:04,639 –> 00:08:07,039
بنابراین اکنون فقط به عبارات زمان نیاز
208
00:08:07,039 –> 00:08:08,160
209
00:08:08,160 –> 00:08:10,400
داریم تا بتوانیم ببینیم
210
00:08:10,400 –> 00:08:14,560
کد چند پردازشی ما چقدر زمان می برد،
211
00:08:19,759 –> 00:08:22,479
اجازه دهید این را اجرا کنیم
212
00:08:24,960 –> 00:08:27,680
فقط به تفاوت نگاه کنیم. در
213
00:08:27,680 –> 00:08:29,440
مورد تک پردازشی
214
00:08:29,440 –> 00:08:32,799
نزدیک به 13 ثانیه طول می کشد،
215
00:08:32,799 –> 00:08:35,360
اما در مورد چند پردازشی
216
00:08:35,360 –> 00:08:36,000
217
00:08:36,000 –> 00:08:40,159
فقط حدود هشت و نیم ثانیه طول می کشد، بنابراین
218
00:08:40,159 –> 00:08:42,719
این یک پیشرفت واقعا خوب است و
219
00:08:42,719 –> 00:08:44,720
علاوه بر این، می توانید ببینید که
220
00:08:44,720 –> 00:08:47,920
شمارنده دو در واقع قبل از
221
00:08:47,920 –> 00:08:51,120
شمارنده یک تمام شده است، بنابراین این یک اثبات است. که
222
00:08:51,120 –> 00:08:53,680
دو تابع ما در واقع به صورت موازی در حال اجرا هستند،
223
00:08:53,680 –> 00:08:54,880
224
00:08:54,880 –> 00:08:57,360
بسیار خوب است، بنابراین این یک برنامه بسیار ابتدایی بود
225
00:08:57,360 –> 00:08:59,920
و در اینجا ما فرآیندها
226
00:08:59,920 –> 00:09:02,880
را خودمان ایجاد کردیم، اما راه بهتری وجود دارد
227
00:09:02,880 –> 00:09:05,040
که من می خواهم همین الان در این برنامه به شما نشان دهم
228
00:09:05,040 –> 00:09:06,720
که می خواهیم یک برنامه بنویسیم.
229
00:09:06,720 –> 00:09:08,240
تابع بررسی اول
230
00:09:08,240 –> 00:09:11,040
با استفاده از پردازش چندگانه، بنابراین اجازه دهید به
231
00:09:11,040 –> 00:09:13,279
سرعت ماژول هایی را که به آنها نیاز داریم وارد کنیم،
232
00:09:13,279 –> 00:09:15,519
233
00:09:17,760 –> 00:09:19,600
ابتدا یک تابع ترتیبی می نویسم
234
00:09:19,600 –> 00:09:21,600
که مشخص
235
00:09:21,600 –> 00:09:24,800
می کند یک عدد برای همه اعداد اول است یا نه.
236
00:09:24,800 –> 00:09:28,320
کمتر از n
237
00:09:28,320 –> 00:09:31,200
بنابراین ابتدا یک آرایه را اعلام می کنیم و
238
00:09:31,200 –> 00:09:32,080
ابتدا
239
00:09:32,080 –> 00:09:34,880
هر عنصر در آرایه درست است و
240
00:09:34,880 –> 00:09:35,200
سپس
241
00:09:35,200 –> 00:09:37,519
اگر متوجه شدیم که تعدادی عدد اول نیست،
242
00:09:37,519 –> 00:09:40,480