@PythonForever

‫آموزش گام به گام‬

‫برنامه نویسی پایتون‬

‫تألیف‪:‬‬

‫دکتر جواد وحیدی (عضو هیات علمی دانشگاه علم و صنعت ایران)‬

‫دکتر رمضان عباس نژادورزی‬

‫‪@PythonForever‬‬
‌‫فنآوری‌نوین‬
‌

@PythonForever
 ‫‪:‬وحیدی‪ ،‬جواد‪- 6900 ،‬‬ ‫سرشناسه‬
‫تالیف‌جواد‌وحیدی‪‌،‬رمضان‌عباسنژادورزی‪‌.‬‬
‫‌‬ ‫نامهنویسی‌پایتون‪‌/‬‬
‫آموزش‌گام‌به‌گام‌بر ‌‬ ‫عنوان و نام پدیدآور‬

‫‪:‬بابل‪:‬فنآوری نوین‪6931 ٬‬‬ ‫مشخصات نشر‬

‫‫ ‪ 982:‬ص‫‪:‬مصور‪،‬جدول‬ ‫مشخصات ظاهری‬

‫ریال ‫‪7-27-7070-122-378 :‬‬

‫‫ ‪ 902222:‬‫‬ ‫شابک‬

‫‪:‬فیپا‬ ‫وضعیت فهرست نویسی‬

‫کتابنامه‪.‬‬ ‫‪:‬‬ ‫یاداشت‬

‫پیتون (زبان برنامهنویسی کامپیوتر ‫)‬ ‫‪:‬‬ ‫موضوع‬

‫‪Python (Computer program language):‬‬ ‫موضوع‬

‫پیتون (زبان برنامهنویسی کامپیوتر ‫) ‪ --‬مسائل‪ ،‬تمرینها و غیره‬ ‫‪:‬‬ ‫موضوع‬

‫‪.‬‬ ‫‪Python (Computer program language) -- Problems, exercises, etc‬‬ ‫‪:‬‬ ‫موضوع‬

‫عباسنژاد ورزی‪ ،‬رمضان‪- 69۳8 ،‬‬ ‫‪:‬‬ ‫شناسه افزوده‬

‫‫‬
‫‪6931‬‬ ‫‪71/79QA‬‫ ‪/‬پ‪30‬و‪9‬‬ ‫رده بندی کنگره‬

‫‫‪220/699‬‬ ‫رده بندی دیویی‬

‫‪‬ ۳882907‬‬ ‫شماره کتابشناسی ملی‬

‫‪www.fanavarienovin.net‬‬
‫بابل‪‌،‬کدپستی‌‪‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌38178-84337‬تلفن‪‌011-48867778‌:‬‬
‫‌‬ ‫فنآوری‌نوین‬
‫‌‬

‫آموزش گام به گام برنامه نویسی پایتون‬

‫تألیف‪ :‬جواد وحیدی‪ -‬رمضان عباس نژادورزی‬
‫نوبت چاپ‪ :‬چاپ اول‬
‫سال چاپ‪ :‬پاییز ‪6931‬‬
‫شمارگان‪022:‬‬
‫قیمت‪ 90222 :‬تومان‬
‫نام چاپخانه و صحافی‪:‬‬

‫‪@PythonForever‬‬
 ‫شابک‪378-122-7070-27-7 :‬‬
‫نشانی ناشر‪ :‬بابل‪ ،‬چهارراه نواب‪ ،‬کاظمبیگی‪ ،‬جنب مسجد منصور کاظمبیگی‪ ،‬طبقه همکف‬
‫طراح جلد‪ :‬کانون آگهی و تبلیغات آبان (احمد فرجی)‬
‫تلفکس‪:‬‬ ‫تهران‪ ،‬خ اردیبهشت‪ ،‬نبش وحید نظری‪ ،‬پالک ‪6۳0‬‬ ‫‪11۳226۳۳-11۳22002‬‬

‫‪@PythonForever‬‬
 ‫فهرست مطالب‬
‫فصل اول‪ :‬آشنایی با زبان پایتون‬
‫‪ .6 – 6‬مقدمهای بر زبان برنامه نویسی پایتون ‪3 ......................................................................................................................‬‬
‫‪ .6-0‬مقایسهی زبان برنامهنویسی پایتون با سایر زبانهای برنامهنویسی ‪66 ................................................................................‬‬
‫‪ .6-9‬از پایتون برای چه اپلیکیشنهایی میتوان استفاده کرد؟‪6۳ .....................................................................................................‬‬
‫‪ .6-۳‬آموزش زبانهای برنامهنویسی‪60 ..........................................................................................................................................‬‬
‫‪ .6-۳-6‬سطرها‪61 ..........................................................................................................................................................................‬‬
‫‪ .6-۳-0‬بالک بندی ‪67 ..................................................................................................................................................................‬‬
‫‪ .6-۳-9‬دستورات‪67‬‬
‫‪ .6-۳-۳‬شناسهها‪68 ........................................................................................................................................................................‬‬
‫‪ .6-۳-0‬متغیرها ‪63 ........................................................................................................................................................................‬‬
‫‪ .6-۳-1‬انتساب چندگانه ‪02 ..........................................................................................................................................................‬‬
‫‪ .6-0‬عملگرها ‪00 ...........................................................................................................................................................................‬‬
‫‪ .6-0-6‬عملگرهای محاسباتی ‪00 ..................................................................................................................................................‬‬
‫‪ .6-0-0‬عملگرهای رابطهای (مقایسهای) ‪09 ..........................................................................................................................‬‬
‫‪ .6-0-9‬عملگرهای ترکیبی ‪09 .......................................................................................................................................................‬‬
‫‪ .6-0-۳‬عملگرهای منطقی ‪09 .......................................................................................................................................................‬‬
‫‪ .6-0-0‬عملگرهای بیتی‪0۳ ............................................................................................................................................................‬‬
‫‪ .6-0-1‬اولویت عملگرها ‪01 ................................................................................................................................................‬‬
‫‪ .6-1‬انواع دادهها(اشیای آماده) ‪07 .................................................................................................................................................‬‬
‫‪ .6-1-6‬انواع دادههای عددی ‪07 ...................................................................................................................................................‬‬
‫‪ .6-1-0‬رشته ‪90 ............................................................................................................................................................................‬‬
‫‪ .6-7‬تبدیل نوع‪99 .........................................................................................................................................................................‬‬
‫‪ .6-8‬تابع )(‪9۳. ..................................................................................................................................................................... print‬‬
‫‪ .6-3‬تایپ‪ ،‬ذخیره و اجرای برنامه در پایتون ‪90 .............................................................................................................................‬‬
‫‪ .6-62‬خواندن داده ‪98 ..................................................................................................................................................................‬‬

‫‪@PythonForever‬‬
 ‫‪ .6-66‬مسائل حلشده‪۳7 ................................................................................................................................................................‬‬
‫فصل دوم‪ :‬ساختار تصمیم و تکرار‬
‫‪ .0-6‬ساختارهای تصمیمگیری ‪0۳ ..................................................................................................................................................‬‬
‫‪ .0-0‬ساختارهای تکرار‪12 ....................................................................................................................................................‬‬
‫‪ .0-0-6‬دستور ‪12 ......................................................................................................................................................... for‬‬
‫‪ .0-0-0‬دستور ‪11 ............................................................................................................................................................... while‬‬
‫‪ .0-9‬دستور ‪18 ................................................................................................................................................................. break‬‬
‫‪ .0-۳‬دستور ‪13 ............................................................................................................................................................. continue‬‬
‫‪ .0-0‬مسائل حل شده ‪70 ......................................................................................................................................................‬‬
‫فصل سوم‪ :‬توابع ‪..................... ................................ ................................ ................................‬‬
‫‪ .9 – 6‬انواع توابع ‪88 ............................................................................................................................................................‬‬
‫‪ .9 – 0‬توابعی که برنامه نویس مینویسد ‪88 ..........................................................................................................................‬‬
‫‪ .9 – 0 – 6‬نوشتن تابع ‪88 .....................................................................................................................................................‬‬
‫‪ .9 – 0 – 0‬فراخوانی تابع ‪32 .................................................................................................................................................‬‬
‫‪ .9 – 9‬ارسال پارامترها ‪3۳ .....................................................................................................................................................‬‬
‫‪ .9- 9 – 6‬ارسال پارامتر از طریق مقدار ‪3۳ ............................................................................................................................‬‬
‫‪ .9 – ۳‬آرگومانهای تابع‪33 ...........................................................................................................................................................‬‬
‫‪ .9 – ۳ – 6‬آرگومانهای اجباری‪33 .....................................................................................................................................‬‬
‫‪ .9 – ۳ – 0‬آرگومانهای کلمه کلیدی ‪33 ............................................................................................................................‬‬
‫‪ .9 – ۳ – 9‬آرگومانهای با مقدار پیش فرض ‪622 .................................................................................................................‬‬
‫‪ .9 – ۳ – ۳‬تعریف و فراخوانی توابع با تعداد پارامترهای متغیر‪620 ..................................................................................................‬‬
‫‪ .9 – 0‬توابع بی نام‪62۳ ....................................................................................................................................................................‬‬
‫‪ .9 – 1‬طول عمر و محدود حضور متغیرها ‪621 ................................................................................................................................‬‬

‫‪@PythonForever‬‬
‫‪ .9-7‬مسائل حل شده‪660 ................................................................................................................................................................‬‬
‫فصل چهارم‪ :‬آرایهها و بسته ‪............................................................................................ NUMPY‬‬
‫‪ .۳ – 6‬آرایههای یکبعدی ‪690 .............................................................................................................................................‬‬
‫‪ .۳-6-6‬تعریف آرایه ‪690 ...............................................................................................................................................................‬‬
‫‪ .۳-6-0‬دسترسی به عناصر آرایه ‪691 .............................................................................................................................................‬‬
‫‪ .۳-6-9‬مقداردهی به عناصر آرایه ‪697 ..................................................................................................................................‬‬
‫‪ .۳ – 6-۳‬نمایش عناصر آرایه ‪698 .........................................................................................................................................‬‬
‫‪ .۳ – 0‬تولید اعداد تصادفی ‪693 .............................................................................................................................................‬‬
‫‪ .۳ – 9‬مرتبسازی تعویضی ‪6۳0 ...........................................................................................................................................‬‬
‫‪ .۳ – ۳‬جستوجوی مقدار در آرایه ‪6۳۳ ................................................................................................................................‬‬
‫‪ .۳ – ۳ – 6‬جستوجوی خطی (ترتیبی) ‪6۳۳ .........................................................................................................................‬‬
‫‪ .۳ – ۳ – 0‬جستوجوی دودویی ‪6۳۳ ...................................................................................................................................‬‬
‫‪ .۳-0‬بسته ‪6۳8 ..................................................................................................................................................................NumPy‬‬
‫‪ .۳-0-6‬آرایههای ‪6۳3 ......................................................................................................................................................NumPy‬‬
‫‪ .۳-0-0‬ریاضیات در ‪611 ................................................................................................................................................. Numpy‬‬
‫‪ .۳-1‬آرایههای دوبعدی (ماتریس) ‪613 ..................................................................................................................................‬‬
‫‪ .۳-1-6‬تعریف آرایه دوبعدی ‪672 ........................................................................................................................................‬‬
‫‪ .۳ – 1-0‬مقداردهی به عناصر آرایه دوبعدی ‪672 .................................................................................................................‬‬
‫‪ .۳-1-9‬نمایش مقادیر عناصر آرایه دوبعدی ‪676 ..................................................................................................................‬‬
‫‪ .۳-1-۳‬کار با ماتریس از طریق ‪676 ..................................................................................................................................numpy‬‬
‫‪ .۳-1-0‬جبر خطی در ‪671 .................................................................................................................................................numpy‬‬
‫‪ .۳-7‬مسائل حل شده‪682 ................................................................................................................................................................‬‬
‫فصل پنجم‪ :‬رشتهها ‪................... ................................ ................................ ................................‬‬

‫‪@PythonForever‬‬
‫‪ .0-6‬عملگرهای رشتهای‪630 ..........................................................................................................................................................‬‬
‫‪ .0-0‬متدهای کار بر روی رشته ‪022 ................................................................................................................................................‬‬
‫‪ .0-9‬کاربرد سه کتیشن (""")‪020 ..................................................................................................................................................‬‬
‫‪ .0-۳‬نمایش کاراکتر \‪020 ..............................................................................................................................................................‬‬
‫‪ .0-0‬رشتههای یونیکد ‪028 ...................................................................................................................................................‬‬
‫‪.0-1‬مسائل حل شده ‪023 .......................................................................................................................................................‬‬
‫فصل ششم‪ :‬لیستها‪ ،‬چندتاییها‪ ،‬دیکشنریها و مجموعهها‬
‫‪ .1-6‬لیستها ‪001 .....................................................................................................................................................................‬‬
‫‪ .1-6-6‬عملگرهای کار بر روی لیست‪007 ...............................................................................................................................‬‬
‫‪ .1-6-0‬متدهای کار با لیست ‪098 ............................................................................................................................................‬‬
‫‪ .1-0‬تاپل (چندتایی) ‪0۳2 .........................................................................................................................................................‬‬
‫‪ .1-9‬دیکشنری‪0۳9 ..................................................................................................................................................................‬‬
‫‪ .1-9-6‬عملیات بر روی دیکشنری ‪0۳1 ...................................................................................................................................‬‬
‫‪ .1-9-0‬کاربرد ‪ for‬برای پیمایش دیکشنری‪006 .......................................................................................................................‬‬
‫‪ .1-۳‬مجموعهها ‪001 ................................................................................................................................................................‬‬
‫‪ .1-۳-6‬عملگرهای مجموعه ‪007 .............................................................................................................................................‬‬
‫‪ .1-۳-0‬متدهای مجموعه ‪016 ..................................................................................................................................................‬‬
‫‪ .1-۳-9‬نوع ‪011 ....................................................................................................................................................frozenset‬‬
‫‪ .1-0‬مسائل حل شده ‪018 .........................................................................................................................................................‬‬
‫فصل هفتم‪ :‬کالسها و وراثت ‪........................................ ................................ ................................‬‬
‫‪ .7 – 6‬کالسها ‪079 ..............................................................................................................................................................‬‬
‫‪ .7 – 6 – 6‬تعریف کالسها‪07۳ .....................................................................................................................................................‬‬
‫‪ .7 – 6 – 0‬نمونهسازی کالسها‪070 ...............................................................................................................................................‬‬

‫‪@PythonForever‬‬
‫‪ .7 – 0‬اعضای کالس ‪070 .....................................................................................................................................................‬‬
‫‪ .7 – 0-6‬دسترسی به اعضای کالس ‪071 ...............................................................................................................................‬‬
‫‪ .7 – 0-0‬انواع اعضای کالس ‪071 ........................................................................................................................................‬‬
‫‪ .7 – 9‬سازندهها و مخربها ‪078 .....................................................................................................................................................‬‬
‫‪ .7 – ۳‬وراثت و چندریختی‪081 ......................................................................................................................................................‬‬
‫‪ .7 – 0‬وراثت‪087 ...........................................................................................................................................................................‬‬
‫‪ .7 – 1‬تشخیص کالس پایه و مشتق‪083 ..........................................................................................................................................‬‬
‫‪ .7 –7‬تعریف کالس مشتق‪083 .......................................................................................................................................................‬‬
‫‪ .7 – 8‬سازندهها و مخربها در کالسهای مشتق ‪032 .....................................................................................................................‬‬
‫‪ .7 – 3‬پیادهسازی مجدد عملگرها ‪039 ............................................................................................................................................‬‬
‫‪ .7 – 62‬مسائل حل شده ‪926 ...........................................................................................................................................................‬‬
‫فصل هشتم‪ :‬فایلها‬
‫‪ .8- 6‬باز کردن فایل ‪969 ..........................................................................................................................................................‬‬

‫پیوست‪ :‬مسائل تکمیلی ‪998 ....................................................................................................................................................‬‬

‫منابع‪982‌.............................................................................................................................................................‌:‬‬

‫‪@PythonForever‬‬
 ‫مقدمه‬
‫هرگز به آنقدر که میپری قانع نباش ‪.‬‬
‫هرگز نگو بیشتر از این ممکن نیست‪.‬‬
‫دائم از خودت عبور کن!‬
‫شاگردی که کمتر از معلمش بداند‪،‬‬
‫دنیا را به عقب میراند‪،‬‬
‫شاگردی که به قدر معلمش بداند دنیا را متوقف میکند‪.‬‬
‫این تویی که پیش میرانی‪...‬‬

‫عصر حاضر از نظر بسیاری از روشنفکران انقالب ارتباطات و اطالعات نام گرفته است‪.‬‬
‫در واقع کلیه کارهای روزمرهی انسان با سیستم های ارتباطی نوین و فناوری اطالعات گره‬
‫خورده است‪ .‬لذا اهمیت علم کامپیوتر به عنوان نمود اصلی فناوری اطالعات و ارتباطات بر‬
‫کسی پوشیده نیست‪ .‬در دنیای مدرن امروز تسلط و آشنایی با نحوه کار با سیستم های‬
‫کامپیوتری به عنوان یک سطح سواد مطلوب در جامعه شناخته می شود که اگر کسی آن را‬
‫نداشته باشد باید بهای عدم آشنایی با دنیای کامپیوتر در زندگی روزمره خویش با مراجعه به‬
‫کافی نت ها‪ ،‬درخواست های الکترونیکی و موارد دیگر بپردازد‪.‬‬
‫بدون شک‪ ،‬برنامه نویسی یکی از مهمترین مهارتهایی است که امروزه نه تنها برای‬
‫فارغ التحصیالن و دانشجویان رشته مهندسی کامپیوتر‪ ،‬بلکه برای سایر رشتهها و زمینهها نیز‬
‫به شکل ضروری‪ ،‬مورد نیاز است‪ .‬هر ساله‪ ،‬بر تعداد موقعیتهای شغلی که مرتبط با‬
‫برنامهنویسی هستند و یا پیشنیاز اصلی آنها برنامهنویسی است‪ ،‬افزوده میشود‪ .‬از طرفی‪،‬‬
‫بخشی جدا نشدنی از فرآیند تحقیق و پژوهش در اکثر رشتههای دانشگاهی امروزی‪ ،‬کار با‬

‫‪@PythonForever‬‬
 ‫‪ 01‬فصل اول‬

‫کامپیوتر و توانایی پیادهسازی ایدهها و الگوریتمها در قالب برنامههای کامپیوتری است‪.‬‬

‫قطعا در این مسیر‪ ،‬دانشجویان نیازمند یادگیری و کسب مهارتهای برنامهنویسی هستند‪.‬‬

‫پایتون یک زبان برنامهنویسی همه منظوره‪ ،‬سطح باال‪ ،‬شیءگرا و مفسر است که توسط‬
‫خودو فان روسوم در سال ‪ 6336‬در کشور هلند طراحی شد‪ .‬فلسفه ایجاد آن تأکید بر دو‬
‫هدف اصلی خوانایی باالی برنامههای نوشته شده و کوتاهی و بازدهی نسبی باالی آن است‪.‬‬
‫کلمات کلیدی و اصلی این زبان به صورت حداقلی تهیه شدهاند و در مقابل کتابخانههایی‬
‫که در اختیار کاربر است بسیار وسیع هستند‪.‬‬
‫علی رغم استقبال گسترده دانش پژوهان عرصه کامپیوتر از زبان پایتون ‪ ،‬در زمینه آموزش‬
‫این زبان قدرتمند کتاب های زیادی به زبان فارسی منتشر نشده است که کتاب حاضر برای‬
‫پر کردن خالء موجود در زمینه نوشته شده و توسط انتشارات فن آوری های نوین به زیور‬
‫چاپ آراسته شده است‪ .‬امید است اثر حاضر همانند سایر آثار مولفین مورد استقبال قرار‬
‫گیرد‪.‬‬
‫از تمامی اساتید و دانشجویان عزیز تقاضا داریم‪ ،‬هر گونه اشکال‪ ،‬ابهام در متن کتاب‪،‬‬
‫پیشنهاد و انتقادات را به آدرس پستالکترونیک ‪‌[email protected]‬‬
‫ارسال نمایند‪‌‌.‬‬

‫مولفین‬
‫‪[email protected]‬‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪00‬‬

‫فصل‬
‫آشنایی با زبان پایتون‬
‫‪1‬‬
‫‌‬

‫‪ .-1 1‬مقدمهای بر زبان برنامه نویسی پایتون‬

‫پایتون یکی از معدود زبانهای برنامهنویسی است که میتوان ادعا کرد ساختاری سااده و قدرتمناد‬
‫دارد‪ ،‬ازاینرو‪ ،‬یادگیری این زبان همواره به افراد مبتدی که شاید هیچ تجربهای در برنامهنویسی نداشاته‬
‫باشند‪ ،‬توصیه میشود و از طرف دیگر‪ ،‬استفاده از این زبان برای حل مسائل مختلف و پیچیاده انتخااب‬
‫اول بسیاری از برنامه نویسان حرفهای بوده است‪.‬‬
‫بر اساس رتبهبندی سایت‫‪ ،Tiobe‬زبان برنامهنویسی ‪ Python‬در سپتامبر سال ‪ 0260‬با سه پلاه صاعود‬
‫نسبت به زمان مشابه در سال قبل در جایگاه پنجم قرارگرفته است که نشاندهندهی رشد محبوبیات ایان‬
‫زبان در میان برنامه نویسان سراسر دنیا است‪.‬‬
‫همانطور که میدانید هر زبان برنامهنویسی ویژگیها و قابلیتهای خاص خود را دارد کاه آن را از‬
‫سایر زبانها متمایز میسازد و علت شکلگیری زبانهای مختلف نیز پاسخگویی به نیازهاای متفااوت و‬
‫متنوع کاربران با استفاده از همین قابلیتهای متمایز است‪ .‬به همین دلیل‪ ،‬پیش از شروع به یادگیری هار‬
‫زبان ابتدا باید نیازها و هدف خود را از یادگیری آن‫زبان در کنار قابلیتهایش قرار دهیم و در صورت‬
‫تطبیق آنها باهم‪ ،‬قدم درراه یادگیری بگذاریم‪ .‬بنابراین‪ ،‬برای آشنایی بیشتر با زبان پایتون‪ ،‬در ادامه به‬
‫معرفی برخی از ویژگیها و قابلیتهای آن میپردازیم‪:‬‬
‫‪ .1‬سادگی‌و‌صراحت‪:1‬‫پایتون یکزبان ساده و کمینهگرا اسات‪ .‬وقتای نگااهی باه ساورس کاد یاک‬
‫برنامهی‫نوشتهشده به زبان پایتون بیاندازیم‪ ،‬احساس میکنیم که با یاک ماتن انگلیسای صاریح مواجاه‬
‫هستیم‪ .‬شاید بتوان گفت این بزرگترین نقطهی قوت پایتون است که بهجای درگیر کردن برنامهنویس‬

‫‪1‬‬ ‫‪2‬‬
‫‪. Simplicity‬‬ ‫‪. Low Learning Curve‬‬

‫‪@PythonForever‬‬
 ‫‪ 01‬فصل اول‬

‫به جزئیات زبان به او اجازه میدهد تا روی حل مسئله تمرکز داشته باشاد‪ .‬هماین موضاوع سارعت کاد‬
‫نویسی و خوانایی این زبان را هم افزایش داده است‪.‬‬
‫‪ .2‬منحنی‌یادگیری‌کم‌شیب‪:8‬‫قطعاً عامل اصلی این موضوع که یادگیری پایتون بهعنوان‫ قادم اول باه‬
‫مشتاقان برنامهنویسی و حتی کودکان توصیه میشود سینتکس فوقالعاده ساادهی آن اسات‪ .‬هماانطاور‬
‫که گفتیم صراحت زبان پایتون نهتنها خوانایی آن را افزایش داده اسات‪ ،‬بلکاه باا حاذف پیچیادگیهاا‬
‫سهولت یادگیری آن را نیز بیشتر کرده است‪.‬‬
‫‪ .3‬رایگان‌و‌متن‌باز‌بودن‪:1‬‫توزیعهای مختلف زبان برناماهنویسای پاایتون کاامالً رایگاان‫ باوده‫و هار‬
‫برنامااهنااویس ماایتوانااد سااورس کااد آن را بخوانااد‪ ،‬آن را تغییاار دهااد‪ ،‬و در برنامااههااای خااود از‬
‫اسکریپتهای‫آن استفاده کند‪.‬‬
‫‪ .4‬سطح‌باال‌بودن‪:8‬‫پایتون ازجمله زباانهاای قدرتمناد ساطح بااال اسات کاه برناماهناویس را درگیار‬
‫جزئیات سطح پایین مثل مدیریت حافظه یا کار با ثباتها (‪ )Registerss‬و غیره نمیکند‪.‬‬
‫‪ .5‬قابل‌حمل‌بودن‪:3‬‫ماهیت متنباز پایتون موجب شده اسات کاه ایان زباان باا پلتفارمهاای مختلاف‬
‫سازگار باشد‪ .‬بنا بر اعاالم رسامی ساایت پاایتون‪ ،‬در حاال حاضار ایان زباان روی ‪06‬‫پلتفارم ازجملاه‬
‫‪ ،iOS ،Android ،Solaris ،Macintosh ،GNU/Linux ،Windows‬و ‪ ...‬کااار ماایکنااد و برنامااههااای‬
‫نوشتهشده به این زبان بدون نیاز به تغییر یا با تغییرات بسیار جزئی روی تمام پلتفرمها اجرا میشوند‪.‬‬
‫‪ .6‬زبانی‌مفسری‪:3‬‫برخالف زبانهای کامپایلری مانند ‪ C‬یا جاوا‪ ،‬زبان برناماهنویسای پاایتون یاکزباان‬
‫مفسری است و سورس کد برنامههای نوشتهشده به این زبان با استفاده از یک مفسر اجرا مایشاود کاه‬
‫همین موضوع قابل حمل بودن آن را افزایش میدهد‪.‬‬
‫‪ .7‬شیءگرایی‪:6‬‫پایتون در مقایسه با زبانهایی مانند جااوا یاا ‪،C++‬‫روش قدرتمنادتر و‫ساادهتاری را‬
‫برای اجرا برنامههای شیءگرا به کار میگیرد‪.‬‬
‫‪ .8‬توسعه‌پذیری‪:7‬‫یکی از مشکالت زبان مفسری پاایتون سارعتپاایین اجارا در مقایساه باا زباانهاای‬
‫کامپایلری مانند ‪ C‬یا جاوا است‪ .‬حال اگر بخواهید قطعهای از کدها سریعتر اجرا شود یا اگر بخواهیاد‬

‫‪1‬‬ ‫‪2‬‬ ‫‪3.‬‬ ‫‪4‬‬

‫‪. Free & Open Source‬‬ ‫‪. High-level‬‬ ‫‪Portable‬‬ ‫‪. Interpreted‬‬
‫‪5‬‬ ‫‪6‬‬ ‫‪7‬‬
‫‪. Object Oriented‬‬ ‫‪. Extensible‬‬ ‫‪. Embeddable‬‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪01‬‬

‫بخشی از الگوریتم برنامهی خود را پنهان کنید میتوانید آن بخش را به زبان ‪ C++ ،C‬یا جاوا‫بنویساید‬
‫و آن را در میان کدهای پایتون برنامهی خود قرار دهید‪.‬‬
‫‪ .9‬تعبیهپذیری‪:8‬‫عالوه بر اینکه میتوان کدهای زبانهای دیگر را در برنامههای نوشتهشده باه زباان‫‬
‫پایتون قرار داد‪ ،‬میتوان قطعه کدهایی را به زبان پایتون نوشت و در سورس کد برنامههای ‪ C++ ،C‬یا‬
‫جاوا نشاند و به این ترتیب قابلیتهای اسکریپتی به سورس کد مدنظر اضافه نمود‪.‬‬
‫‪:‬‫پااایتون از یااک کتابخانااهی اسااتاندارد غناای بهااره مایباارد و در کنااار ایاان‬ ‫‪ .01‬کتابخانههه‌ی‌گسههترد‬

‫کتابخانهی وسیع‪،‬‫کتابخانه هاای ساایر توساعهدهنادگان‫نیاز باه سارعت درحاالتوساعه مایباشاند کاه‬
‫درمجموع ابزارهای مناسبی را برای ایجاد اسناد‪ ،‬رابط های گرافیکی کاربر (‪ ،)GUI‬مرورگرهاای وب‪،‬‬
‫رمزنگاری‪ ،‬هوش مصنوعی‪ ،‬پست الکترونیکی‪ ،‬بازیسازی‪ ،‬دادهکاوی‪ ،‬ایجاد و مادیریت وبساایت‪،‬‬
‫و بسیاری کاربردهای دیگر در اختیار برنامه نویسان قرار میدهد‪.‬‬
‫‌بودن‪:1‬‫پایتون یکزبان برنامهنویسی با طیف گستردهای از کاربردها اسات کاه‫ در‬ ‫‪ .11‬همه‌منظور‬

‫حوزههای مختلف و متنوع کاربرد داشته است کاه ازجملاه مهامتارین کاربردهاای آن در طای ساالیان‬
‫گذشته میتوان به موارد زیر اشاره کرد‪:‬‬
‫موتور جستجوگر گوگل و موتور گرافیکی یوتیوب‬
‫ساخت برنامههای کاربردی علمی در سازمان فضایی ناسا‪Fermilab ،‬‬

‫بخشی از سرویس ایمیل یاهو‬

‫تست سختافزار در ‪Cisco،Intel ،IBM‬‫‬
‫ابزارهای نصب لینوکس در نسخهی ‪Redhat‬‬

‫سرویس ابری ‪Dropbox‬‬

‫و بسیاری کاربردهای دیگر نظیر طراحای ساایتهاای دینامیاک‪ ،‬تولیاد نارمافزارهاای دساکتاپ‪،‬‬
‫انیمیشنسازی‪ ،‬بازیسازی‪ ،‬شبکه‪ ،‬امنیات‪ ،‬پایگااه داده‪ ،‬دادهکااوی‪ ،‬سااخت برناماههاای محاساباتی و‬
‫کاربردی در رشتههای مختلف نظیر ریاضی‪ ،‬فیزیکی‪ ،‬آمار‪ ،‬زیست و غیره‪.‬‬

‫‪1‬‬
‫‪. General-Purpose‬‬

‫‪@PythonForever‬‬
 ‫‪ 01‬فصل اول‬

‫درنهایت میتوان گفت که پایتون ابزاری مهیج و قدرتمند در اختیار برنامه نویسان است که کاار باا‬
‫آن ساده و سرگرمکننده میباشد و تسلط بر آن کاربران را وارد دنیایی شگفتانگیز و بینهایت میکند‬
‫که هرکس میتواند متناسب با تواناییهایش از امکانات آن برای حل مسائل خود بهرهمند شود‪.‬‬

‫‪ .1-4-1‬سطرها‬
‫مفسر پایتون و همچنین کااربران‪ ،‬کادهای درون هار ماالول را باهصاورت تعادادی ساطر مشااهده‬
‫ههی‪ ،6‬سااطرهایی هسااتند کااه توسااط‬ ‫ماایکننااد‪ .‬در پاایتون دو نااوع سااطر وجااود دارنااد‪ .6 .‬سههطرهای‌فیکی‬

‫ویرایشگرهای متن شمارهگذاری میشوند و بهسادگی توسط کاربر قابلتشخیص میباشند‪ .0 .‬سهطرهای‌‬

‫منطقی‪ ،0‬برداشت مفسر از اجرای برنامه است‪ .‬هر سطر بیانگر یک دستور پایتون اسات‪ .‬باهعناوانمثاال‪،‬‬
‫دستورات زیر را در نظر بگیرید‪:‬‬
‫"‪>>> name = "Fanavarienovin.net‬‬
‫)‪>>> print(name‬‬
‫دسااتور اول رشااته ‪ fanavarienovin.net‬را بااه متغیاار ‪ name‬نساابت ماایدهااد و دسااتور دوم‪ ،‬عبااارت‬
‫‪ fanavarienovin.net‬را نمایش میدهد‪ .‬در این دستورات‪ ،‬هر سطر منطقی یاک ساطر فیزیکای در نظار‬
‫گرفتهشده است‪ .‬با اجرای این دستورات خروجی زیر نمایش داده میشود‪:‬‬
‫‪Fanavarienovin.net‬‬
‫گاهی اوقات هر سطر فیزیکی می تواند شاامل چناد ساطر منطقای باشاد‪ .‬در ایان حالات‪ ،‬بایاد باین‬
‫سطرها‪ ،‬کاراکتر ”;“ قرار داد‪ .‬بهعنوانمثال‪ ،‬دستورات زیر را ببینید‪:‬‬
‫)‪>>> name = "Fanavarienovin.net"; print(name‬‬

‫با اجرای این دستورات نیز خروجی زیر نمایش داده میشود‪:‬‬
‫‪Fanavarienovin.net‬‬
‫گاهی اوقات برای خوانایی بیشتر بهتر است دستورات یاک ساطر منطقای در چناد ساطر فیزیکای‬
‫تایپ شود؛ بهعنوانمثال‪ ،‬دستورات زیر را مشاهده کنید‪:‬‬
‫\ ‪>>> message ="Python is a‬‬
‫"‪good programing language‬‬
‫)‪>>> print(message‬‬

‫‪1‬‬ ‫‪2‬‬
‫‪. Physical Lines‬‬ ‫‪. Logical Lines‬‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪01‬‬

‫در این مثال‪ ،‬خطوط اول و دوم یک دستور منطقی هستند کاه در دو ساطر آمادهاناد‪ .‬بارای توساعه‬
‫یک دستور در چند سطر فیزیکی از کاراکتر ”\“ استفاده میشود‪‬.‬با اجرای این دستورات خروجی زیار‬
‫نمایش داده میشود‪:‬‬
‫‪‬Python is a good programing language‬‬
‫تعداد کاراکترهای هر سطر فیزیکی نباید از ‪ 73‬کاراکتر بیشتر شود‪.‬‬
‫سطرهای‌خالی‪ ،6‬برای افزایش خوانایی برنامه به کار میروند که شامل فضای خالی (‪ Space‬یاا ‪)Tab‬‬
‫هستند و توسط مفسر نادیده گرفته میشوند و به بایت کد ترجمه نمیگردند‪.‬‬

‫‪ .1-4-2‬بالک بندی‬
‫بالک‌بندی‪ ،‬یکی از امکاناتی است که برای افزایش خوانایی کاد پاایتون باه کاار مایرود‪ .‬در زباان‬
‫پایتون برای ایجاد بالک از تورفتگی‪ 0‬سطرها استفاده مایشاود‪ .‬درواقاع‪ ،‬تاورفتگی میازان فضاای خاالی‬
‫(‪ Space‬یا ‪ )Tab‬است که در ابتدای هر سطر فیزیکی قرار مایگیارد‪ .‬تماام دساتورات موجاود در یاک‬
‫بالک باید به یک میزان نسبت به سرآیند خود تورفتگی داشته باشند‪ .‬یعنای‪ ،‬تعاداد فضاای خاالی تماام‬
‫دستورات آن بالک نسبت به سرآیند یکای باشاد‪ .‬شاکل‪ 6 – 6‬نموناهای از ایان باالک بنادی را نشاان‬
‫میدهد‪.‬‬
‫‪Block 1‬‬
‫]‪items = [5, 8, 1, 6, 7, 3, 4, 2, 9, 0‬‬
‫‪Header:‬‬
‫‪Block 2‬‬ ‫‪def bubble_sort(seq):‬‬
‫‪Header:‬‬
‫)‪l=len(seq‬‬
‫‪Block 3‬‬
‫‪Header:‬‬ ‫‪for i in range(l):‬‬
‫‪Block 4‬‬
‫‪Header:‬‬ ‫‪for n in range(1, l):‬‬
‫‪Block 5‬‬ ‫‪if seq[n] < seq [n-1]:‬‬
‫]‪seq[n-1], seq[n] = seq [n], seq[n-1‬‬
‫‪Block 2‬‬ ‫‪return seq‬‬
‫))‪print (bubble_sort(items‬‬
‫‪Block 1‬‬

‫بالکبندی در پایتون‪.‬‬ ‫شکل ‪1 – 1‬‬

‫برای ایجاد هر تورفتگی از چهار جای خالی(کلید ‪ )Space‬استفاده کنید‪.‬‬

‫هرگز برای تورفتگی از کلیدهای ‪ Space‬و ‪ Tab‬باهم استفاده نکنید‬

‫‪1‬‬ ‫‪2‬‬
‫‪. Blank Lines‬‬ ‫‪. Indentation‬‬

‫‪@PythonForever‬‬
 ‫‪ 01‬فصل اول‬

‫‪ .1-5-4‬عملگرهای منطقی‬
‫عملگرهای منطقی‪ ،‬بر روی عبارات منطقی درست یا نادرسات عمال مایکنناد‪ .‬نتیجاه عملگرهاای‬
‫(و‬ ‫‪ 6- 1‬میبینید‪ ،‬زمانی نتیجه عملگار ‪and‬‬ ‫منطقی در جدول ‪ 6- 1‬آمده است‪ .‬همانطور که در جدول‬
‫منطقی) درست است که هر دو عملوند نتیجه درسات داشاته باشاند‪ .‬اماا نتیجاه عملگار ‪( or‬یاا منطقای)‬
‫هنگامی نادرست است که هردو عملوند نادرست باشند‪ .‬عملگر ‪ ،not‬نتیجه درست را نادرسات و نتیجاه‬
‫نادرست را به درست تبدیل میکند‪.‬‬
‫اکنون دستورات زیر را ببینید‪.‬‬
‫‪>>> x = true‬‬
‫‪>>> y = false‬‬
‫‪>>> z1 = x and y‬‬
‫‪>>> z2 = x or y‬‬
‫‪>>> z3 = not y‬‬
‫دستور اول شیء ‪ true‬و ‪ x‬را تعریف کرده‪ True ،‬را به ‪ x‬پیوناد مایدهاد‪ ،‬دساتور دوم‪ ،‬اشایاء ‪ y‬و‬
‫‪ False‬را ایجاد کرده‪ ،‬بین ‪ y‬و ‪ false‬پیوند برقرار میکند‪ ،‬دستور ساوم‪ ،‬نتیجاه ‪( x and y‬یعنای ‪ )false‬را‬
‫قرار میدهاد و‬ ‫‪( x or y‬یعنی ‪ )true‬را در ‪z2‬‬ ‫در شیء ایجادشده ‪ z1‬قرار میدهد‪ ،‬دستور چهارم‪ ،‬نتیجه‬
‫قرار میدهد‪.‬‬ ‫دستور پنجم‪( not y ،‬یعنی ‪ )true‬را در ‪z3‬‬

‫جدول‌‪‌1‌–‌3‬عملگرهای‌رابطهای‌(مقایسهای)‪‌.‬‬
‫توضیحات‌‬ ‫نتیجه‌‬ ‫مثال‌‬ ‫نام‌‬ ‫عملگر‌‬

‫اگر عملوند اول بزرگتر از عملوند دوم باشد‪ ،‬نتیجه درست اسات‪،‬‬ ‫‪False‬‬ ‫‪0<9‬‬ ‫بزرگتر‬ ‫>‬

‫وگرنه نتیجه نادرست میباشد‪.‬‬

‫اگر عملوند اول بزرگتر یا مساوی عملوند دوم باشد‪ ،‬نتیجه درست‬ ‫‪True‬‬ ‫‪0 <= 9‬‬ ‫بزرگتر‬ ‫=>‬

‫است‪ ،‬وگرنه‪ ،‬نتیجه نادرست میباشد‪.‬‬ ‫یا مساوی‬

‫اگر عملوناد اول کوچاکتار از عملوناد دوم باشاد‪ ،‬نتیجاه درسات‬ ‫‪True‬‬ ‫‪0>7‬‬ ‫کوچکتر‬ ‫<‬

‫است‪ ،‬وگرنه نتیجه نادرست است‪.‬‬

‫اگر عملوند اول کوچاکتار یاا مسااوی عملوناد دوم باشاد‪ ،‬نتیجاه‬ ‫‪Talse‬‬ ‫‪0 >= 9‬‬ ‫کوچکتر‬ ‫=<‬

‫درست است‪ ،‬وگرنه نتیجه نادرست خواهد شد‪.‬‬ ‫یا مساوی‬

‫اگر عملوند اول مخاالف عملوناد دوم باشاد‪ ،‬نتیجاه درسات اسات‪،‬‬ ‫‪True‬‬ ‫‪0 != 0‬‬ ‫نامساوی‬ ‫<>‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪01‬‬

‫وگرنه‪ ،‬نتیجه نادرست خواهد بود‪.‬‬ ‫یا‬

‫=!‬
‫اگر عملوند اول مسااوی عملوناد دوم باشاد‪ ،‬نتیجاه درسات اسات‪،‬‬ ‫‪Talse‬‬ ‫‪0 == 9‬‬ ‫تساوی‬ ‫==‬

‫وگرنه نتیجه نادرست خواهد شد‪.‬‬

‫عملگرهای‌ترکیبی‪‌.‬‬
‫‌‬ ‫جدول‪‌1-6‬‬
‫عمل رد‌‬ ‫نتیجه‌‬ ‫مثال‌‬ ‫روش‌استفاد ‌‬ ‫عملگر‌‬
‫‪x =x + y‬‬ ‫‪8‬‬ ‫‪x = 3; x += 5‬‬ ‫‪x += y‬‬ ‫=‪+‬‬

‫‪x=x-y‬‬ ‫‪۳‬‬ ‫‪x = 7; x -= 3‬‬ ‫‪x -= y‬‬ ‫=‪-‬‬

‫‪x=x*y‬‬ ‫‪60‬‬ ‫‪x = 3; x *= 5‬‬ ‫‪x *= y‬‬ ‫=*‬

‫‪x=x/y‬‬ ‫‪9.۳‬‬ ‫‪x = 17; x /=5‬‬ ‫‪x /= y‬‬ ‫=‪/‬‬

‫‪x=x%y‬‬ ‫‪0‬‬ ‫‪x = 17; x %=5‬‬ ‫‪x %= y‬‬ ‫=‪%‬‬

‫‪x = x**y‬‬ ‫‪3‬‬ ‫‪x=3; x **=2‬‬ ‫‪x **= y‬‬ ‫=**‬

‫‪x = x//y‬‬ ‫‪0.2‬‬ ‫‪x=17; x//=3‬‬ ‫‪x //= y‬‬ ‫=‪//‬‬

‫جدول‌‪‌1-7‬عمل رد‌عملگر‌های‌منطقی‪‌.‬‬

‫‪not y‬‬ ‫‪‌not x‬‬ ‫‪‌x or y‬‬ ‫‪x and y‬‬ ‫‪x‬‬ ‫‪Y‬‬
‫‪True‬‬ ‫‪True‬‬ ‫‪False‬‬ ‫‪False‬‬ ‫‪False‬‬ ‫‪False‬‬
‫‪False‬‬ ‫‪True‬‬ ‫‪True‬‬ ‫‪False‬‬ ‫‪False‬‬ ‫‪True‬‬
‫‪True‬‬ ‫‪False‬‬ ‫‪True‬‬ ‫‪False‬‬ ‫‪True‬‬ ‫‪False‬‬
‫‪False‬‬ ‫‪False‬‬ ‫‪True‬‬ ‫‪True‬‬ ‫‪True‬‬ ‫‪True‬‬

‫‪ .1-5-5‬عملگرهای بیتی‬
‫عملگرهای بیتای‪ ،‬عملگرهاایای کاه بار روی بیاتهاای داده کاار مایکنناد و مایتوانناد آنهاا را‬
‫دستکاری کنند‪ ،‬برخی از این عملگرها عبارتاند از‪:‬‬

‫‪ .6‬عملگر‌&‪"‌،‬و"‌بیتی را انجام مایدهاد‪ .‬ایان عملگار‪ ،‬دو عملوناد را بیات باه بیات بااهم "و"‌بیتهی‌‬

‫مینماید (نتیجه و بیتی زمانی یک است که هر دو بیت ‪ 6‬باشند)‪ .‬بهعنوانمثال‪ ،‬دستورات زیر را ببینید‪:‬‬
‫‪>>> a, b = 3, 2‬‬
‫‪>>> z = a & b‬‬
‫‪a= 00000011‬‬
‫‪b=00000010‬‬
‫===========‬

‫‪@PythonForever‬‬
 ‫‪ 01‬فصل اول‬

‫‪z = 00000010‬‬
‫پس ‪ z‬برابر با ‪ 2‬میشود‪.‬‬

‫‪ .0‬عملگر|‪"‌،‬یا" بیتی را انجام میدهد‪ .‬این عملگر‪ ،‬دو عملوند را بیت به بیت بااهم "یا‌بیتهی‌" نماوده‬
‫(نتیجه یا بیتی زمانی صفر است که هر دو بیت ‪ 2‬باشند)‪ .‬بهعنوانمثال‪ ،‬دستورات زیر را ببینید‪:‬‬
‫‪>>> a, b = 3, 2‬‬
‫‪>>> z = a | b‬‬
‫‪a= 00000011‬‬
‫‪b=00000010‬‬
‫===========‬
‫‪z = 00000011‬‬
‫پس‬‪‬ z‬برابر ‪ 3‬خواهد شد‪.‬‬
‫‪ .9‬عملگر^‪(‌xor‌،‬یا‌انحصاری) بیتی‌را انجام میدهد‪ .‬این عملگر دو عملوند را بیت به بیت (بیتهاای‬
‫متناظر) را باهم یا انحصاری میکند (نتیجه یا انحصاری زمانی یک است که دو بیات مخاالف یکادیگر‬
‫باشند)‪ .‬بهعنوانمثال‪ ،‬دستورات زیر را ببینید‪:‬‬
‫‪7, 2‬‫= ‪>>> a, b‬‬
‫‪= a ^ b‬‫‪>>> z‬‬
‫‪a= 00000111‬‬
‫‪b=00000010‬‬
‫===========‬
‫‪z = 00000101‬‬
‫‪ .۳‬عملگر~‪‌‌،‬نقیض‌بیتی است‪ .‬این عملکر قبل از یک عملوند قرارگرفته‪ ،‬تمام بیتهای ‪ 1‬آن را باه ‪0‬‬

‫و تمام بیتهای ‪ 0‬را به ‪ 1‬تبدیل میکند‪ .‬بهعنوانمثال‪ ،‬دستورات زیر را مشاهده کنید‪:‬‬
‫‪= 10‬‫‪>>> a‬‬
‫‪~ a‬‫=‫‪b‬‫>>>‬
‫‪a= 00001010‬‬
‫‪b=11110101‬‬
‫‪ .0‬عملگر‌>>‪‌،‬شیفت‌به‌چپ را انجام میدهد‪.‬این عملگر بین دو عملوند قارارگرفتاه و مقادار عملوناد‬
‫سمت چپ را به تعداد عملوند سمت راست به سمت چپ شیفت میدهد‪ .‬بهعنوانمثال‪ ،‬دستورات زیر‬
‫را ببینید‪:‬‬
‫‪2, 3‬‫= ‪>>> a, b‬‬
‫‪b‬‫<<‫‪= a‬‫‪>>>z‬‬
‫‪a= 00000010‬‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪01‬‬

‫‪b=3‬‬
‫‪---------------------‬‬
‫‪z = 00010000‬‬
‫همانطور که مشاهده میشود‪ z ،‬برابر با ‪ 61‬است‪ .‬یعنی‪ ،‬با هر شیفت به چپ‪ ،‬مقادار ‪ a‬در ‪ 0‬ضارب‬
‫میشود و در ‪ z‬قرار میگیرد‪ .‬پس مقدار ‪ a‬در ‪ 8‬ضرب شده (‪ )0 * 09‬تا ‪ 61‬به دست آماده‪ ،‬در ‪ z‬قارار‬
‫میگیرد‪.‬‬
‫‪ .1‬عملگر<<‪ ،‬شیفت‌به‌سمت‌راست را انجام میدهد‪ .‬ایان عملگار باین دو عملوناد قرارگرفتاه و مقادار‬
‫عملوند اول را به تعداد عملوند دوم به سمت راست شیفت میدهد‪ .‬بهعنوانمثال‪ ،‬دستورات را مشاهده‬
‫کنید‪:‬‬
‫‪=12‬‫‪>>> a‬‬
‫‪2‬‫>>‫‪= a‬‫‪z‬‫>>>‬
‫‪a= 00001100‬‬
‫‪b=00000011‬‬
‫همانطور که در این دستورت مشاهده کردید‪ ،‬با هر شیفت به چپ عدد تقسیمبر ‪ 0‬میشود‪ ،‬مقادار‬
‫‪ 60‬تقسیمبر ‪ ۳‬شده و مقدار ‪( 3‬یعنی‪،‬‫‪ ) 00000011‬بهدستآمده است‪.‬‬

‫‪ .1-6‬انواع دادهها(اشیای آماده)‬

‫پایتون هر نوع داده را توسط یک کالس ارائه میکند‪‬.‬بنابراین‪ ،‬هر داده نمونهای‪6‬یا یک شهیء‌‪ 0‬از‬
‫کالس مشخص است‪ .‬عالوه بر کالسهای آماده‪ ،‬برنامهنویس میتواناد کاالسهاای جدیادی تعریاف‬
‫کند که در فصلهای بعدی خواهیم دید‪ .‬در پایتون انواع دادههای مختلفی وجود دارند کاه عباارتاناد‬
‫از‪:‬‬
‫‪ .9‬لیستها‬ ‫‪ .0‬دادههای رشتهای‬ ‫‪ .6‬دادههای عددی‬
‫‪ .1‬دیکشنریها‬ ‫‪ .0‬فایلها‬ ‫‪ .۳‬مجموعهها‬
‫در این فصل به دادههای عددی میپردازیم و در فصول بعدی رشتهها‪ ،‬لیستها‪ ،‬مجموعهها‪ ،‬فایلها‬
‫و دیکشنری را خواهیم آموخت‪.‬‬

‫‪ .1-6-1‬انواع دادههای عددی‬

‫‪1‬‬ ‫‪2‬‬
‫‪. Instance‬‬ ‫‪. Object‬‬

‫‪@PythonForever‬‬
 ‫‪ 11‬فصل اول‬

‫در پایتون گروهی از انواع اشیاء وجود دارند که برای کار با اعداد به کار میروند‪ .‬ایان اناواع اشایاء‬
‫عبارتاند از‪:‬‬
‫‪ .0‬دادههای ممیز شناور (‪)Float‬‬ ‫‪ .6‬دادههای صحیح (‪)Integer‬‬
‫‪ .۳‬دادههای دهدهی (‪)Decimal‬‬ ‫‪ .9‬دادههای مختلط (‪)Complex‬‬
‫‪ .1‬دادههای منطقی (‪)Boolean‬‬ ‫‪ .0‬دادههای کسری (‪)Fraction‬‬
‫دادههای صحیح‬

‫این نوع داده ها برای معرفی اعداد صحیح مثبت و منفی (بدون ممیز اعشاار) نظیار ‪ -900 ،0 ،1785‬و‬
‫غیره به کار میروند‪ .‬در پایتون نسخه ‪ 0‬دو نوع داده صحیح وجود دارد که عبارتاند از‪:‬‬
‫دادههای صحیح با محدودیت اندازه که ‪ int‬نامیده میشوند‪.‬‬
‫دادههای صحیح بدون محدودیت اندازه که ‪ long‬نامیده میشوند‪ .‬در پایتون نسخه ‪ 0‬برای تعیین‬
‫دادههای صحیح با نوع ‪ ، long‬انتهای داده کاراکتر‪ L‬یا ‪ l‬قرار میگیرد‪.‬‬
‫چنانچه در نسخه ‪ 0‬پایتون دادهای را با نوع ‪ int‬در نظر بگیرید‪ ،‬سهرریک‌‪ 6‬اتفااق افتاد(یعنای‪ ،‬دادهای را‬
‫در آن متغیر قرار دهید که در متغیر جا نشود)‪ ،‬خطایی رخ نخواهد داد و پایتون بهصورت خودکاار ناوع‬
‫تبدیل خواهد کرد‪.‬‬ ‫‪ int‬را به شیء با نوع ‪long‬‬

‫دقت کنید که بیشترین مقدار و کمترین مقدار یک شیء نوع ‪ int‬را میتوانید با ‪ sys.maxint - 1‬و‬
‫‪ sys.maxint‬ببینید‪ .‬برای این منظور میتوانید دستورات زیر را اجرا کنید‪:‬‬
‫‫‬ ‫‪>> import sys‬‬
‫‪>>> print sys.maxint , sys.maxint-1‬‬
‫امّا در نسخه ‪ 9‬پایتون اعداد صحیح با یک نوع ‪ int‬ارائه میگردند که ازلحاظ‌انداز ‌محدودیتی‌ندارند‪.‬‬

‫لذا‪ ،‬استفاده از کاراکترهای ‪ L‬و ‪ l‬در پایان این اعداد مجاز نمیباشد‪ .‬چون در این نسخه محدودیت نوع‬
‫‪ int‬حذفشده است‪ ،‬لذا‪ sys.maxint ،‬حذفشده است‪ .‬امّا‪ ،‬میتوان بهجای آن از دساتور ‪sys.maxsize‬‬

‫استفاده کرد‪.‬‬

‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬

‫‪. Overflow‬‬ ‫‪. Binary‬‬ ‫‪. Octal‬‬ ‫‪. Hexadecimal‬‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪10‬‬

‫‪ ۳‬بیان کرد‪ .‬اعداد مبنای ‪ 0‬را باید با‬ ‫‪9‬‬ ‫‪0‬‬

‫اعداد صحیح را میتوان در مبنای‌دو ‪ ،‬مبنای‌هشت و‌مبنای‌شانکد‬

‫‪ 0b‬یا ‪ 0B‬شروع نمود‪ .‬بهعنوانمثال‪ ،‬عدد زیر در مبنای ‪ 0‬است‪:‬‬

‫‫‬ ‫‪>>> a = 0b1101‬‬
‫امّا‪ ،‬اعداد مبنای ‪ 8‬را میتوان با ‪ 0O‬یا ‪ 0o‬شروع کرد‪ .‬بهعنوانمثال‪ ،‬عدد زیر در مبنای ‪ 8‬است‪:‬‬
‫‫‬ ‫‪>>> a = 0o743‬‬
‫ولی‪ ،‬اعداد مبنای ‪ 61‬را باید با ‪ 0x‬یا ‪ 0X‬آغاز نمود‪ .‬بهعنوانمثال‪ ،‬عدد زیر در مبنای ‪ 61‬است‪:‬‬
‫‫‬ ‫‪>>> a = 0xb7D‬‬
‫در پایتون توابعی برای تبدیل یک عدد از مبنای ‪ 62‬به مبنای ‪ 8 ،0‬و ‪ 61‬وجود دارند که عباارت‫اناد‬
‫از‪‬:‬‬
‫تابع‌)(‪ ٬bin‬یک عدد مبنای ‪ 62‬را به عدد مبنای ‪ 0‬تبدیل میکناد‪ .‬باهعناوانمثاال‪ ،‬دساتورات زیار‬
‫خروجی ‪ 0b101‬را نمایش میدهند‪:‬‬
‫‫‬ ‫‪>>> a = 5‬‬
‫))‪>>> print(bin(a‬‬
‫تابع)(‪ ،oct‬برای تبدیل عدد مبنای ‪ 62‬به مبنای ‪ 8‬به کاار مایرود‪ .‬باهعناوانمثاال‪ ،‬دساتورات زیار‬
‫خروجی ‪ 0o22‬را نمایش میدهند‪:‬‬
‫‪>>> a = 18‬‬
‫))‪>>> print(oct(a‬‬
‫تابع‌)(‪ ،hex‬برای تبدیل عدد مبنای‪ 62‬به مبنای ‪ 61‬به کار میرود‪ .‬باهعناوانمثاال‪ ،‬دساتورات زیار‬
‫خروچی ‪ 0x14‬را نمایش میدهند‪:‬‬
‫‪>>> a = 20‬‬
‫))‪>>> print(hex(a‬‬
‫تابع‌)(‪ ،int‬برای تبدیل یک عدد از یک مبنا به مبنای ‪ 62‬به کار میرود‪ .‬بهعنوانمثاال‪ ،‬دساتورات‬
‫زیر ‪ 20‬را نمایش میدهند‪:‬‬
‫‪>>> a = 0x14‬‬
‫))‪>>> print(int(a‬‬
‫اعداد اعشاری‬

‫‪@PythonForever‬‬
 ‫‪ 11‬فصل اول‬

‫اعداد میتوانند اعشاری باشاند‪ .‬پاایتون بارای نگاهداری اعاداد اعشااری (نظیار‪ 0.5 ،3.1415‬و‪ )...‬از‬
‫اشیایی با نوع ‪ float‬استفاده میکند‪ .‬عالوه بر نمایش اعداد اعشاری بهصورت ممیز شناور میتوان اعداد‬
‫اعشاری را با‌نماد‌علمی‪‌1‬نمایش داد که در پایتون برای نمایش اعداد اعشاری با نمااد علمای از حارف ‪E‬‬

‫به صاورت‫هاای‬‪‬)5e7(5E7‬‬ ‫و‬ ‫یا ‪ e‬استفاده میشود‪ .‬بهعنوانمثال‪ ،‬در پایتون اعداد‬
‫یا‬‪6E-10‬‫(‪)6e-10‬‫نمایش داده میشوند‪.‬‬
‫اعداد مختلط‬

‫همانطور که در ریاضی دیدیم‪ ،‬هر عادد مخاتلط‪ 0‬از دو بخاش حقیقای‪ 9‬و موهاومی‪ ۳‬تشاکیلشاده‬
‫است‪ .‬اعداد مختلط در پایتون با نوع شیء ‪ complex‬تعریف میشوند‪ .‬عدد مختلط در پایتون بهصاورت‬
‫نمایش داده میشود که ‪ x‬نشاندهنده‪ ،‬بخش حقیقای و ‪ y‬نشااندهناده بخاش موهاومی اسات‪.‬‬ ‫‪x + yj‬‬

‫‪3 + 5j‬‫ یاک عادد مخاتلط اسات کاه بخاش حقیقای آن ‪ 9‬و بخاش موهاومی آن ‪5‬‬ ‫بهعنوانمثال‪ ،‬عادد‬
‫میباشد‪.‬‬
‫از کالس ‪complex‬‫می توان برای تعریف اعداد مختلط استفاده نمود که این کالس بهصاورت زیار‬
‫به کار میرود‪:‬‬
‫)‪complex (real, imag‬‬
‫که ‪ real‬بخش حقیقی و ‪ imag‬بخش موهومی عدد مختلط را مشخص میکناد‪ .‬چنانچاه هریاک از‬
‫این بخشها بهعنوان آرگومان ارسال نشاوند‪ ،‬باهصاورت پایشفارض صافر در نظار گرفتاه مایشاوند‪،‬‬
‫بهعنوانمثال‪ ،‬دستورات زیر را ببینید‪:‬‬
‫‪>>> a = 5; b = -3‬‬
‫)‪>>> complex(a, b‬‬
‫دستور اول‪ ،‬مقادیر ‪ 9‬و ‪ -۳‬را به ترتیب به اشیاء ‪ a‬و ‪ b‬تخصیص میدهاد و دساتور دوم‪ ،‬یاک شایء‬
‫‪ complex‬با مقدار حقیقی ‪ 0‬و مقدار موهومی ‪ -9‬ایجاد مینماید(خروجی )‪ (5-3j‬نمایش داده میشود)‪.‬‬
‫با دو صفت ‪ real‬و ‪ imag‬میتوان بخشهای حقیقی و موهومی یک عدد مخاتلط را باهدسات آورد‪.‬‬
‫بهعنوانمثال‪ ،‬دستورات زیر را ببینید‪:‬‬
‫‪>>> a = 4.5‬‬

‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬

‫‪. Scientific Notation‬‬ ‫‪. Complex Number‬‬ ‫‪. Real‬‬ ‫‪. Imaginary‬‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪11‬‬

‫)‪>>> b = complex(a‬‬
‫‪>>> b.real‬‬
‫‪>>> b.imag‬‬
‫دستور اول‪ ،‬متغیر ‪ a‬با مقدار ‪ ۳.0‬را ایجاد کرده‪ ،‬دستور دوم‪ ،‬شایء ‪ 4.5+0.0j‬را ایجااد ماینمایاد و‬
‫دستور سوم‪ ،‬بخش حقیقای شایء مخاتلط ‪( b‬یعنای ‪ )۳.0‬را نماایش مایدهاد و دساتور چهاارم‪ ،‬بخاش‬
‫موهومی شیء ‪( b‬یعنی ‪ )0.0‬را نمایش میدهد‪.‬‬
‫اعداد دسیمال(دهدهی)‬

‫همانطور که بیان گردید‪ ،‬در پایتون اعداد اعشاری بهصورت شیء با نوع ‪ float‬معرفای مایگردناد‪.‬‬
‫‪ Binary-Floating‬اساتفاده ماینمایاد کاه‬ ‫مفسر پایتون برای ارائه نوع ممیز شاناور از کدگاذاری ‪Point‬‬

‫برای محاسبات حسابداری مناسب نمیباشد‪ .‬چون‪ ،‬پایتون اعدادی از قبیل ‪ 0.2 ،0.1‬و ‪ 0.3‬را باهصاورت‬
‫‪ 0.2000000000000001 ،0.1000000000000001‬و ‪ 0.300000000000001‬نشان مایدهاد کاه دقیقااً‬
‫برابر ‪ 0.2 ،0.1‬و ‪ 0.3‬نمیباشند‪ .‬این موضاوع در برخای از اوقاات موجاب خطاای منطقای خواهاد شاد‪.‬‬
‫بهعنوانمثال‪ ،‬دستورات زیر را ببینید‪:‬‬
‫‪>>> a = 0.2 + 0.2 + 0.2‬‬
‫‪>>> a == 0.6‬‬
‫نشان داده می شود‪ .‬یعنی‪ 0.2 + 0.2 + 0.2 ،‬برابار ‪ 0.6‬نخواهاد شاد و‬ ‫با اجرای این دستورات ‪False‬‬

‫این موضوع یک خطای منطقی برنامه است‪ .‬اکنون اگار ‪ a‬را نشاان دهایم‪ ،‬یعنای‪ ،‬دساتور زیار را تایاپ‬
‫کنیم‪ ،‬خروجی ‪ 0.6000000000000001‬نشان داده میشود‪:‬‬
‫‪>>> a‬‬
‫را نشان میدهند‪:‬‬ ‫‪0.3000000000000004‬‬ ‫و دستورات زیر مقدار‬
‫‪>>> a = 0.1 + 0.1 + 0.1‬‬
‫‪>>> a‬‬

‫دستور اول‪ ،‬سه بار‪ 0.1‬را جمع کرده و در ‪ a‬قرار میدهد که انتظار میرود‪ ،‬نتیجه ‪ 0.3‬شاود‪ ،‬امّاا‪ ،‬باا‬
‫نمایش ‪ a‬مایبینایم کاه ‪ a‬برابار باا ‪ 0.3000000000000004‬مایباشاد کاه ایان انحاراف ناشای از نحاوه‬
‫کدگذاری اعداد اعشاری میباشد‪ .‬به همین دلیل‪ ،‬در پاایتون یاک ناوع شایء جدیاد باه ناام ‪Decimal‬‬

‫‪@PythonForever‬‬
 ‫‪ 11‬فصل اول‬

‫طراحیشده است‪ .‬این نوع در مالول ‪ decimal‬قرار دارد‪ .‬بارای اساتفاده از ناوع ‪ Decimal‬ابتادا بایاد باا‬
‫دستور زیر این مالول را به برنامه اضافه کنید‪:‬‬
‫‪>>> import decimal‬‬
‫را نشان میدهند‪:‬‬ ‫دستورات زیر‪True‬‬

‫‪>>> import decimal‬‬

‫)"‪>>> a = decimal.Decimal("0.6‬‬
‫)"‪>>> b = decimal.Decimal("0.2‬‬
‫‪>>> a == b + b + b‬‬
‫دستور اول‪ ،‬مالول ‪ decimal‬را اضافه میکند‪ ،‬دساتور دوم‪ ،‬مقادار دهدهای ‪ 0.6‬را در شایء ‪ a‬قارار‬
‫قارار مایدهاد‪ ،‬دساتور چهاارم‪ )0.6( a ،‬را باا‬ ‫میدهد‪ ،‬دستور سوم‪ ،‬مقادار دهدهای ‪ 0.2‬را در شایء ‪b‬‬

‫(‪ )0.2+0.2+0.2‬مقایسه کرده و نتیجه ‪ True‬را برمیگرداند‪.‬‬ ‫‪b+b+b‬‬ ‫حاصل جمع‬

‫‪ .1-6-2‬رشته‬
‫در پایتون رشته‪ ،1‬مجموعهای از کاراکترهای پشت سر هم است که در باین جفات کتیشان(" ") یاا‬
‫تککتیشن('‫') قرار میگیرند‪ .‬بهعنوانمثال‪ ،‬دستورات زیر را ببینید‪:‬‬
‫"‪>>> a = "Python language‬‬
‫‪>>> a‬‬
‫)‪>>> print(a‬‬
‫دستور اول‪ ،‬شیءایی به نام ‪ a‬با نوع رشتهای تعریف میکند و شیء رشاتهای '‪ 'Python Language‬را‬
‫به آن تخصیص میدهد‪ ،‬دستور دوم‪ ،‬مقدار ‪( a‬یعنی‪ )'Python language' ،‬را نمایش میدهاد و دساتور‬
‫سوم نیز مقدار ‪( a‬یعنی‪ ) Python language ،‬را نمایش میدهد‪.‬‬
‫در پایتون برخالف برخی از زبانهای برنامهنویسی دیگر نوع‌کاراکتری‪ 0‬وجود ندارد‪ .‬یعنی‪ ،‬در زبان‬
‫پایتون کاراکتر‪ ،‬رشتهای با طول یک است‪.‬‬
‫در پایتون می توان از کاراکترهای کتیشن در داخل یکدیگر استفاده کرد‪ .‬در این حالات فقاط بایاد‬
‫نوع کتیشن داخلی با بیرونی متفاوت باشد‪ .‬امّا‪ ،‬اگر بخواهید از کاراکتر کتیشان یکساان اساتفاده کنیاد‪،‬‬
‫باید از کاراکتر \ ‪ 9‬قبل از کتیشن استفاده کنید‪ .‬بهعنوانمثال‪ ،‬دستورات زیر را مشاهده کنید‪:‬‬
‫"'‪>>> "Python 'language‬‬

‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬

‫‪. String‬‬ ‫‪. Char‬‬ ‫‪. Escape‬‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪11‬‬

‫'‪>>> 'I\'m a student‬‬

‫دستور اول‪ ،‬کاراکتر تککتیشن را در داخل جفتکتیشن استفاده میکناد(خروجای را باه صاورت‬
‫‪ "Python‬نمااایش ماایدهااد) و دسااتور دوم‪ ،‬کاااراکتر تااککتیشاان را در داخاال کاااراکتر‬ ‫"'‪'language‬‬

‫تککتیشن دیگر استفاده میکند‪ .‬برای این منظور‪ ،‬از کااراکتر \ قبال از کااراکتر تاککتیشان داخلای‬
‫استفاده مینماید(عبارت "‪ "I'm a student‬را نمایش خواهد داد)‪.‬‬
‫عملگرهای‌رشته‌‌‬

‫عملگر‪ ،+‬این عملگر برای اتصال (الحاق) دو رشته به کار میرود‪ .‬بهطوریکه رشته سامت راسات‬
‫را به انتهای رشته سمت چپ اضافه میکند‪ .‬بهعنوانمثال‪ ،‬دستورات زیر را ببینید‪:‬‬
‫"‪>>> s1 = "Fanavarienovin‬‬
‫"‪>>> s2 = ".net‬‬
‫‪>>> s1 + s2‬‬
‫دستور اول‪ ،‬رشته ‪ s1‬را ایجاد کرده‪ ،‬شایء ‪ Fanavarienovin‬را باه آن تخصایص مایدهاد‪ ،‬دساتور‬
‫دوم شیء ‪ s2‬را ایجاد نموده‪ ،‬رشته ‪ .net‬را در آن قرار میدهد و دستور سوم‪ ،‬رشته ‪ s2‬را به انتهای رشته‬
‫‪ s1‬میچسباند‪ .‬یعنی '‪ 'Fanavarienovin.net‬را نمایش میدهد‪.‬‬
‫عملگر*‪ ،‬برای تکرار یک رشته به کاار مایرود‪ .‬ایان عملگار دو عملوناد یکای از ناوع رشاتهای و‬
‫دیگری از نوع عدد صحیح را دریافت کرده رشته را باه تعاداد عادد دریافات شاده تکارار مایکناد و‬
‫' ‪'Fanavarienovin Fanavarienovin Fanavarienovin‬‬ ‫برمیگرداند‪ .‬بهعنوانمثال‪ ،‬دستور زیر عبارت‬
‫را نمایش میدهند‪:‬‬
‫‪>>> "Fanavarienovin " * 3‬‬

‫‪ .1-8‬تابع )(‪print‬‬
‫همان طور که قبالً بیان گردید‪ ،‬زمانی که یک عبارت را در مفسر تایپ کارده باشاید و کلیاد ‪Enter‬‬

‫را بزنید‪ ،‬عبارت فوراً ارزیابی شده‪ ،‬نتیجه ارزیابی عبارت نمایش داده میشود‪ .‬بهعنوانمثال‪ ،‬دستور زیار‬
‫را تایپ کرده تا نتیجه ارزیابی عبارت (یعنی‪ ) 57.125 ،‬را ببینید‪:‬‬
‫>>>‬ ‫‪8*(5+3)-110/6‬‬

‫‪@PythonForever‬‬
 ‫‪ 11‬فصل اول‬

‫این ویژگی برای زمانی به کار می رود کاه بخواهیاد نتیجاه یاک دساتور محاساباتی را حسااب‬
‫کرده یا بخواهید امالئی عبارت را ارزیابی کنید‪.‬‬
‫حال‪ ،‬اگر این دستورات را دریک ماالول تایاپ کنیاد‪ ،‬باا اجارای ایان دساتورات خروجای آنهاا‬
‫نمایش داده نمیشود‪ .‬برای نمایش اطالعات در مالول میتوانید از تابع )(‪ print‬اساتفاده کنیاد‪ .‬در تاابع‬
‫)(‪ ، print‬میتوانید هر دنبالهای از عباراتی را بیآورید‪ .‬این عبارات با کاما (‪ ),‬از هم جادا مایشاوند‪ .‬در‬
‫هنگام استفاده از تابع )(‪ print‬به نکات زیر دقت کنید‪:‬‬
‫‪ .6‬اگر تابع )(‪ print‬را بدون آرگومان استفاده کنید‪ ،‬یک سطر خالی چاپ خواهد شد‪.‬‬
‫‪ .0‬با هر بار اجرای تابع ‪ ،print‬یک سطر چاپ خواهد شد‪.‬‬
‫‪ .9‬اگر آرگومان تابع )(‪ ٬print‬رشتهای باشد‪ ،‬عین رشته را در خروجی نمایش میدهد‪.‬‬
‫‪ .۳‬اگر در آرگومان تابع )(‪ ٬print‬یک عبارت آورده شاود‪ ،‬نتیجاه عباارت در خروجای نماایش داده‬
‫میشود‪.‬‬
‫‪ .0‬اگر در آرگومان تابع )(‪ ٬print‬نام یک متغیر آورده شاود‪ ،‬مقادار متغیار در خروجای نماایش داده‬
‫میشود‪.‬‬
‫بهعنوانمثال‪ ،‬دستورات زیر را ببینید‪:‬‬
‫‪>>> x, y = 3, 5‬‬
‫)‪>>> print(x, " + ", y, " = ", x + y‬‬
‫دستور اول‪ ،‬مقدار ‪9‬را در ‪ x‬و مقدار ‪ 0‬را در ‪ y‬قرار میدهد‪ ،‬دستور دوم‪ ،‬ابتدا مقدار ‪( x‬یعنای ‪،)9‬‬
‫سپس عالمت "‪ ،"+‬در ادامه مقدار ‪ y‬یعنی (‪ ،)0‬در پایان عالمت = و نتیجاه عباارت ‪( x + y‬یعنای ‪ )8‬را‬
‫نمایش میدهد؛ یعنی‪ ،‬خروجی زیر‪:‬‬
‫‪3+5=8‬‬
‫درواقع هر چیزی که در آرگومان تابع )(‪ print‬استفاده میشود‪ ،‬برای نماایش باه ناوع رشاته تبادیل‬
‫میگردد‪ ،‬بهعنوانمثال‪ ،‬اگر متغیر ‪ n‬عددی صحیح باشاد کاه باه مقادار ‪ 62‬ارجااع مایدهاد‪ ،‬امّاا وقتای‬
‫بهعنوان آرگومان )(‪ print‬استفاده میگردد‪ ،‬درنهایت مقدار ‪ 62‬به یکرشته تبدیل میشود‪ .‬بااینوجود‪،‬‬
‫باید دقت کنید که متغیر ‪ n‬همچنان به یک عدد صحیح ارجاع میدهد‪ .‬بهعنوانمثال‪ ،‬دساتورات زیار را‬
‫ببینید‪:‬‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪11‬‬

‫‪>>> n = 10‬‬
‫)‪>>> print("n is" + n‬‬
‫با اجرای این دستور انتظار داریم که عبارت زیر نمایش داده شود‪:‬‬
‫‪n is 10‬‬
‫درصورتیکه با اجرای این دستور خطای زیر صادر میگردد‪:‬‬
‫)‪Traceback (most recent call last:‬‬

‫>‪File "<pyshell#11>", line 1, in <module‬‬

‫)‪print("n is" + n‬‬

‫‪TypeError: Can't convert 'int' object to str implicitly‬‬

‫چون ‪ n‬از نوع عددی است‪ .‬پس باید به نوع رشته تبدیل شود یا دستور بهصورت زیر به کار رود‪:‬‬
‫)‪>>> print("n is", n‬‬
‫اکنون خروجی زیر نمایش داده میشود ‪:‬‬
‫‪n is 10‬‬
‫استفاده کنید(مانند دستور زیر)‪:‬‬ ‫نوع رشتهای میتوانید از تابع )(‪str‬‬ ‫برای تبدیل ‪ n‬به‬
‫))‪>>> print("n is " + str(n‬‬
‫با اجرای این دستور‪ ،‬خروجی زیر نمایش داده میشود‪:‬‬
‫‪n is 10‬‬

‫‪ .1-9‬تایپ‪ ،‬ذخیره و اجرای برنامه در پایتون‬

‫تاکنون‪ ،‬دستورات را بهصورت تکی نوشته و اجارا کاردیم و نتاایج را مشااهده نماودیم‪ .‬در پاایتون‬
‫امکانی وجود دارد تا بتوانید دستورات را بهصورت یکجا تایپ کرده و اجرا نمایید‪ .‬بارای ایان منظاور‪،‬‬
‫به ویراستاری نیاز دارید تا برنامه را در آن تایپ کنید‪ .‬سپس آن را اجارا کنیاد‪ .‬در نساخههاای مختلاف‬
‫پایتون‪ ،‬ویراستاری آمادهشده است که میتوانید در آن برنامهتان را تایپ و اجرا کنید‪.‬‬
‫بهعنوانمثال‪ ،‬در پایتون نسخه ‪ 9‬به بعد فرآیند اجرا و ویرایش مانند مثال ‪ 6 - 6‬است‪.‬‬
‫برنامهای‌که‌مراحل‌تایپ‪‌،‬ذخیر ‌و‌اجرای‌یک‌برنامه‌ساد ‌را‌نشان‌می‌دهد‪‌.‬‬
‫‌‬ ‫مثال‪‌.1-1‬‬
‫‪ .1‬در منوی ‪ ،Start‬در باکس ‪ ،Search‬عباارت ‪ py‬را تایاپ کارده تاا لیسات برناماههاایی کاه باا ‪ py‬شاروع‬
‫میشوند‪ ،‬ظاهر شود (شکل‪‬.)6-0‬‬

‫‪@PythonForever‬‬
 ‫‪ 11‬فصل اول‬

‫شکل‪1-2‬لیست برنامههایی که با ‪ py‬شروع میشوند‪.‬‬

‫‪ .0‬برنامه)‪ IDLE (python 3.5 64-bit‬را اجرا کنید تا شکل ‪ 6- 9‬ظاهر شود‪.‬‬

‫شکل ‪.python 3.5.1 shell 1-3‬‬

‫‪ .9‬گزینه ‪( File / New File‬یا کلیدهای ترکیبی ‪ )Ctrl+N‬را فشار دهید تا فایال جدیادی ایجااد شاود‬
‫(شکل‪.)6-۳‬‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪11‬‬

‫شکل ‪1-4‬ایجاد فایل جدید ‪.python‬‬

‫‪ .۳‬اکنون دستورات برنامهتان را تایپ کنید (مانند شکل‪.)6-0‬‬

‫شکل ‪1 - 5‬دستورات نمونه برای اجرا‪.‬‬

‫‪ .0‬گزینه ‪( File / Save As‬یاا کلیادهای ترکیبای ‪ )Ctrl+ Shift+ S‬را اجارا کنیاد تاا پنجاره ‪Save As‬‬

‫ظاهر شود (شکل ‪.)6- 1‬‬

‫‪@PythonForever‬‬
 ‫‪ 11‬فصل اول‬

‫شکل ‪1-6‬پنجره ‪.Save As‬‬

‫‪ .1‬نام فایل را ‪ 1-1.py‬انتخاب کرده‪ ،‬ساپس ‪ Save‬را کلیاک کنیاد (هماانطاوری کاه در ایان شاکل‬
‫میبینید‪ ،‬پسوند فایل ‪ .py‬انتخابشده است که فایل ‪ source‬برنامههای زبان پایتون میباشد)‪.‬‬
‫‪ .7‬برای اجرا گزینه ‪( Run / Run Module‬یا کلید ‪ )F5‬را انتخاب کنید تا خروجی زیر را ببینید(شاکل‬
‫‪.)6-7‬‬

‫شکل ‪ 1 -7‬نمونه خروجی برنامه‪.‬‬

‫‪ .1-11‬خواندن داده‬
‫اکثر برنامههای واقعی باید اطالعاتی را از کاربر بخوانند‪ .‬بارای ایان منظاور‪ ،‬پاایتون از تاابع )(‪input‬‬

‫استفاده میکند‪ .‬تابع )(‪ input‬بهصورت زیر به کار میرود‪:‬‬

‫("پیغام ")‪ = input‬متغیر‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪10‬‬

‫وقتی کنترل اجرای برنامه به تابع )(‪ input‬برسد‪ ،‬ابتدا پیغام نمایش داده میشاود‪ ،‬منتظار مایماناد تاا‬
‫کاربر رشتهای را وارد کرده‪ ،‬کلید ‪ Enter‬را فشار دهد‪ .‬بهمحض اینکه کاربر کلید ‪ Enter‬را فشار دهد‪،‬‬
‫رشته واردشده در متغیر قرار میگیرد‪ .‬بهعنوانمثال‪ ،‬دستور زیر را ببینید‪:‬‬
‫)”‪name = input(“Enter your name:‬‬
‫با اجرای این دستور عبارت زیر نمایش داده میشود‪:‬‬
‫‪Enter your name:‬‬
‫را فشااار دهااد‪ ،‬عبااارت‬ ‫اکنااون کاااربر عبااارت ‪ fanavarienovin‬را وارد کاارده‪ ،‬کلیااد ‪Enter‬‬

‫قرار میگیرد‪.‬‬ ‫‪ fanavarienovin‬در متغیر ‪name‬‬

‫اکنون دستورات زیر را ببینید‪:‬‬

‫)"‪a = input("Enter a:‬‬
‫)"‪b = input("Enter b:‬‬
‫‪sum = a + b‬‬
‫)‪print("Sum is ", sum‬‬
‫با اجرای این دستورات خروجی زیر نمایش داده میشود‪:‬‬
‫‪Enter a:10‬‬
‫‪Enter b:20‬‬
‫‪Sum is 1020‬‬
‫همانطور که در این خروجی میبینید‪ ،‬خروجی حاصل جمع دو عادد واردشاده (یعنای جماع ‪ 62‬و‬
‫‪ ) 02‬نمیباشد‪ .‬چون دستورات )(‪ a ،input‬و ‪ b‬را بهصورت رشته میخوانند‪.‬‬
‫پس "‪ a ="10‬و‬"‪‬b="‬20‬میباشد‪ .‬بنابراین‬‬‪(‬sum = a + b‬برابر‬‪‬)1020‬اتصال دو رشاته ‪ a‬و ‪b‬‬

‫میباشد‪.‬‬
‫پس اگر بخواهید عددی را بخوانید‪ ،‬ابتدا‪ ،‬باا دساتور )(‪ input‬مایتوانیاد آن را باهصاورت رشاتهای‬
‫آن را به عدد تبدیل کنید‪ .‬اکنون‪ ،‬دستورات زیر را ببینید‪:‬‬ ‫بخوانید و با تابع )(‪int‬‬

‫)"‪a = input("Enter a:‬‬

‫)"‪b = input("Enter b:‬‬
‫)‪a = int(a‬‬
‫)‪b = int(b‬‬
‫‪sum = a + b‬‬
‫)‪print("Sum is ", sum‬‬
‫خروجی زیر ظاهر میگردد‪:‬‬ ‫با اجرای این دستورات و ورود اعداد ‪ 62‬و ‪ 02‬جلوی ‪ a:‬و ‪b:‬‬

‫‪@PythonForever‬‬
 ‫‪ 11‬فصل اول‬

‫‪Enter a:10‬‬
‫‪Enter b:20‬‬
‫‪Sum is 30‬‬
‫چون‪ ،‬دستور اول‪ ،‬رشته عددی ‪ 62‬را میخواند‪ ،‬در ‪ a‬قرار میدهد‪ ،‬دستور دوم‪ ،‬رشته عاددی ‪02‬‬
‫قارار مایدهاد‪ ،‬دساتور‬ ‫‪a‬‬ ‫را خوانده‪ ،‬در ‪ b‬قرار میدهد‪ ،‬دستور ساوم‪ ،‬مقادار صاحیح ‪ (int(a)) a‬را در‬
‫قارار‬ ‫‪( b‬یعنای‪ )30‬را در ‪sum‬‬ ‫قرار میدهد‪ ،‬دستور پنجم‪ ،‬جماع ‪ a‬و‬ ‫‪b‬‬ ‫را در‬ ‫‪b‬‬ ‫چهارم‪ ،‬مقدار صحیح‬
‫را نمایش میدهد‪.‬‬ ‫میدهد و دستور ششم‪ ،‬عبارت ‪Sum is 30‬‬

‫استفاده کرد‪ .‬در این صاورت رشاته خوانادهشاده را باه‬ ‫تابع )(‪ input‬را میتوان در داخل تابع )(‪int‬‬

‫عدد صحیح تبدیل کرده‪ ،‬در متغیر قرار میدهد‪ .‬بهعنوانمثال‪ ،‬دستور زیر را مشاهده کنید‪:‬‬
‫))”‪n = int(input(“Enter n:‬‬
‫با اجرای این دستور عبارت زیر ظاهر میشود‪:‬‬
‫‪Enter n:‬‬
‫اکنون اگرکاربر جلوی ‪ ، n:‬مقادار رشاتهای ‪ 60‬را وارد کناد‪ ،‬مقادار رشاتهای "‪ "15‬باه عادد ‪60‬‬
‫تبدیل و در ‪ n‬قرار میگیرد‪ .‬حال اگر کاربر بهجای یک عادد اشاتباهاً رشاتهای را وارد کناد کاه در آن‬
‫یا '‪'A‬‫تا '‪'Z‬‫و غیره وجود داشته باشند‪ ،‬مفسر پایتون پیغام خطاای‬ ‫کاراکترهای غیر عددی نظیر '‪ 'a‬تا '‪'z‬‬

‫زیر را نمایش میدهد‪:‬‬

‫‪Enter n:12A12‬‬
‫)‪Traceback (most recent call last:‬‬

‫>‪File "<pyshell#2>", line 1, in <module‬‬

‫‪n = int(input("Enter n))":‬‬

‫' ‪ValueError: invalid literal for int() with base 10: '12A12‬‬
‫این پیغام خطا به این دلیال اسات کاه آرگوماان تاابع )(‪ int‬بایاد شاامل رشاتهای باشاد کاه فقاط از‬
‫کاراکترهای عددی تشکیل میشود‪ .‬یعنی‪ ،‬آرگومان تابع )(‪ ،int‬رشته نمیتواند شامل کاراکترهای غیار‬
‫عددی باشد‪.‬‬
‫یدههد‌ (ههد ‌ا‌یهن‌‌برنامهه‌‬
‫حاصل‌جمع‌آنها‌را‌نمایش‌مه‌ ‌‬
‫‌‬ ‫برنامهای‌که‌دو‌عدد‌را‌خواند ‪،‬‬
‫‌‬ ‫مثال ‌‪‌.1-8‬‬
‫آشنایی‌با‌دستورات‌ورودی‪‌،‬خروجی‌و‌عملگر‌‪‌+‬است)‪.‬‬
‫مراحل‌طراحی‌و‌اجرا‪‌‌:‬‬

‫‪ .6‬با گزینه ‪( File / New file‬کلیدهای ‪ ) Ctrl + N‬مالول جدیدی ایجاد کنید‪.‬‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪11‬‬

‫‪ .0‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫)" ‪a = input("Please enter number1:‬‬
‫هد ‌‌‬ ‫متغیر‌‬
‫)‪a=int(a‬‬
‫)" ‪b = input("Please enter number2:‬‬ ‫عدد اول‬ ‫‪a‬‬
‫)‪b = int(b‬‬
‫)‪print (a, ' + ', b, ' = ', a + b‬‬
‫عدد دوم‬ ‫‪b‬‫‬

‫دستور اول‪ ،‬پیغام ‪ Please enter number1:‬را نماایش مایدهاد‪ ،‬ساپس رشاتهای را خواناده‪ ،‬در ‪a‬‬

‫قرار میدهد‪ ،‬دستور دوم‪ ،‬مقدار موجود در رشته ‪ a‬را به عادد تبادیل مایکناد و در ‪ a‬قارار مایدهاد‪،‬‬
‫دستور سوم‪ ،‬پیغام ‪ Please enter number2:‬را نمایش داده‪ ،‬یاکرشاته عاددی را خواناده‪ ،‬در ‪ b‬قارار‬
‫را به عدد تبدیل میکند و در ‪ b‬قرار میدهاد و دساتور پانجم‪ ،‬باا تاابع‬ ‫میدهد‪ ،‬دستور چهارم‪ ،‬رشته ‪b‬‬

‫را‬ ‫در اداماه مقادار ‪ b‬و در پایاان عالمات = باه هماراه ‪a + b‬‬ ‫‪ ، print‬ابتدا مقادار ‪ ،a‬ساپس عالمات ‪،+‬‬
‫نمایش میدهد‪.‬‬
‫ذخیره کنید‪.‬‬ ‫‪ .9‬با گزینه ‪ )Ctrl + Shift + S( File / Save As‬مالول را به نام ‪1-2.Py‬‬

‫‪ .۳‬با گزینه ‪( Run / Run Module‬کلید ‪ )F5‬مالول را اجرا کنید و دادههای ورودی را بهصاورت زیار‬
‫وارد نمایید‪:‬‬
‫‪Please enter number1: 12‬‬
‫‪Please enter number2: 15‬‬
‫‪12 + 15 = 27‬‬
‫مثال‌‪‌‌.1-4‬برنامه‌ای‌ که‌شعاع‌دایر ‌را‌خواند ‪‌،‬بها‌اسهتفاد ‌از‌فرمهول‌زیهر‌مسهاحت‌دایهر ‌را‌نمهایش‌‬
‫میدهد‪‌:‬‬
‫‌‬

‫مراحل‌طراحی‌و‌اجرا‪‌‌:‬‬

‫‪ .6‬با گزینه ‪ )Ctrl + N( File / New file‬مالول جدیدی ایجاد کنید‪.‬‬

‫‪ .0‬دستورات زیر را در آن تایپ کنید‪:‬‬
‫)" ?‪response=input("What is your radius‬‬ ‫هد ‌‌‬ ‫متغیر‌‬
‫)‪r = float(response‬‬
‫شعاع دایره‬ ‫‪r‬‬
‫‪area = 3.14159 * r**2‬‬
‫)‪print("The area is ", area‬‬ ‫مساحت دایره‬ ‫‪area‬‫‬

‫‪@PythonForever‬‬
 ‫‪ 11‬فصل اول‬

‫دستور اول پیغامی را نمایش داده‪ ،‬یکرشته را بهعنوان شعاع دریافت میکند و در شایء ‪response‬‬

‫را به عدد اعشااری تبادیل مایکناد و در ‪ r‬قارار مایدهاد‪،‬‬ ‫قرار میدهد‪ ،‬دستور دوم‪ ،‬مقدار ‪response‬‬

‫دستور سوم‪ ،‬مساحت دایره را حساب کرده‪ ،‬به ‪ area‬تخصیص مایدهاد‪ ،‬دساتور چهاارم ابتادا‪ ،‬عباارت‬
‫‪ The area is‬و سپس در ادامه آن مقدار متغیر‪( area‬مساحت دایره) را نمایش میدهد‪.‬‬
‫‪ .9‬مالول را به نام‪ 1-3.Py‬ذخیره کنید‪.‬‬
‫مقدار ‪ 12.5‬را وارد کرده تاا خروجای زیار را‬ ‫‪ .۳‬مالول را اجرا کنید‪ .‬جلوی ? ‪What is your radius‬‬

‫مشاهده نمایید‪:‬‬
‫‪What is your radius? 12.5‬‬
‫‪The area is 490.87343749999997‬‬
‫که‌سنتان‌را‌به‌سال‌دریافت‌کرد ‪‌،‬بهه‌اانیهه‪‌،‬‬
‫‌‬ ‫‌است‪‌.‬برنامهای‌‬ ‫مثال‪ .1-3‬هرسال‌برابر‌با‌‬
‫دقیقه‌و‌ساعت‌تبدیل‌کند‪‌.‬هر‌دقیقه‌‪‌60‬اانیه‌و‌هر‌ساعت‌‪‌60‬دقیقه‌است‌(هر‌ساعت‌‪‌4700‬اانیه‌است)‪‌.‬‬
‫مراحل‌طراحی‌و‌اجرا‪‌‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫)" ‪age=input("Enter your age:‬‬ ‫هد ‌‌‬ ‫متغیر‌‬
‫)‪Age=int(age‬‬
‫‪second = Age * 3165e4‬‬
‫سن ورودی(بهصورت رشته)‬ ‫‪age‬‬
‫‪minute = second / 60‬‬ ‫سن به سال و تبدیل شده به عدد‬ ‫‪Age‬‫‬
‫‪hour = second / 3600‬‬
‫)‪print ('Second is ', second‬‬ ‫سن به ثانیه‬ ‫‪second‬‬
‫)‪print ('Minute is ', minute‬‬
‫)‪print ('Hour is ', hour‬‬ ‫سن به دقیقه‬ ‫‪minute‬‬

‫سن به ساعت‬ ‫‪hour‬‬

‫را نمایش داده‪ ،‬یکرشته را بهعنوان سنتان دریافت میکناد و‬ ‫دستور اول‪ ،‬پیغام ٍ‪Enter your age:‬‬

‫در متغیر ‪ age‬قرار میدهد‪ .‬دستور دوم‪ ،‬رشته عددی ‪ age‬را به عدد صاحیح تبادیل مایکناد و در متغیار‬
‫‪ Age‬قرار میدهد(دقت داشته باشید که متغیر ‪ age‬و ‪ Age‬دو متغیر متفاوت هستند‪ ،‬چون پاایتون نبسات‬
‫به حروف بازرگ و کوچاک حسااس اسات)‪ ،‬دساتور ساوم‪ ،‬مقادار متغیار ‪ Age‬را در ‪( 3156e4‬یعنای‬
‫) ضرب کرده تا سنتان را باه ثانیاه تبادیل نمایاد و ساپس آن را در متغیار ‪ second‬قارار‬
‫میدهد‪ ،‬دستور چهارم‪ ،‬مقدار متغیر ‪ second‬را تقسیمبر ‪ 12‬میکند تا تعداد دقایق سانتاان را باه دسات‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪11‬‬

‫آورده‪ ،‬سپس آن را در متغیر ‪ minute‬قارار مایدهاد‪ ،‬دساتور پانجم‪ ،‬مقادار ‪ second‬را تقسایمبار ‪9122‬‬
‫قارار مایدهاد‪ ،‬دساتورات‬ ‫میکند تا تعداد ساعات سنتان را حساب کرده‪ ،‬سپس آن را در متغیر ‪hour‬‬

‫ششم تا هشتم با پیغامهای مناسب تعداد ثانیهها‪ ،‬دقایق و ساعات سنتان را نمایش میدهند‪.‬‬
‫‪ .0.6‬مالول را ذخیره و اجرا کنید‪ .‬جلوی ‪ ،Enter your age:‬عدد ‪ ۳7‬را وارد کرده تا خروجی زیار را‬
‫مشاهده کنید‪:‬‬
‫‪Enter your age: 47‬‬
‫‪Second is 1487550000.0‬‬
‫‪Minute is 24792500.0‬‬
‫‪Hour is 413208.3333333333‬‬
‫مثال‌‪‌.1-6‬برنامه‌ای‌که‌یک‌عدد‌دورقمی‌را‌خواند ‪‌،‬مقلهو ‌آن‌را‌نمهایش‌مهی‌دههد‌‌(ههد ‌برنامهه‌‬
‫آشنایی‌با‌عملگرهای‌‪‌%‬و‌‪‌//‬است)‪‌‌.‬‬
‫مراحل‌طراحی‌و‌اجرا‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورت آن را بهصورت زیر تایپ کنید‪:‬‬

‫)" ‪a = input("Enter a number:‬‬ ‫هد ‌‌‬ ‫متغیر‌‬
‫)‪a = int(a‬‬
‫عدد دورقمی‬ ‫‪a‬‬
‫‪r1 = a % 10‬‬
‫‪r2 = a // 10‬‬ ‫رقم یکان‬ ‫‪ r1‬‫‬
‫)‪print ("Reverse is ", r1 * 10 + r2‬‬
‫رقم دهگان‬ ‫‪r2‬‬

‫دستور اول‪ ،‬با نمایش پیغام ‪ Enter a number:‬یک رشته عددی دورقمی را دریافت میکند و در ‪a‬‬

‫قرار میدهد‪ ،‬دستور دوم‪ ،‬مقدار ‪ a‬را به عدد صحیح تبدیل نموده‪ ،‬به ‪ a‬نسبت مایدهاد (هماانطاور کاه‬
‫مشاهده کردید‪ ،‬در زمان اجرا میتواند نوع شایء تغییار کناد‪ ،‬یعنای ‪ a‬از ناوع رشاتهای باه ناوع عاددی‬
‫قرار میدهاد‪ ،‬دساتور‬ ‫صحیح تبدیل گردید)‪ ،‬دستور سوم‪ ،‬رقم یکان ‪ a‬را با عملگر ‪ %‬جدا کرده‪ ،‬در ‪r1‬‬

‫چهارم‪ ،‬با عملگر ‪ //‬رقم دهگان (عملگر ‪ //‬برای انجام تقسیم صحیح به کار مایرود) ‪ a‬را جادا نماوده‪،‬‬
‫قرار میدهد و دستور پنجم‪ ،‬ابتدا عبارت ‪ Reverse is‬و سپس ‪ r1* 10 +r2‬یعنی‪ ،‬هماان مقلاوب ‪)a‬‬ ‫در ‪r2‬‬

‫را نمایش میدهد‪.‬‬

‫‪ .0‬مالول را به ناام‪ 1_5.Py‬ذخیاره کارده و اجارا نماییاد‪ .‬جلاوی ‪ ،Enter a number:‬عادد ‪ 47‬را وارد‬
‫کرده تا خروجی زیر را مشاهده کنید‪:‬‬
‫‪Enter a number: 47‬‬

‫‪@PythonForever‬‬
 ‫‪ 11‬فصل اول‬

‫‪Reverse is 74‬‬
‫یماند ‌عهدد‌اول‌بهر‌عهدد‌دوم‌را‌‬
‫مثال‪‌.1-7‬برنامه‌ای‌که‌دو‌عدد‌صحیح‌را‌خواند ‪‌،‬خارج‌قسمت‌و‌باق ‌‬
‫باقیماند ‌تقسیم‌صحیح)‌و‌‪(‌//‬تقسیم‌صحیح)‌است)‪‌.‬‬
‫نمایش‌میدهد‌(هد ‌برنامه‌آشنایی‌با‌عملگرهای‌‪‌ (‌%‬‬
‫‌‬
‫مراحل‌طراحی‌و‌اجرا‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫))" ‪a = int(input("Enter a:‬‬ ‫هد ‌‌‬ ‫متغیر‌‬
‫))" ‪b = int(input("Enter b:‬‬
‫عدد اول‬ ‫‪a‬‬
‫)‪print (a % b, " ", a // b‬‬
‫عدد دوم‬ ‫‪b‬‫‬
‫‪ .0‬مالول را ذخیره کرده‪ ،‬اعداد ‪ 6۳‬و ‪ 9‬را وارد نمایید تا خروجی زیر را ببینید‪:‬‬
‫‪Enter a: 14‬‬
‫‪Enter b: 3‬‬
‫‪4‬‬ ‫‪2‬‬
‫مثال‪‌.1-8‬برنامه‌ای‌که‌‪‌x‬و‌‪‌y‬را‌خواند ‌و‌حاصل‌عبارت‌زیر‌را‌نمایش‌می‌دهد‌(هد ‌برنامه‌آشهنایی‌بها‌‬
‫عملگر‌توان‌است)‪‌:‬‬
‫‫‬
‫مراحل‌طراحی‌و‌اجرا‌‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫))" ‪x = int(input("Enter x:‬‬
‫))" ‪y = int(input("Enter y:‬‬
‫‪z = x ** 3 + 2 * x ** 2 * y + 3 * y - 7‬‬
‫)‪print ("Z = ", z‬‬
‫‪ .0‬مالول را ذخیره و اجرا کنید و اکنون دو عدد ‪ 7‬و ‪ 1‬وارد کرده تا خروجی زیر را ببینید‪:‬‬
‫‪Enter x: 7‬‬
‫‪Enter y: 6‬‬
‫‪Z = 942‬‬
‫مثال‌‪‌.1-16‬برنامه‌ ای‌که‌دو‌رشته‌را‌خواند ‪‌،‬این‌دو‌رشته‌را‌بهه‌ههم‌الحهار‌کهرد ‪‌،‬ن‌تیجهه‌را‌نمهایش‌‬
‫میدهد‌(هد ‌این‌برنامه‪‌،‬آشنایی‌با‌عملگر‌‪‌+‬برای‌اتصال‌دو‌رشته‌است)‪‌.‬‬
‫‌‬
‫مراحل‌طراحی‌و‌اجرا‌‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫هد ‌‌‬ ‫متغیر‌‬

‫رشته اول‬ ‫‪str1‬‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪11‬‬

‫)" ‪str1 = input("Enter string1:‬‬ ‫رشته دوم‬ ‫‪str2‬‬

‫)" ‪str2 = input("Enter string2:‬‬
‫‪str3 = str1 + str2‬‬ ‫حاصل الحاق رشته اول و دوم‬ ‫‪str3‬‬
‫)‪print (str3‬‬
‫‪ .0‬مالول را ذخیره و اجرا کنید و نمونه خروجی را بهصورت زیر مشاهده نمایید‪:‬‬
‫‪Enter string1: Fanavarienovin‬‬
‫‪Enter string2: Publisher‬‬
‫‪Fanavarienovin Publisher‬‬
‫یکرشته‌و‌تعداد‌ت رار‌آن‌را‌خواند ‪‌،‬رشته‌را‌به‌تعداد‌عدد‌واردشهد ‌‌ت هرار‌‬
‫مثال‌‪‌.‌1-17‬برنامه‌ای‌که‌ ‌‬
‫نماید‌و‌نمایش‌میدهد‌(هد ‌برنامه‌استفاد ‌از‌عملگر‌*‌برای‌ت رار‌رشته‌است)‪‌.‬‬
‫‌‬ ‫‌‬
‫می‬
‫مراحل‌طراحی‌و‌اجرا‌‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫)" ‪s = input("Enter a string:‬‬ ‫هد ‌‌‬ ‫متغیر‌‬
‫))" ‪rep = int(input("Enter repeat:‬‬
‫رشته ورودی‬ ‫‪s‬‬
‫)‪print (s * rep‬‬
‫تعداد تکرار رشته‬ ‫‪rep‬‬

‫‪ .0‬مالول را ذخیره و اجرا کرده‪ ،‬سپس جلاوی ‪ ،string‬مقادار ‪ Python‬و جلاوی ‪ ،repeat‬مقادار ‪ 0‬را‬
‫وارد کنید تا خروجی زیر را مشاهده کنید‪:‬‬
‫‪Enter a string: Python‬‬
‫‪Enter repeat: 5‬‬
‫‪PythonPythonPythonPythonPython‬‬
‫برنامهای‌که‌دو‌عدد‌را‌خواند ‪‌،‬معادل‌مختلط‌آن‌دو‌عدد‌را‌نمایش‌مهی‌دههد‌ (عهدد‌اول‌‬
‫‌‬ ‫مثال‌‪‌.1-18‬‬
‫ها‌است‪‌.‬‬ ‫بخش‌‪‌real‬و‌عدد‌دوم‌بخش‌ ‪‌ ‌imag‬‬
‫میباشد)‪‌.‬هد ‌این‌برنامه‌ایجاد‌اعداد‌مختلط‌و‌نمایش‌آن‌ ‌‬
‫مراحل‌طراحی‌و‌اجرا‌‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫))" ‪a = int(input("Enter real part:‬‬ ‫هد ‌‌‬ ‫متغیر‌‬
‫))" ‪b = int(input("Enter image part:‬‬
‫)‪complex1 =complex(a, b‬‬ ‫بخش ‪real‬‬ ‫‪a‬‬
‫)‪print (complex1‬‬ ‫بخش ‪imag‬‬ ‫‪b‬‬

‫عدد مختلط تولیدشده‬ ‫‪complex1‬‬

‫‪@PythonForever‬‬
 ‫‪ 11‬فصل اول‬

‫‪ .0‬مالول را ذخیره و اجارا کارده‪ ،‬جلاوی ‪ real part‬و ‪ image part‬مقاادیر ‪ 60‬و ‪ -۳‬را وارد کنیاد تاا‬
‫خروجی زیر را ببینید‪:‬‬
‫‪Enter real part: 12‬‬
‫‪Enter image part: -4‬‬
‫)‪)j4 -12‬‬

‫‪ .1-11‬مسائل حلشده‬
‫مثال‌‪‌.1‬برنامه‌ای‌که‌سه‌ضلع‌مثلث‌را‌خواند ‪‌،‬با‌استفاد ‌از‌فرمول‌های‌زیر‌محیط‌و‌مسهاحت‌مثلهث‌را‌‬
‫حسا ‌می‌کند‪‌.‬‬

‫)‪p  ( a  b  c‬‬
‫‪2‬‬
‫)‪s  p( p  a)( p  b)( p  c‬‬
‫مراحل‌طراحی‌و‌اجرا‌‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫))" ‪a = float(input("Enter a:‬‬ ‫هد ‌‌‬ ‫متغیر‌‬
‫))" ‪b = float(input("Enter b:‬‬
‫ضلع اول مثلث‬ ‫‪a‬‬
‫))" ‪c = float(input("Enter b:‬‬
‫) ‪p = (a + b + c‬‬ ‫ضلع دوم مثلت‬ ‫‪b‬‬
‫)‪print("Perime is ", p‬‬
‫‪p=p/2‬‬ ‫ضلع سوم مثلث‬ ‫‪c‬‬
‫‪s=(p * (p - a )*(p - b) *(p -c))**0.5‬‬
‫)‪print("Area is ", s‬‬
‫محیط و نصف‬
‫‪p‬‬
‫محیط مثلث‬
‫مساحت مثلث‬ ‫‪s‬‬

‫‪ .0‬مالول را ذخیره و اجرا کرده‪ ،‬جلوی ‪ b: ، a:‬و ‪ c:‬به ترتیب ‪ 8 ،60‬و ‪ 3‬را وارد کنید تا خروجی زیار‬
‫را ببینید‪:‬‬
‫‪Enter a: 12‬‬
‫‪Enter b: 8‬‬
‫‪Enter b: 9‬‬
‫‪Perime is 29.0‬‬
‫‪Area is 35.99913193397863‬‬
‫برنامهای‌که‌دو‌عدد ‪‌a‬و‌ ‪‌b‬را‌خواند ‪‌،‬حاصل‌عبارت‌زیر‌را‌محاسبه‌کرد ‌و‌نمایش‌می‌دهد‪‌:‬‬
‫‌‬ ‫مثال‪‌.8‬‬

‫‪f (a, b) ‬‬

‫‪b‬‬
‫‪a‬‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪11‬‬

‫مراحل‌طراحی‌و‌اجرا‌‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫))" ‪a = int(input("Enter a:‬‬
‫هد ‌‌‬ ‫متغیر‌‬
‫))" ‪b = int(input("Enter b:‬‬
‫‪f = (a ** b ) ** 0.5‬‬ ‫عدد ورودی اول‬ ‫‪a‬‬
‫)‪print("f is ", f‬‬
‫عدد ورودی دوم‬ ‫‪b‬‬

‫حاصل عبارت‬ ‫‪f‬‬

‫‪ .0‬مالول را ذخیره و اجرا کرده‪ ،‬جلوی ‪ a:‬و ‪ b:‬به ترتیب ‪ 7‬و ‪ 2‬را وارد کنید تا خروجی زیر را ببینید‪:‬‬
‫‪Enter a: 7‬‬
‫‪Enter b: 2‬‬
‫‪f is 7.0‬‬
‫مثال‪‌.4‬برنامه‌ای‌که‌یک‌عدد‌دورقمی‌را‌خواند ‪‌،‬حاصل‌رقم‌اول‌به‌توان‌رقم‌دوم‌و‌رقم‌دوم‌به‌توان‌‬
‫رقم‌اول‌را‌نمایش‌میدهد‪‌‌.‬‬
‫‌‬
‫مراحل‌طراحی‌و‌اجرا‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫))" ‪a = int(input("Enter a:‬‬ ‫هد ‌‬ ‫متغیر‌‬
‫‪r1 = a % 10‬‬
‫عدد دورقمی‬ ‫‪a‬‬
‫‪r2 = a // 10‬‬
‫)‪print(r1," ** ",r2, " = ", r1 ** r2‬‬ ‫‪r1‬‬
‫رقم یکان‬
‫)‪print(r2," ** ",r1, " = ", r2 ** r1‬‬
‫رقم دهگان‬ ‫‪r2‬‬

‫‪ .0‬مالول را ذخیره و اجرا کرده‪ ،‬عدد ‪ 9۳‬را وارد کنید تا خروجی زیر را ببینید‪:‬‬
‫‪Enter a: 34‬‬
‫‪4 ** 3 = 64‬‬
‫‪3 ** 4 = 81‬‬
‫میکند‪‌.‬‬
‫برنامهای‌که‌دو‌عدد‌را‌خواند ‪‌،‬بدون‌استفاد ‌از‌متغیر‌کم ی‌محتوی‌آن‌ها‌را‌تعویض‌ ‌‬
‫‌‬ ‫مثال‪‌.3‬‬
‫مراحل‌‌طراحی‌و‌اجرا‌‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫))" ‪a = int(input("Enter a:‬‬ ‫هد ‌‬ ‫متغیر‌‬ ‫‌‬
‫))" ‪b = int(input("Enter b:‬‬ ‫‪a‬‬
‫عدد ورودی اول‬
‫‪a, b = b, a‬‬
‫)‪print("a = ", a‬‬ ‫عدد ورودی دوم‬ ‫‪b‬‬
‫)‪print("b = ", b‬‬

‫‪@PythonForever‬‬
 ‫‪ 11‬فصل اول‬

‫‪ .0‬مالول را ذخیره و اجرا کرده‪ ،‬جلوی ‪ a:‬و ‪ b:‬به ترتیب اعداد ‪ 02‬و ‪ 60‬را وارد کنید تا خروجی زیر‬
‫را ببینید‪:‬‬
‫‪Enter a: 12‬‬
‫‪Enter b: 20‬‬
‫‪a = 20‬‬
‫‪b = 12‬‬
‫مثال‪‌.6‬برنامه‌ای‌که‌ارتفاع‌و‌قاعد ‌مثلهث‌را‌از‌ورودی‌خوانهد ‪‌،‬مسهاحت‌آن‌را‌محاسهبه‌مهی‌کنهد‌‌و‌‬
‫نمایش‌میدهد‪.‬‬
‫‌‬
‫ارتفاع‬ ‫قاعده‬
‫مساحت مثلث‬
‫مراحل‌طراحی‌و‌اجرا‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده و در آن دستورات زیر را تایپ کنید‪:‬‬

‫))" ‪a = int(input("Enter a:‬‬ ‫هد ‌‬ ‫متغیر‌‬
‫))" ‪h = int(input("Enter h:‬‬
‫قاعده‬ ‫‪a‬‬
‫‪s=a*h/2‬‬
‫)‪print("Area is ", s‬‬ ‫ارتفاع‬ ‫‪h‬‬

‫مساحت مثلث‬ ‫‪s‬‬

‫‪ .0‬مالول را ذخیره و اجرا کنید‪ .‬اکنون به ترتیب اعداد ‪ 7‬و ‪ 3‬را جلوی ‪ a:‬و ‪ h:‬وارد کرده تا خروجای‬
‫زیر را ببینید‪:‬‬
‫‪Enter a: 7‬‬
‫‪Enter h: 9‬‬
‫‪Area is 31.5‬‬
‫مثال‪‌.7‬یک‌دوچرخه‌سوار‌با‌سرعت‌‪‌x‬کیلومتر‌بر‌ساعت‌شروع‌به‌حرکهت‌مهی‌کنهد‌و‌پها‌از‌‪‌n‬دقیقهه‌‬
‫سرعت‌آن‌به‌‪‌k‬کیلومتر‌بر‌ساعت‌می‌رسد‪‌.‬برنامه‌ای‌که‌با‌استفاد ‌از‌فرمهول‌زیهر‌شهتا ‌دوچرخهه‌سهوار‌را‌‬
‫محاسبه‌کرد ‪‌،‬نمایش‌می‌دهد‪‌:‬‬

‫سرعت نهایی‬ ‫سرعت اولیه‬

‫شتاب‬
‫زمان به دقیقه‬
‫مراحل‌طراحی‌و‌اجرا‪‌:‬‬

‫‪ .6‬مالول جدید ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫هد ‌‬ ‫متغیر‌‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪10‬‬

‫))" ‪x = int(input("Enter x:‬‬ ‫سرعت اولیه‬ ‫‪x‬‬

‫))" ‪k = int(input("Enter k:‬‬
‫))" ‪n = int(input("Enter n:‬‬ ‫سرعت نهایی‬ ‫‪k‬‬
‫‪a = (k- x) * 60 / n‬‬
‫مدت به دقیقه‬ ‫‪n‬‬
‫)‪print("a is ", a‬‬
‫شتاب محاسبهشده‬ ‫‪a‬‬

‫‪ .0‬مالول را ذخیره و اجرا کرده‪ ،‬جلوی ‪ ،n: ،k: ،x:‬به ترتیب ‪ 9 ،60 ،62‬را وارد کنید تا خروجی زیار‬
‫را ببینید‪:‬‬
‫‪Enter x: 10‬‬
‫‪Enter k: 20‬‬
‫‪Enter n: 3‬‬
‫‪a is 200.0‬‬
‫برنامهای‌که‌توان‌‪‌،8‬توان‌‪‌4‬و‌توان‌‪‌3‬اعداد‌‪‌1‬تا‌‪‌9‬را‌چاپ‌کند‪‌.‬‬
‫‌‬ ‫مثال‪.8‬‬
‫مراحل‌طراحی‌و‌اجرا‪‌:‬‬

‫‪ .6‬مالول جدید ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫)"‪print('---', '\t', "---", '\t', "---‬‬
‫)‪print(1 ** 2, '\t', 1 ** 3, '\t', 1 ** 4‬‬
‫)‪print(2 ** 2, '\t', 2 ** 3, '\t', 2 ** 4‬‬
‫)‪print(3 ** 2, '\t', 3 ** 3, '\t', 3 ** 4‬‬
‫)‪print(4 ** 2, '\t', 4 ** 3, '\t', 4 ** 4‬‬
‫)‪print(5 ** 2, '\t', 5 ** 3, '\t', 5 ** 4‬‬
‫)‪print(6 ** 2, '\t', 6 ** 3, '\t', 6 ** 4‬‬
‫)‪print(7 ** 2, '\t', 7 ** 3, '\t', 7 ** 4‬‬
‫)‪print(8 ** 2, '\t', 8 ** 3, '\t', 8 ** 4‬‬
‫)‪print(9 ** 2, '\t', 9 ** 3, '\t', 9 ** 4‬‬
‫‪ .0‬مالول را ذخیره و اجرا کرده تا خروجی زیر را ببینید‪:‬‬
‫‪--- ---‬‬ ‫‪---‬‬
‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬
‫‪4‬‬ ‫‪8‬‬ ‫‪16‬‬
‫‪9‬‬ ‫‪27‬‬ ‫‪81‬‬
‫‪16 64‬‬ ‫‪256‬‬
‫‪25 125‬‬ ‫‪625‬‬
‫‪36 216‬‬ ‫‪1296‬‬
‫‪49 343‬‬ ‫‪2401‬‬
‫‪64 512‬‬ ‫‪4096‬‬
‫‪81 729‬‬ ‫‪6561‬‬

‫‪@PythonForever‬‬
 ‫‪ 11‬فصل اول‬

‫همانطور که در کد این برنامه مشاهده مایشاود‪ ،‬هریاک از اعاداد ‪ 6‬تاا ‪ 3‬را در یاک ساطر تایاپ‬
‫کردیم که با بیان حلقه تکرار در فصل بعدی نیازی به تکرار ‪ 3‬سطر نمیباشد‪.‬‬
‫یدههد‌‪‌‌.‬اگهر‌‬
‫مثال‪‌.7‬برنامهای‌که‌مختصات‌دونقطه‌را‌خواند ‪‌،‬فاصله‌بین‌دونقطه‌را‌محاسبه‌و‌نمایش‌م ‌‬
‫زیر‌محاسبه‌میشود‪‌:‬‬
‫‌‬ ‫دونقطه‌(‪‌)x1 , y1‬و‌(‪‌)‌x2 , y2‬باشند‪‌،‬فاصله‌بین‌دونقطه‌ ‌‬
‫بهصورت‌‬

‫مراحل‌طراحی‌و‌اجرا‌‪‌:‬‬

‫‪ .6‬مالول جدیدی را ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫))" ‪x1 = int(input("Enter x1:‬‬ ‫هد ‌‬ ‫متغیر‌‬
‫))" ‪y1 = int(input("Enter y1:‬‬ ‫‪x1‬‬
‫مختصات ‪ x‬نقطه اول‬
‫))" ‪x2 = int(input("Enter x2:‬‬
‫))" ‪y2 = int(input("Enter y2:‬‬ ‫مختصات ‪ y‬نقطه اول‬ ‫‪y1‬‬
‫))‪d = ((x2 ** 2 - x1 ** 2) + (y2 ** 2 - y1 ** 2‬‬
‫‪** 0.5‬‬ ‫مختصات ‪ x‬نقطه دوم‬ ‫‪x1‬‬
‫)‪print("distance is " , d‬‬
‫مختصات ‪ y‬نقطه دوم‬ ‫‪y2‬‬

‫فاصله دونقطه‬ ‫‪d‬‬

‫‪ .0‬مالول را ذخیره و اجرا کرده‪ ،‬اطالعات زیر را وارد کنید تا فاصله بین دونقطه را مشاهده نمایید‪:‬‬
‫‪Enter x1: 12‬‬
‫‪Enter y1: 14‬‬
‫‪Enter x2: 19‬‬
‫‪Enter y2: 24‬‬
‫‪distance is 24.43358344574123‬‬
‫مثال‪‌.9‬برنامهای‌که‌سه‌مقدار‌را‌خواند ‪‌،‬نوع‌آنها‌را‌نمایش‌میدهد‪‌.‬‬
‫مراحل‌طراحی‌و‌اجرا‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫))" ‪a = int(input("Enter a:‬‬ ‫هد ‌‬ ‫متغیر‌‬
‫))" ‪b = float(input("Enter b:‬‬ ‫‪a‬‬
‫متغیر ورودی از نوع عدد صحیح‬
‫)" ‪c = input("Enter c:‬‬
‫))‪print("Type a is " , type(a‬‬ ‫متغیر ورودی از نوع عدد اعشاری‬ ‫‪b‬‬
‫))‪print("Type b is " , type(b‬‬
‫))‪print("Type c is " , type(c‬‬ ‫متغیر ورودی از نوع رشتهای‬‬ ‫‪c‬‬

‫‪ .0‬پروله را ذخیره و اجرا کارده‪ ،‬و باه ترتیاب مقاادیر ‪ 60 ،0 ،62‬و ‪ string‬را جلاوی‪ b: ، a:‬و ‪ c:‬وارد‬
‫کنید تا خروجی زیر را ببینید‪:‬‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪11‬‬

‫‪Enter a: 10‬‬
‫‪Enter b: 12.5‬‬
‫‪Enter c: string‬‬
‫‪>'Type a is <class 'int‬‬
‫‪>'Type b is <class 'float‬‬
‫‪>'Type c is <class 'str‬‬
‫شناسایی‌این‌اشیاء‌را‌نمایش‌میدهد‪‌.‬‬
‫‌‬ ‫برنامهای‌که‌دو‌مقدار‌را‌خواند ‪‌،‬شمار ‌‬
‫‌‬ ‫مثال‪‌.10‬‬
‫مراحل‌طراحی‌و‌اجرا‌‪‌:‬‬

‫‪ .6‬مالول جدیدی را ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫))" ‪a = int(input("Enter a:‬‬ ‫هد ‌‬ ‫متغیر‌‬
‫)" ‪b = input("Enter b:‬‬ ‫‪a‬‬
‫مقدار ورودی اول‬
‫))‪print("ID a is " , id(a‬‬
‫))‪print("ID b is " , id(b‬‬ ‫مقدار ورودی دوم‬ ‫‪b‬‬

‫‪ .0‬مالول را ذخیره و اجارا کارده‪ ،‬مقاادیر ‪ 62‬و ‪ Fanavarienovin‬را وارد کنیاد تاا خروجای زیار را‬
‫ببینید‪:‬‬
‫‪Enter a: 10‬‬
‫‪Enter b: Fanavarienovin‬‬
‫‪ID a is 1498607696‬‬
‫‪ID b is 58207472‬‬
‫‪‌،‬ارقام‌عدد‌را‌بافاصله‌نمایش‌میدهد‪.‬‬
‫‌‬ ‫برنامهای‌که‌یک‌عدد‌‪‌6‬رقمی‌را‌خواند‬
‫‌‬ ‫پروژ ‌برنامه‌نویسی‌‪‌:1‬‬
‫مراحل‌طراحی‌و‌اجرا‌‪‌:‬‬

‫‪ .6‬مالول جدیدی را ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫هد ‌‬ ‫متغیر‌‬

‫عدد پنجرقمی خواندهشده‬ ‫‪num‬‬

‫متغیر کمکی کاه پاس از حاذف هار‬ ‫‪temp‬‬

‫رقم ‪ num‬را نگهداری میکند‬

‫رقم یکان‬‬ ‫‪a6‬‬

‫رقم دهگان‬ ‫‪a0‬‬

‫رقم صدگان‬ ‫‪a9‬‬

‫رقم هزارگان‬ ‫‪a۳‬‬

‫‪@PythonForever‬‬
 ‫‪ 11‬فصل اول‬

‫))"‪num = int(input("Enter a number:‬‬ ‫رقم ده هزارگان‬ ‫‪a0‬‬

‫‪a1= num % 10‬‬
‫‪temp = num // 10‬‬
‫‪a2 = temp % 10‬‬
‫‪temp = temp // 10‬‬
‫‪a3 = temp % 10‬‬
‫‪temp = temp // 10‬‬
‫‪a4 = temp % 10‬‬
‫‪temp = temp // 10‬‬
‫‪a5 = temp % 10‬‬
‫‪temp = temp // 10‬‬
‫)‪print(a5," ",a4," ",a3," ",a2," ",a1‬‬
‫‪ .0‬مالول را ذخیره و اجرا کرده‪ ،‬عدد ‪ ‌17686‬را وارد کنید تا خروجی زیر را ببینید‪:‬‬
‫‪Enter a number:67181‬‬
‫‪1 8 1‬‬ ‫‪7‬‬ ‫‪6‬‬
‫میدهد‪‌:‬‬
‫برنامهای‌که‌دو‌عدد‌را‌خواند ‪‌،‬اعمال‌زیر‌را‌انجام‌ ‌‬
‫‌‬ ‫برنامهنویسی‪‌.8‬‬
‫‌‬ ‫پروژ ‌‬
‫ها‌را‌نمایش‌میدهد‪‌.‬‬
‫‌‬ ‫‪‌،‬تفریق‪‌،‬حاصلضر ‪‌،‬تقسیم‪‌،‬باقی‌ماند ‌تقسیم‌صحیح‌و‌توان‌آن‌‬
‫‌‬ ‫‪ .1‬حاصل‌جمع‬
‫‪‌.8‬حاصل‌عملگرهای‌‪(‌and‬و‌منطقی)‪( or‌،‬یا‌منطقی)‪(‌&‌،‬و‌بیتی)‪(‌|‌‌،‬یا‌بیتی)‌و‌˄ (یا‌انحصهاری‌بیتهی‌)‌‬
‫ام‌میدهد‪‌.‬‬
‫‌‬ ‫آنها‌را‌انج‬
‫‌‬
‫‪‌.4‬دو‌عدد‌را‌به‌باینری‌نمایش‌داد ‪‌،‬حاصل‌جمع‪‌،‬تفریق‪‌،‬ضر ‪‌،‬تقسیم‪‌،‬باقی‌ماند ‌تقسیم‌و‌توان‌آن‌هها‌‬
‫را‌به‌باینری‌نمایش‌میدهد‪‌.‬‬
‫‌‬
‫‪‌.3‬دو‌عدد‌را‌به‌مبنای‌‪‌7‬تبدیل‌کرد ‪‌،‬حاصل‌جمع‪‌،‬تفریق‪‌،‬ضر ‪‌،‬تقسهیم‪‌،‬بهاقی‌مانهد ‌تقسهیم‌و‌تهوان‌‬
‫تبدیل‌میکند‪‌.‬‬
‫‌‬ ‫آنها‌را‌به‌مبنای‌‪‌7‬‬
‫‌‬
‫‪‌.6‬دو‌عدد‌را‌به‌مبنای‌‪‌17‬تبدیل‌کرد ‪‌،‬حاصل‌جمع‪‌،‬تفریق‪‌،‬ضر ‪‌،‬تقسیم‪‌،‬بهاقی‌مانهد ‌تقسهیم‌و‌تهوان‌‬
‫نماید‌و‌نمایش‌میدهد‪‌.‬‬
‫‌‬ ‫‌‬
‫تبدیل‌می‬ ‫آنها‌را‌به‌مبنای‌‪‌17‬‬
‫‌‬
‫مراحل‌طراحی‌و‌اجرا‌‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات زیر را در آن تایپ کنید‪:‬‬

‫))"‪num1 = int(input("Enter a number1:‬‬
‫))"‪num2 = int(input("Enter a number2:‬‬ ‫هد ‌‬ ‫متغیر‌‬
‫)‪print(num1, " + ", num2, " = ", num1 + num2‬‬ ‫عدد اول خواندهشده‬ ‫‪num1‬‬
‫)‪print(num1, " - ", num2, " = ", num1 - num2‬‬
‫)‪print(num1, " * ", num2, " = ", num1 * num2‬‬ ‫عدد دوم خواندهشده‬ ‫‪num2‬‬
‫)‪print(num1, " / ", num2, " = ", num1 / num2‬‬
‫)‪print(num1, " // ", num2, " = ", num1 // num2‬‬
‫)‪print(num1, " % ", num2, " = ", num1% num2‬‬
‫)‪print(num1, " ** ", num2, " = ", num1 ** num2‬‬

‫‪@PythonForever‬‬
11 ‫آشنایی با زبان پایتون‬

print(num1, " and ", num2, " = ", num1 and num2)
print(num1, " or ", num2, " = ", num1 or num2)
print(num1, " & ", num2, " = ", num1 & num2)
print(num1, " | ", num2, " = ", num1 | num2)
print(num1, " ^ ", num2, " = ", num1 ^ num2)
print(bin(num1), " + ", bin(num2), " = ", bin(num1 + num2))
print(bin(num1), " - ", bin(num2), " = ", bin(num1 - num2))
print(bin(num1), " * ", bin(num2), " = ", bin(num1 * num2))
print(bin(num1), " // ", bin(num2), " = ", bin(num1 // num2))
print(bin(num1), " % ", bin(num2), " = ", bin(num1 % num2))
print(bin(num1), " ** ", bin(num2), " = ", bin(num1 ** num2))
print(oct(num1), " + ", oct(num2), " = ", oct(num1 + num2))
print(oct(num1), " - ", oct(num2), " = ", oct(num1 - num2))
print(oct(num1), " * ", oct(num2), " = ", oct(num1 * num2))
print(oct(num1), " // ", oct(num2), " = ", oct(num1 // num2))
print(oct(num1), " % ", oct(num2), " = ", oct(num1 % num2))
print(oct(num1), " ** ", oct(num2), " = ", oct(num1 ** num2))
print(hex(num1), " + ", hex(num2), " = ", hex(num1 + num2))
print(hex(num1), " - ", hex(num2), " = ", hex(num1 - num2))
print(hex(num1), " * ", hex(num2), " = ", hex(num1 * num2))
print(hex(num1), " // ", hex(num2), " = ", hex(num1 // num2))
print(hex(num1), " % ", hex(num2), " = ", hex(num1 % num2))
print(hex(num1), " ** ", hex(num2), " = ", hex(num1 ** num2))
:‫ دو عدد را وارد کرده تا خروجی زیر را ببینید‬.‫ مالول را ذخیره و اجرا کنید‬.0
Enter a number1:12
Enter a number2:5
12 + 5 = 17
12 - 5 = 7
12 * 5 = 60
12 / 5 = 2.4
12 // 5 = 2
12 % 5 = 2
12 ** 5 = 248832
12 and 5 = 5
12 or 5 = 12
12 & 5 = 4
12 | 5 = 13
12 ^ 5 = 9
0b1100 + 0b101 = 0b10001
0b1100 - 0b101 = 0b111
0b1100 * 0b101 = 0b111100

@PythonForever
 ‫ فصل اول‬11

0b1100 // 0b101 = 0b10

0b1100 % 0b101 = 0b10
0b1100 ** 0b101 = 0b111100110000000000
0o14 + 0o5 = 0o21
0o14 - 0o5 = 0o7
0o14 * 0o5 = 0o74
0o14 // 0o5 = 0o2
0o14 % 0o5 = 0o2
0o14 ** 0o5 = 0o746000
0xc + 0x5 = 0x11
0xc - 0x5 = 0x7
0xc * 0x5 = 0x3c
0xc // 0x5 = 0x2
0xc % 0x5 = 0x2
0xc ** 0x5 = 0x3cc00

@PythonForever
‫آشنایی با زبان پایتون ‪11‬‬

‫فصل‬
‫ساختارهای تصمیم و تکرار‬
‫‪2‬‬

‫در برنامههایی که تاکنون نوشتهایم‪ ،‬دستورات بهصورت پشت سارهم (از اولاین دساتور باه آخارین‬
‫دستور) اجرا میگردیدند‪ .‬در برنامه های واقعی و پیچیده نیاز اسات بعضای از دساتورات تحات شارایط‬
‫خاصی اجرا شوند‪ ،‬و برخی دیگر از دساتورات اجارا نشاوند یاا بعضای از دساتورات چنادین باار اجارا‬
‫گردند‪ .‬برای پیادهسازی چنین برنامههایی از ساختارهای کنترلی استفاده مایشاود‪ .‬سااختارهای کنترلای‬
‫دو نوع هستند که عبارتاند از‪:‬‬
‫‪ .0‬ساختارهای تکرار‬ ‫‪ .6‬ساختارهای تصمیمگیری‬

‫‪ .2-1‬ساختارهای تصمیمگیری‬
‫این ساختارها برای مواقعی بهکار میروند که بخواهید با برقرار شذن شارط خاصای‪ ،‬مجموعاهای از‬
‫دستورات اجرا شوند یا بعضی از دساتورات دیگار اجارا نشاوند‪ .‬در اداماه سااختارهای تصامیم را مای‪-‬‬
‫آموزیم‪.‬‬
‫ساختار تصمیم ‪if‬‬
‫‪6‬‬
‫ارزیابی میشود‪ ،‬اگر نتیجه ارزیابی شرط درست (‪ )True‬باشد‪ ،‬یک‬ ‫شرطی‬ ‫در این ساختار ابتدا‬
‫مجموعه از دستورات اجرا میشوند‪ ،‬وگرنه‪ ،‬مجموعه دیگری از‬
‫‪:‬شرط ‪if‬‬ ‫دستورات اجرا خواهند شد‪ .‬این ساختار به صورتهای زیر‬
‫مجموعه‌دستورات‌‬ ‫‌‬
‫بهکار میرود‪:‬‬
‫‌تک‌انتخابی‪ ،‬این دستور یک دستور مرکب است که بهصورت زیر بهکار میرود‪:‬‬ ‫ساختار‌ساد‬ ‫‪.6‬‬

‫‪1‬‬
‫‪Condition‬‬

‫‪@PythonForever‬‬
 ‫‪ 11‬فصل اول‬

‫مجموعه‌‬ ‫در این ساختار‪ ،‬ابتدا شرط ارزیابی میشود‪ ،‬اگر نتیجه ارزیابی شرط ‪( True‬درست) باشد‪،‬‬
‫دستورات اجرا خواهند شد‪ ،‬در غیر اینصورت‪ ،‬از اجرای مجموعه دستورات صرف نظر خواهد شد و‬
‫اولین دستور بعد از ‪if‬‫اجرا خواهد شد‪.‬‬
‫در هنگام استفاده از ساختار ‪ if‬به نکات زیر دقت کنید‪:‬‬
‫‪ .0‬در این ساختار شرط میتواند مرکب باشد‪ .‬یعنی‪ ،‬میتوان با عملگرهای ‪ or ،and‬شرطهای‬
‫مرکب را ایجاد نمود‪ .‬به عنوان مثال‪ ،‬شرط مرکب میتواند‬

‫‪x>10 and x<19‬‬ ‫بهصورت زیر بیان گردد‪.‬‬

‫این شرط بررسی میکند که ‪ x‬بین ‪ 62‬تا ‪ 63‬است یا خیر؟‬
‫‪ .9‬برای تست برابری باید از عملگر == استفاده کرد‪.‬‬
‫امه ای‌که‌عددی‌صحیح‌را‌خواند ‪‌،‬قدرمطلق‌آن‌را‌نمایش‌می‌دهد‌(هد ‌این‌برنامه‌‬
‫مثال‌‪ .8-1‬برن ‌‬
‫آشنایی‌با‌ساختار‌‪ if‬ساد ‌است)‪‌.‬‬
‫مراحل‌طراحی‌و‌اجرا‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫))"‪n = int(input("Enter a number:‬‬
‫‪if n < 0 :‬‬ ‫هد ‌‬ ‫متغیر‌‬
‫‪n = -n‬‬
‫))‪print( n‬‬ ‫عدد ورودی‬ ‫‪n‬‬

‫‪ .0‬مالول را ذخیره و اجرا کنید‪ .‬اکنون جلوی ‪ ،number:‬عدد ‪ -62‬را وارد نمایید تا خروجی زیر را‬
‫ببینید‪:‬‬
‫‪Enter a number:-10‬‬
‫‪10‬‬
‫‪ .0‬ساختارهای‌دو‌انتخابی‌‪ ،if‬در ساختار ‪ if‬میتوان کلمه کلیدی ‪ else‬را بهکاربرد‪ ،‬در این صورت‬
‫این ساختار بهصورت زیر استفاده میشود‪:‬‬

‫‪:‬شرط ‪if‬‬ ‫در این ساختار ابتدا شرط ارزیابی میشود‪ .‬اگر نتیجه‬
‫مجموعه‌دستورات‌‪1‬‬
‫‪else:‬‬ ‫ارزیابی شرط درست (‪ )True‬باشد‪ ،‬مجموعه ‌دستورات ‌‪ 1‬و‬
‫مجموعه‌دستورات‌‪8‬‬
‫‪False‬‫ باشد)‪ ،‬مجموعه‌دستورات‌‬ ‫گرنه (نتیجه ارزیابی شرط‬
‫‪ 8‬اجرا خواهند شد‪.‬‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪11‬‬

‫برنامهای‌که‌عددی‌را‌خواند ‪‌،‬تشخیص‌می‌دهد‌زوج‌است‌یا‌فرد‌(هد ‌این‌برنامه‌آشنایی‌‬

‫‌‬ ‫مثال‌‪.8-8‬‬
‫با‌ساختار‌دو‌انتخابی‌‪‌if – else‬است)‪‌.‬‬
‫مراحل‌طراحی‌و‌اجرا‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫))"‪n = int(input("Enter a number:‬‬
‫‪if n % 2 == 1:‬‬ ‫هد ‌‬ ‫متغیر‌‬
‫)"‪print("Odd‬‬
‫‪else:‬‬ ‫عدد ورودی‬ ‫‪n‬‬
‫)"‪print("Even‬‬
‫‪ .0‬مالول را ذخیره و اجرا کرده‪ ،‬عدد ‪ 60‬را وارد کنید تا خروجی زیر را ببینید‪:‬‬
‫‪Enter a number:15‬‬
‫‪Odd‬‬
‫‪ .9‬ساختارهای‌چند‌انتخابی‪ ،‬در این ساختار دستور ‪ if‬را‬
‫‪:‬شرط ‪if‬‬
‫مجموعه‌دستورات‌‪1‬‬ ‫میتوان توسعه داد و بخشهای بیشتری را با شرطهای‬
‫‪ :‬شرط‪elif 0‬‬
‫مجموعه‌دستورات‌‪8‬‬
‫مختلف ایجاد نمود‪ ،‬این دستور بهصورت زیر بهکار‬
‫‪..‬‬
‫‪:‬شرط‪elif n‬‬ ‫میرود‪:‬‬
‫مجموعه‌دستورات‌‪n‬‬
‫‪else:‬‬ ‫در این ساختار ابتادا شرط‪ 1‬ارزیاابی مایشاود‪ ،‬چنانچاه‬
‫مجموعه‌دستورات‪n+1‬‬
‫براباار ‪( True‬درساات) باشااد‪ ،‬مجموعههه‌دسههتورات‪ 1‬اجاارا‬
‫میشوند و سپس دستور بعد از مجموعه‌دستورات‪ n+1‬اجرا خواهند شد‪ ،‬اگر شرط‪ 1‬درسات نباشاد‪ ،‬شهرط‌‪8‬‬

‫ارزیابی میشود‪ ،‬اگر شرط‪ 8‬درست (‪ )True‬باشد‪ ،‬مجموعه‌دستورات‪ 8‬اجرا میشوند‪ ،‬و سپس دستور بعاد‬
‫از مجموعه‌دستورات‪ n+1‬اجرا میگردد‪ ،‬اگر شرط‪ 8‬درست نباشد‪ ،‬شرط‪ 4‬ارزیابی میشاود و ایان روناد تاا‬
‫شرط‪ n‬ادامه مییابد‪ .‬اگر هیچ یاک از شارطهاای ‪ 6‬تاا ‪ n‬درسات نباشاد‪ ،‬مجموعهه‌‌دسهتورات‌‪ n+1‬اجارا‬
‫خواهند شد‪.‬‬
‫در هنگام استفاده از این ساختار به نکات زیر دقت کنید‪:‬‬
‫‪ .6‬تعدا بخشهای ‪ elif‬اختیاری است و محدودیتی در آن وجود ندارد‪.‬‬
‫‪ .0‬بخش ‪ elif‬نمیتواند قبل از ‪ if‬یا بعد از ‪ else‬قرار بگیرد‪.‬‬
‫‪ .9‬در این ساختار وجود ‪ else‬اختیاری است‪.‬‬

‫‪@PythonForever‬‬
 ‫‪ 11‬فصل اول‬

‫برنامهای ‌که ‌عددی ‌را ‌خواند ‪‌ ،‬تشخیص ‌می‌دهد‪‌ ،‬مثبت‪‌ ،‬صفر ‌یا ‌منفی ‌است(هد ‌برنامه‌‬
‫‌‬ ‫مثال ‌‪.8-4‬‬
‫آشنایی‌با‌‪‌if – elif – else‬است)‪‌.‬‬
‫‌مراحل‌طراحی‌و‌اجرا‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫;)"‪val = input("Enter a number:‬‬ ‫هد ‌‬ ‫متغیر‌‬
‫)‪val = int(val‬‬
‫‪if val > 0 :‬‬ ‫رشته و عدد‬ ‫‪val‬‫‬
‫)"‪print ("Entered value is positive‬‬
‫ورودی‬
‫‪elif val == 0:‬‬
‫)"‪print ("Entered value is zero‬‬
‫‪else:‬‬
‫)"‪print ("Entered value is negative‬‬
‫‪ .0‬مالول را ذخیره و اجرا کرده‪ ،‬عدد ‪ -60‬را وارد کنید تا خروجی زیر را ببینید‪:‬‬
‫‪Enter a number:-12‬‬
‫‪Entered value is negative‬‬
‫مثال‌‪ .8-3‬برنامه‌ای‌که‌ضرایب‌یک‌معادله‌درجه‌‪‌8‬را‌خوانهد ‪‌،‬ریشهه‌ههای‌آن‌‌را‌محاسهبه‌مهی‌کنهد‌و‌‬
‫نمایش‌میدهد‪‌.‬‬
‫‌‬

‫توضیح‪ :‬برای محاسبه ریشههاای معادلاه درجاه ‪ 0‬ابتادا ضارایب ‪ c ،b ،a‬را مایخاوانیم‪ .‬ساپس دلتاا‬
‫(‪ )delta‬را به صورت زیر محاسبه میکنیم‪:‬‬
‫‪2‬‬
‫‪delta = b – 4*a*c‬‬

‫اگر ‪ delta‬کوچکتر از صفر باشد‪ ،‬معادله ریشه ندارد‪.‬‬

‫وگرنه‪ ،‬اگر ‪ delta‬برابر صفر باشد‪ ،‬معادله دو ریشه مساوی دارد و ریشههای آن برابر است با‪:‬‬

‫)‪x1 = x2 = -b / (2*a‬‬

‫وگرنه (اگر ‪ )delta > 0‬معادله دارای دو ریشه مختلف است و ریشههاای معادلاه باه صاورت زیار‬
‫محاسبه میشوند‪:‬‬

‫‫‬ ‫‫و‫‬
‫مراحل‌طراحی‌و‌اجرا‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫هد ‌‬ ‫متغیر‌‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪10‬‬

‫‪ a‬ضریب ‪x2‬‬
‫‪ b‬ضریب ‪x‬‬
‫‪ c‬عدد ثابت معادله‬
‫‪ delta‬مقدار دلتا‬
‫‪ x1‬ریشه اول‬
‫‪ x2‬ریشه دوم‬
‫))"‪a = int(input("Enter a:‬‬
‫))"‪b = int(input("Enter b:‬‬
‫))"‪c = int(input("Enter c:‬‬
‫‪delta = b ** 2 - 4 * a * c‬‬
‫‪if delta < 0:‬‬
‫)"‪print("Not root‬‬
‫‪elif delta == 0:‬‬
‫))‪print(" x1 = x2 = ", -b/ (2.0 * a‬‬
‫‪else:‬‬
‫))‪print(" x1 = ", (-b + delta ** 0.5) / (2.0 * a‬‬
‫))‪print(" x2 = ", (-b - delta ** 0.5) / (2.0 * a‬‬
‫‪ .0‬مالول را ذخیره و اجرا کنید‪ .‬اکنون جلوی ‪ ،b: ،a:‬و ‪ c:‬به ترتیب مقادیر ‪ ۳ ،0‬و ‪ 0‬را وارد‬
‫کرده تا خروجی زیر را مشاهده نمایید‪:‬‬
‫‪Enter a:2‬‬
‫‪Enter b:4‬‬
‫‪Enter c:2‬‬
‫‪x1 = x2 = -1.0‬‬
‫‪ .2-5‬مسائل حل شده‬
‫مثال‪‌.1‬برنامه‌ای‌که‌نمر ‌عددی‌دانشجویی‌را‌بر‌مبنای‌‪‌100‬خواند ‪‌،‬باتوجه‌به‌جدول‌زیر‌نمر ‌حرفهی‌‬
‫دانشجو‌را‌نمایش‌میدهد(در‌این‌برنامه‌متغیر‌‪‌grade‬نمر ‌است)‪‌:‬‬
‫‌‬
‫پیغام‌‬ ‫نمر ‌‬
‫‪Fail‬‬ ‫‪0-70‬‬
‫‪Good‬‬ ‫‪71-80‬‬
‫‪Very Good‬‬ ‫‪81-90‬‬
‫‪Excellent‬‬ ‫‪90-100‬‬
‫‪Invalid Grade‬‬ ‫‪<0, >100‬‬
‫مراحل‌طراحی‌و‌اجرا‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫‪@PythonForever‬‬
 ‫‪ 11‬فصل اول‬

‫))" ‪grade = int(input("Enter grade:‬‬

‫‪if (0 <= grade <= 70):‬‬
‫)"‪print("Fail‬‬
‫‪elif 71 <= grade <= 80:‬‬
‫)"‪print("Good‬‬
‫‪elif 81 <= grade <= 90:‬‬
‫)"‪print("Very good‬‬
‫‪elif 91 <= grade <= 100:‬‬
‫)"‪print("Excellent‬‬
‫‪else:‬‬
‫)"‪print("Invalid grade‬‬
‫‪ .0‬مالول را ذخیره و اجرا کرده‪ ،‬عدد ‪ 32‬را وارد نمایید تا خروجی زیر را مشاهده کنید‪:‬‬
‫‪Enter grade: 90‬‬
‫‪Very good‬‬
‫مثال‪‌.8‬برنامه‌ای‌که‌‪‌n‬را‌خواند ‪‌‌،‬اعداد‌‪‌n‬تا‌‪‌1‬نمایش‌می‌دهد‌و‌در‌پایان‌حاصل‌ضر ‌ایهن‌اعهداد‌را‌‬
‫نمایش‌خواهد‌داد‪‌.‬‬
‫مراحل‌طراحی‌واجرا‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫))"‪n = int(input("Enter n:‬‬ ‫هد‬ ‫متغیر‬
‫‪p=1‬‬
‫‪for i in range(n, 0, -1):‬‬ ‫‪ n‬عدد خوانده شده‬
‫)'‪print(i, end = '\t‬‬
‫‪p=p*i‬‬ ‫‪ i‬از ‪ n‬تا ‪1‬‬
‫)‪print("\nMultiply is ", p‬‬
‫‪ p‬حاصل ضرب اعداد ‪ n‬تا ‪1‬‬

‫‪ .0‬مالول را ذخیره و اجرا کرده‪ ،‬عدد ‪ 60‬را وارد نمایید تا خروجی زیر را مشاهده کنید‪:‬‬
‫‪Enter n:12‬‬
‫‪12‬‬ ‫‪11‬‬ ‫‪10‬‬ ‫‪9‬‬ ‫‪8‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫‪3‬‬ ‫‪1‬‬
‫‪Multiply is 479001600‬‬
‫ترین‌رقم‌آن‌را‌نمایش‌میدهد‪‌‌.‬‬
‫‌‬ ‫برنامهای‌که‌عددی‌را‌خواند ‪‌،‬بکرگ‌‬
‫‌‬ ‫مثال‌‪‌.4‬‬
‫مراحل‌طراحی‌و‌اجرا‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را به صورت زیر تایپ کنید‪:‬‬

‫))"‪n = int(input("Enter n:‬‬
‫‪max = n % 10‬‬ ‫هد ‌‬ ‫متغیر‌‬
‫‪while n > 0:‬‬ ‫‪ n‬عدد خوانده شده‬
‫‪if max < n % 10 :‬‬
‫‪max = n % 10‬‬ ‫‪ max‬بزرگترین رقم‬
‫‪n = n // 10‬‬
‫)‪print("Max is ", max‬‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪11‬‬

‫‪ .0‬مالول را ذخیره و اجرا کرده‪ ،‬عدد ‪ 801۳326‬را وارد کنید تا خروجی زیر را ببینید‪:‬‬
‫‪Enter n:8564901‬‬
‫‪Max is 9‬‬
‫برنامهای‌که‌عددی ‌را‌خواند ‪‌،‬مشخص‌می‌نماید‌که‌آیا‌عدد‌خواند ‌شد ‌اول‌است‌یا‌خیر؟‌‬
‫‌‬ ‫مثال‌‪‌.3‬‬
‫نصف‌خودش‌به‌جک‌یک‌بخشپذیر‌باشد‪‌،‬عدد‌اول‌نیست‪‌‌.‬‬
‫‌‬ ‫عدد‌کوچکتر‌یا‌مساوی‌‬
‫‌‬ ‫اگر‌عددی‌بر‌یک‌‬
‫مراحل‌طراحی‌و‌اجرا‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را به صورت زیر تایپ کنید‪:‬‬

‫))"‪n = int(input("Enter n:‬‬
‫‪isPrime = True‬‬ ‫هد ‌‌‬ ‫متغیر‌‬
‫‪for i in (2, n // 2+ 1):‬‬ ‫‪ n‬عدد خوانده شده‬
‫‪if n % i == 0:‬‬
‫‪isPrime = False‬‬ ‫آیا ‪ n‬اول است یا نه (اگر اول نباشد‬
‫‪break‬‬ ‫‪isPrime‬‬
‫‪if (isPrime == True):‬‬ ‫‪ isPrime‬برابر ‪ False‬خواهد شد)‪.‬‬
‫)"‪print("Yes‬‬
‫‪else:‬‬ ‫‪ n‬میشمارد‪.‬‬ ‫‪ i‬شمارندهای که از ‪ 2‬تا‬
‫‪2‬‬
‫)"‪print("No‬‬
‫‪ .0‬مالول را ذخیره و اجرا کنید‪ .‬عدد ‪ 97‬را وارد کرده تا خروجی زیر را مشاهده نمایید‪.‬‬
‫‪Enter n:37‬‬
‫‪Yes‬‬
‫ای‌که‌رشتهای‌را‌خواند ‪‌،‬تعداد‌ارقام‌رشته‌را‌نمایش‌می‌دهد‪‌‌.‬‬
‫‌‬ ‫‌‬
‫برنامه‬‫مثال‌‪‌.6‬‬
‫مراحل‌طراحی‌و‌اجرا‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را به صورت زیر تایپ کنید‪:‬‬

‫)"‪s = input("Enter a string:‬‬ ‫هد ‌‌‬ ‫متغیر‌‬
‫‪count = 0‬‬
‫‪for i in s :‬‬ ‫‪ s‬رشته دریافتی از ورودی‬
‫‪if '0' <= i <= '9':‬‬
‫‪ count‬تعداد ارقام موجود در رشته ‪s‬‬
‫‪count = count + 1‬‬
‫)‪print("Count is ", count‬‬ ‫‪ i‬هر کاراکتر رشته‬

‫‪ .0‬مالول را ذخیره و اجرا کرده‪ ،‬اطالعات زیر را وارد کنید تا خروجی را ببینید‪:‬‬
‫‪Enter a string:One equal 1 and Seven equal 7.‬‬
‫‪Count is 2‬‬
‫مثال‌‪‌.7‬برنامه‌ای‌که‌تعدادی‌عدد‌را‌خواند ‪‌،‬اعدادی‌کهه‌همهه‌ارقهام‌آن‌هها‌برابهر‌باشهند‌را‌نمهایش‌‬
‫می‌دهد‪‌.‬درپایان‪‌،‬میانگین‌اعدادی‌که‌تمام‌ارقام‌آن‌ها‌برابر‌است‌را‌نمایش‌می‌دهد‪‌.‬کاربر‌برای‌خهروج‌از‌‬
‫برنامه‌عدد‌‪‌-99‬را‌وارد‌میکند‪‌‌.‬‬
‫مراحل‌طراحی‌و‌اجرا‪‌:‬‬

‫‪@PythonForever‬‬
 ‫‪ 11‬فصل اول‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را به صورت زیر تایپ کنید‪:‬‬

‫هد ‌‌‬ ‫متغیر‌‬

‫‪count, sum = 0, 0‬‬
‫‪while 1:‬‬ ‫تعداد اعدادی که ارقام آنها برابر‬
‫))"‪n = int(input("Enter a number:‬‬ ‫‪count‬‬
‫است‪.‬‬
‫‪if n == -99:‬‬
‫‪break‬‬ ‫مجموع اعدادی که ارقام آنها برابر‬
‫‪r = n % 10‬‬ ‫‪sum‬‬
‫‪m=n‬‬ ‫است‪.‬‬
‫‪while n > 0:‬‬
‫‪if n % 10 !=r:‬‬ ‫‪ n‬عددی که هر بار میخواند‬
‫‪break‬‬
‫‪n = n // 10‬‬ ‫عدد ‪ n‬را خوانده شده را نگه داری‬
‫‪if n == 0:‬‬
‫‪ m‬میکند‪ ،‬چون با جدا کردن ارقام عدد‬
‫‪count = count + 1‬‬
‫‪sum = sum + m‬‬ ‫‪ ،n‬صفر خواهد شد(یا تغییر مییابد)‬
‫)‪print(m‬‬
‫‪if count > 0:‬‬
‫)‪print(sum / count‬‬
‫‪ .0‬مالول را ذخیره و اجرا کرده‪ ،‬اطالعات زیر را تایپ کرده تا خروجی را ببینید‪:‬‬
‫‪Enter a number:111‬‬
‫‪111‬‬
‫‪Enter a number:156‬‬
‫‪Enter a number:555‬‬
‫‪555‬‬
‫‪Enter a number:889‬‬
‫‪Enter a number:7779‬‬
‫‪Enter a number:3444‬‬
‫‪Enter a number:987‬‬
‫‪Enter a number:444‬‬
‫‪444‬‬
‫‪Enter a number:-99‬‬
‫‪370.0‬‬
‫مثال‌‪‌.8‬برنامه‌ای‌که‌عددی‌را‌خواند ‪‌،‬اگر‌باقی‌ماند ‌عدد‌به‌‪‌،8‬صفر‌بود‪‌،‬شنبه‪‌،‬یهک‌بهود‪‌،‬ی شهنبه‪‌،‬دو‌‬
‫بود‪‌،‬جمعه‌را‌نشان‌میدهد‌(‪‌n‬عدد‌خواند ‌شد ‌است)‪‌.‬‬
‫‌‬ ‫بود‪‌،‬دوشنبه‌و‌همینطور‌اگر‌‪‌7‬‬
‫‌‬
‫مراحل‌طراحی‌و‌اجرا‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را به صورت زیر تایپ کنید‪:‬‬

‫))"‪n = int(input("Ente a number:‬‬
‫‪n=n%7‬‬
‫‪if n == 0:‬‬

‫‪@PythonForever‬‬
11 ‫آشنایی با زبان پایتون‬

‫ مالول‬.0 print('Satarday')
elif n == 1:
‫را ذخیره و‬ print('Sunday')
elif n == 2:
print('Monday ')
،‫کرده‬ ‫اجرا‬
elif n == 3:
print('Tuesday')
‫عدد‬ n ‫جلوی‬
elif n == 4:
print('Wednesday')
‫ را وارد‬60
elif n == 5:
print('Thursday')
‫تا‬ ‫کنید‬
elif n == 6:
print('Friday')
‫خروجی زیر را‬
else:
print('Invalid number ')
:‫ببینید‬
Enter a number:12
Thursday

@PythonForever
 ‫‪ 11‬فصل اول‬

‫فصل‬
‫توابع‬
‫‪3‬‬

‫ساختار یک برنامه خیلی شبیه به ساختار یک سازمان اسات‪ .‬یعنای‪ ،‬در هار ساازمان سااختار سلساله‬
‫مراتبی حاکم است‪ .‬در باالترین سطح سازمان‪ ،‬مدیریت قرار دارد‪ .‬هر مدیر میتواند چند معااون داشاته‬
‫باشد‪ .‬هر یک از معاونین نیز میتوانند چندین کارمناد داشاته باشاند‪ .‬ایان برناماههاا مانناد شارکتهاای‬
‫کوچک هستند که مدیر شرکت همه کارهای شرکت را انجام میدهد‪ .‬ولی‪ ،‬در بسایاری از ساازمانهاا‬
‫چنین وضعیتی حاکم نیست‪ .‬برنامههای واقعی و کاربردی مانند سازمانهاای بازرگ طاوالنی و پیچیاده‬
‫هستند‪.‬‬
‫مدیر برای انجام هر وظیفهاش یکی از توابع (معاونین) خودش را صدا میزند و احتماالً پارامترهاای‬
‫(پروندههای) را در اختیار او قرار داده‪ ،‬از او میخواهد کار را انجام داده‪ ،‬نتیجه را برگرداند‪ .‬هر یک از‬
‫توابع (معاونین) نیز خود توابع دیگر (کارمندان خودش) را صدا میزنناد تاا بخشای از کاار را باه آنهاا‬
‫محول نمایند و این روند تا انجام کار ادامه دارد‪ .‬با این تفاسیر‪ ،‬کاربری که از برنامه اساتفاده ماینمایاد‪،‬‬
‫نقش مشتری را بازی خواهد کرد که میتواند اطالعاتی را در اختیار سازمان (برنامه) قرار داده‪ ،‬نتاایجی‬
‫را دریافت کند‪.‬‬
‫استفاده از تابع در برنامهنویسی دارای مزایای زیر است‪:‬‬
‫‪ .0‬برنامهنویسی ساخت یافته را امکانپذیر میکند‪.‬‬
‫‪ .2‬خوانایی برنامه را افزایش میدهد‪ .‬همچنین تست‪ ،‬اشاکالزدایای و خطایاابی برناماه نیاز آساانتار‬
‫خواهد شد‪ .‬چون‪ ،‬برنامهها به بخشهای کوچکتری تبدیل میشوند‪ .‬لذا‪ ،‬خطایابی و اصاال برناماه‪-‬‬
‫های کوچکتر آسانتر خواهد بود‪.‬‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪11‬‬

‫‪ .3‬میتوان توابع مورد نیاز را در یک برنامه نوشت و از آنها در برنامههای دیگار نیاز اساتفاده کارد‪.‬‬
‫‌مجدد‪ 0‬نام دارد‪ .‬بدین ترتیب‪ ،‬کد نویسی کمتر خواهد شد و تولید نارمافازار ساریعتار‬ ‫این امر‪ ،‬استفاد‬

‫انجام میشود‪.‬‬
‫‪ .4‬توابع‪ ،‬امکان کار گروهی را فراهم میکنند‪ .‬زیرا‪ ،‬پس از این که برنامه به بخشهای کوچکتاری‬
‫تقسیم شدند‪ ،‬هر یک از اعضای گروه وظیفه نوشتن و تست توابع مشخص را بر عهده میگیرند‪ .‬بدین‬
‫ترتیب‪ ،‬اعضای گروه به صورت همزمان روی بخشهای مختلف برنامه کار میکنند (بادون ایان کاه‬
‫منتظر همدیگر باشند)‪ .‬انجام کار به صورت گروهی موجب میشود تا برنامهها سریعتر آماده شوند‪.‬‬
‫‪ .5‬توابع امکان استفاده از کارهایی که دیگران انجام دادهاناد‪ ،‬را فاراهم مایکنناد‪ .‬یعنای‪ ،‬در برناماه‪-‬‬
‫هایتان میتوانید از توابعی که دوستانتان آماده کردهاند‪ ،‬استفاده کنید‪.‬‬
‫‪ .6‬توابع‪ ،‬امکان ایجاد کتابخانه را فراهم میکنند‪ .‬کتابخانه‪ ،‬مجموعه توابعی هستند که ماورد نیازتاان‬
‫میباشند ( مجموعه توابعی که به هم مرتبطاند)‪ .‬بنابراین‪ ،‬میتوان مجموعه تواباع مارتبط باه هام را در‬
‫یک فایل کتابخانه (بسته) قرار داد و در برنامهها از این فایل کتابخانه استفاده نمود‪.‬‬

‫‪ .3 – 0‬انواع توابع‬
‫در هر زبان برنامهنویسی دو نوع تابع وجود دارد که عبارتاند از‪:‬‬
‫‪ .0‬توابع‌کتابخانهای‪ ،‬توابعی میباشند که همراه کامپایلر یا مفسر وجود دارند‪ .‬این تواباع را تواباع‬
‫عمومی نیز مینامند‪ .‬زیرا‪ ،‬کاربردهای زیادی دارند‪ .‬توابع کتابخانهای را با توجاه باه کااربرد آنهاا‬
‫دستهبندی کردند و هر یک از دستهها را در فایل مالول خاصی قرار دادهاند‪ .‬تااکنون باا برخای از‬
‫این توابع نظیر )(‪ int() ،print‬آشنا شدید‪ .‬در اداماه باا بعضای از تواباع مهام کتابخاناهای باه هماراه‬
‫کاربرد آنها آشنا خواهید شد‪.‬‬

‫‪@PythonForever‬‬
 ‫‪ 11‬فصل اول‬

‫‪ .3 – 2‬توابعی که برنامه نویس مینویسد‬

‫همانطور که میدانید پایتون شامل مالولهای متنوعی است‪ .‬اماا‪ ،‬باا ایان وجاود‪ ،‬تواباع موجاود در‬
‫مالول پایتون‪ ،‬پاسخگوی همه در خواستهای برنامهنویس نیستند‪ .‬لذا‪ ،‬برنامهنویس بایاد بتواناد تاوابعی‬
‫را نوشته‪ ،‬از آنها استفاده کند‪ .‬برای این منظور‪ ،‬برنامهنویس باید دو کار زیر را انجام دهد‪:‬‬
‫‌‪‌.1‬نوشتن‌تابع‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‪‌.8‬فراخوانی‌تابع‌‬

‫‪ .3 – 2 – 1‬نوشتن تلبع‬
‫برای نوشتن تابع باید آن را تعریف کرد‪:‬‬

‫تعریف تابع‬
‫قبل از این که تابعی را بنویسید باید تابع را تعریف کنید‪ .‬تعریف تابع تعیین مایکناد‪ ،‬ایان تاابع چاه‬
‫ورودیهای دارد‪ ،‬چه چیزی را برمیگرداند (خروجای تاابع چیسات) و چاه عملای را انجاام مایدهاد‪.‬‬
‫الگوی (امضای) تابع‪ ،‬به صورت زیر است‪:‬‬
‫‪(‌:‬لیست‌پارامترها)‌نام‌تابع‌‌‌‌‌‌‌‪def‬‬
‫بدنه‌تابع‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‬

‫توابع از لحاظ مقداری که برمیگردانند به سه نوع زیر تقسیم میشوند‪:‬‬

‫‪ .1‬توابعی‌که‌هیچ‌مقداری‌را‌برنمیگردانند (مثال ‪ 9 – 6‬را ببینید)‪.‬‬
‫‪ .2‬توابعی‌که‌فقط‌یک‌مقدار‌را‌برمیگردانند‪ .‬برخی از این توابع عبارتاند از‪:‬‬
‫‪ .0‬تابعی که بزرگترین مقدار بین سه عدد را برمیگرداند‪.‬‬
‫‪ .2‬تابعی که تعیین میکند عددی اول است یا خیر؟‬
‫‪ .3‬تابعی که تعیین میکند عددی کامل (تام) است یا خیر؟‬
‫‪ .4‬تابعی که حاصل ضرب دو عدد را برمیگرداند‪.‬‬
‫‪ .5‬و غیره‬
‫توابع برای برگشت مقدار از دستور ‪ return‬استفاده میکنند‪ .‬دستور ‪ return‬به صاورتهاای زیار باه‬
‫کار میرود‪:‬‬
‫‪1. return‬‬ ‫;مقدار‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪11‬‬

‫;)عبارت( ‪2. return‬‬

‫;‪3. return‬‬
‫ساختار اول‪ ،‬یک مقدار را برمیگرداند‪ .‬به عنوان مثال‪ ،‬دستورات زیر را ببینید‪:‬‬
‫;‪return False‬‬
‫;‪return 10‬‬
‫دستور اول‪ ،‬مقدار ‪ False‬را برمیگرداند و دستور دوم‪ ،‬مقدار ‪ 62‬را برگشت خواهد داد‪.‬‬
‫اما‪ ،‬ساختار دوم‪ ،‬یک عبارت را ارزیابی کرده‪ ،‬نتیجاه ارزیاابی عباارت را برگشات خواهاد داد‪ .‬باه‬
‫عنوان مثال‪ ،‬دستور زیر را مشاهده کنید‪:‬‬
‫)‪return (2 * i – 3‬‬

‫این دستور ‪ 0 ،‬را در ‪ i‬ضرب کرده‪ 9 ،‬واحد از این حاصل کم میکند و برمیگرداند‪.‬‬
‫ساختار سوم‪ ،‬بدون این که تابع مقداری را برگرداند‪ ،‬از تابع برمیگردد‪.‬‬
‫‪ .3‬توابعی‌که‌چندین‌مقدار‌را‌برمیگردانند‪ .‬این نوع توابع را در ادامه میبینید‪.‬‬
‫‌نام‌تابع‪‌،‬از قانون نامگذاری شناسهها و متغیرها پیروی میکند و برای دسترسی به تابع به کار مای‪-‬‬
‫رود‪.‬‬
‫‌پارامترهای‌تابع‪‌،‬اطالعاتی هستند که در هنگام فراخوانی تابع باید به آن ارسال گردند‪ .‬توابع مای‪-‬‬
‫توانند از لحاظ تعداد پارامترهایی که میپذیرند به گروههای زیر تقسیم گردند‪:‬‬
‫‪‌ .0‬توابع‌بدون‌پارامتر‪ ،‬این توابع معموالً برای چاپ پیغام مشخصی به کار میروند‪.‬‬
‫ن‌است‌یک‌پارامتر‌داشته‌باشد‪ .‬در این صورت باید نام پارامتر تعیین گردد‪.‬‬ ‫تابع‌مم‬ ‫‪.2‬‬
‫برخی از این توابع عبارتاند از‪:‬‬

‫تابعی که عددی را دریافت کرده‪ ،‬تعیین میکند اول است یا خیر؟‬

‫تابعی که عددی را دریافت کرده‪ ،‬تعیین میکند تام است یا خیر؟‬
‫تابعی که عددی را دریافت کرده‪ ،‬فاکتوریل آن را برمیگرداند‪.‬‬
‫تابعی که عددی را دریافت کرده‪ ،‬مجموع ارقام آن را برمیگرداند‪.‬‬
‫ن‌است‌چندین‌پارامتر‌داشته‌باشد‪‌.‬در این صورت باید پارامترها با اساتفاده از کاماا (‪ ) ,‬از‬ ‫تابع‌مم‬

‫هم جدا شوند‪ .‬برخی از این توابع در زیر آمدهاند‪:‬‬

‫‪@PythonForever‬‬
 ‫‪ 11‬فصل اول‬

‫تابعی که دو عدد را دریافت کرده‪ ،‬بزرگترین مقسوم علیه مشترک آنهاا را برمایگرداناد (ایان‬
‫تابع دارای دو پارامتر است)‪.‬‬
‫تابعی که سه عدد را دریافت کرده‪ ،‬کوچکترین عدد را برمیگرداند (این تابع سه پارامتر دارد)‪.‬‬
‫تابعی که دو عدد را دریافت کرده‪ ،‬اولین عدد را به توان عدد دوم رسانده و برمیگرداند‪.‬‬
‫تابعی که دو عدد را گرفته‪ ،‬محتویات آنها را تعویض میکند‪.‬‬
‫و غیره‪.‬‬

‫بدنه تابع‬
‫عملی که تابع باید انجام دهد‪ ،‬در بدنه تابع قرار میگیرد‪‌.‬بدنه‌تابع‪ ،‬مجموعه دساتوراتی هساتند کاه‬
‫تابع باید اجرا کند‪.‬‬

‫‪ .3 – 2 – 2‬فراخوانی تلبع‬
‫دستوری که تابع را صدا زده‪ ،‬از آن استفاده میکناد‪‌،‬فراخهوانی‌تهابع‌ ناام دارد‪ .‬فراخاوانی تاابع باه‬
‫صورت زیر انجام میشود‪:‬‬
‫(لیست‌آرگومانها‌)‌نام‌تابع‬
‫در‌هنگام‌نوشتن‌و‌استفاد ‌از‌توابع‌باید‌به‌ن ات‌زیر‌توجه‌کنید‪‌:‬‬

‫‪ .0‬تعداد پارامترها (در هنگام تعریف تابع) بایاد باا تعاداد آرگوماانهاا (در هنگاام فراخاوانی)‬
‫یکسان باشد (ممکن است نام آنها یکی نباشد)‪.‬‬
‫‪ .2‬در پایتون میتوان تابعی را در داخل تابع دیگر تعریف کرد‪.‬‬

‫درک عملکرد تابع‬

‫برای درک عملکرد توابع‪ ،‬برنامهای را بدون استفاده از توابع و ساپس از طریاق تواباع پیاادهساازی‬
‫میکنیم‪ .‬با همین مثال نیز چگونگی تبدیل یک برنامه معماولی باه تواباع را مایآماوزیم‪ .‬فارض کنیاد‪،‬‬
‫بخواهید برنامهای بنویسید که دو عدد را خوانده‪ ،‬حاصل جمع آنها را نمایش دهد‪ .‬همانطور کاه قابالً‬
‫دیدید‪ ،‬این برنامه به صورت زیر پیادهسازی میشود (روش اول)‪:‬‬
‫)"‪a = int (input("Enter a:‬‬
‫)"‪b = int (input("Enter b:‬‬
‫‪c=a+b‬‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪10‬‬

‫در ایااااااان‬ ‫)‪print (a, "+", b, "=", c‬‬

‫برنامه‪ ،‬مالول اصلی همه کاره است‪ .‬یعنی‪ ،‬دو عدد صحیح را از کاربر (مشتری) گرفته‪ ،‬خودش حاصل‬
‫جمع دو عدد را محاسبه کرده‪ ،‬چاپ میکند (در اختیار مشتری قرار میدهد)‪ .‬این فرآیند در شاکل ‪-6‬‬
‫‪ 9‬آمده است‪.‬‬

‫شکل ‪ 3-1‬فرآیند اجرای برنامه‪.‬‬

‫در روش دوم پیادهسازی‪ ،‬مالول اصلی دو عدد ‪ a‬و ‪ b‬را از کااربر گرفتاه‪ ،‬در اختیاار تاابع ‪addition‬‬

‫(کارمند خودش) قرار میدهد تا حاصل جمع این دو عدد را حساب کند‪ .‬تابع ‪ addition‬پس از محاسبه‬
‫حاصل جمع دو عدد (مانند کارمند) نتیجه را در اختیار مالول اصلی (مدیریت) قرار مایدهاد و ماالول‬
‫اصلی این نتیجه را به کاربر (مشتری) میدهد‪ .‬پیادهسازی این روش به صورت زیر است‪:‬‬
‫‪def addition (a, b):‬‬
‫‪return a + b‬‬
‫)"‪a = int (input("Enter a:‬‬
‫)"‪b = int (input("Enter b:‬‬
‫)‪c = addition (a, b‬‬
‫)‪print( a, " + ", b, " = ", c‬‬
‫‪‬مثال ‪ .3 –5‬برنامهای‌که‌عدد‌‪‌n‬را‌خواند ‪‌،‬اعداد‌کامل‌(تام)‌‪‌1‬تا‌‪‌n‬را‌نمایش‌میدهد‌(ههد ‌ایهن‌برنامهه‌بهه‌‬
‫کارگیری‌مجدد‌تابع‌)(‪‌isPerfect‬نوشته‌شد ‌در‌مثال‌‪‌4-3‬میباشد)‪‌.‬‬
‫مراحل‌طراحی‌و‌اجرا‪:‬‬

‫‪ .1‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را به صورت زیر تایپ کنید‪:‬‬

‫هد ‌‬ ‫م‬ ‫تابع‌‬
‫تغیر‌‬

‫عدد ورودی‬ ‫‪n‬‬ ‫ماااااالول‬

‫‪@PythonForever‬‬
 ‫‪ 11‬فصل اول‬

‫مااالو‬ ‫‪.2‬‬ ‫‪def sum(n):‬‬ ‫شمارنده از ‪ 6‬تا ‪n‬‬ ‫‪i‬‬ ‫اصلی‬

‫‪s=0‬‬
‫‪for i in range(1, n):‬‬ ‫مجمااااوع مقسااااوم‬ ‫‪s‬‬ ‫‪sum‬‬
‫ل را ذخیاااره و‬
‫‪if(n % i == 0):‬‬
‫‪s += i‬‬ ‫علیهها‬
‫اجااارا کااارده‪،‬‬
‫‪return s‬‬
‫شمارنده از ‪ 6‬تا ‪n‬‬ ‫‪i‬‬
‫عااادد ‪ 6222‬را‬ ‫‪def isPerfect(n):‬‬
‫))‪return(n == sum(n‬‬ ‫‪n‬‬
‫پارامتر ورودی‬
‫))"‪n=int(input("Enter n:‬‬
‫وارد کنیاااد تاااا‬
‫‪for i in range(1, n + 1):‬‬ ‫عااادد باااه عناااوان‬ ‫‪n‬‬ ‫‪isPerfe‬‬
‫‪if isPerfect(i) == True:‬‬ ‫‪ct‬‬
‫خروجی زیر را‬
‫)‪print(i‬‬ ‫پارامتر‬
‫ببینید‪:‬‬
‫‪Enter n:1000‬‬
‫‪6‬‬
‫‪28‬‬
‫‪496‬‬
‫‪‬مثال ‪ .3 –6‬برنامهای‌که‌‪‌x‬و‌‪‌n‬را‌خواند ‪‌،‬حاصل‌عبارت‌زیر‌را‌نمایش‌میدهد‪‌:‬‬

‫توضیح‪ :‬در این برنامه تابع )(‪ fact‬برای محاسبه فاکتوریل پیادهسازی شده است‪.‬‬
‫مراحل‌طراحی‌و‌اجرا‪:‬‬

‫‪ .1‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را به صورت زیر تایپ کنید‪:‬‬

‫هد‬ ‫م‬ ‫تابع‬

‫تغیر‬

‫عدد ورودی‬ ‫‪x‬‬ ‫ماااااالول‬

‫‪n‬‬ ‫اصلی‬
‫عدد ورودی‬
‫شمارنده ‪ 9‬تا‪ n‬با گام افزایش ‪9‬‬ ‫‪i‬‬

‫مجموع سری‬ ‫‪s‬‬

‫‪um‬‬
‫عالمت یکای در میاان مثبات و‬ ‫‪s‬‬
‫‪ign‬‬
‫منفی‬
‫پارامتر ورودی‬ ‫‪n‬‬ ‫‪fact‬‬

‫شمارنده ‪ 6‬تا‪n‬‬ ‫‪i‬‬

‫‪def fact(n):‬‬ ‫‪f‬‬

‫فاکتویل ‪n‬‬
‫‪f = 1.0‬‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪11‬‬

‫‪for i in range(1, n+1):‬‬

‫‪f *= i‬‬
‫‪return f‬‬
‫))"‪x=int(input("Enter x:‬‬
‫))"‪n=int(input("Enter n:‬‬
‫‪sum =0.0‬‬
‫‪sign = -1‬‬
‫‪for i in range(3, n + 1, 3):‬‬
‫‪sum = sum + (x ** i) / fact(i) * sign‬‬
‫‪sign = -sign‬‬
‫)‪print("Sum is ", sum‬‬
‫‪ .2‬مالول را ذخیره و اجرا کرده‪ ،‬اعداد ‪ 9‬و ‪ 02‬را وارد کنید تا خروجی زیر را ببینید‪:‬‬
‫‪Enter x:3‬‬
‫‪Enter n:20‬‬
‫‪Sum is -3.540642507299644‬‬
‫‪‬مثال ‪ .3 –7‬برنامهای‌که‌عددی‌را‌خواند ‪‌‌،‬اعداد‌مربعی‌‪‌1‬تا‌آن‌عدد‌را‌نمایش‌میدههد‌‪‌.‬چنهد‌عهدد‌مربعهی‌‬
‫عبارتاند‌از‪:‬‬
‫‪1‬‬ ‫‪4‬‬ ‫‪9‬‬ ‫‪16‬‬ ‫‪25‬‬ ‫‪36‬‬ ‫‪49‬‬ ‫‪64‬‬ ‫…‬
‫مراحل‌طراحی‌و‌اجرا‪:‬‬

‫‪ .1‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را به صورت زیر تایپ کنید‪:‬‬

‫‪def isSquare(n):‬‬ ‫هدف‬ ‫متغ‬ ‫تابع‬
‫‪i=1‬‬ ‫یر‬
‫‪while i * i <= n:‬‬ ‫عدد ورودی‬ ‫‪n‬‬ ‫ماااالول‬
‫‪if (i * i == n):‬‬
‫‪return True‬‬ ‫شمارنده از ‪ 6‬تا ‪n‬‬ ‫‪i‬‬ ‫اصلی‬
‫‪i=i+1‬‬ ‫‪n‬‬
‫پارامتری که بایاد تعیاین‬ ‫‪isSqu‬‬
‫‪return False‬‬
‫‪are‬‬
‫))"‪n = int(input("Enter n:‬‬ ‫شود مربعی است یا نه‬
‫‪for i in range(1, n + 1):‬‬
‫شمارنده از ‪ 6‬تا جذر ‪n‬‬ ‫‪i‬‬
‫‪if isSquare(i) == True:‬‬
‫)'‪print(i, end = '\t‬‬
‫‪ .2‬مالول را ذخیره و اجرا کرده‪ ،‬عدد ‪ 622‬را وارد کنید تا خروجی زیر را ببینید‪:‬‬
‫‪Enter n:100‬‬
‫‪1‬‬ ‫‪4‬‬ ‫‪9 16‬‬ ‫‪25‬‬ ‫‪36‬‬ ‫‪49‬‬ ‫‪64‬‬ ‫‪81‬‬ ‫‪100‬‬

‫‪ .3-‬مسائل حل شده‬
‫‪‬مثال ‪ .1‬برنامه ای‌که‌عددی‌را‌خواند ‪‌،‬رقم‌اول‌از‌سمت‌چپ‌را‌بتوان‌رقم‌دوم‪‌،‬نتیجه‌را‌بهه‌تهوان‌‬
‫رقم‌سوم‌و‌همین‌روند‌را‌ادامه‌میدهد‪.‬‬

‫‪@PythonForever‬‬
 ‫‪ 11‬فصل اول‬

‫مراحل‌طراحی‌و‌اجرا‪:‬‬

‫‪ .1‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را به صورت زیر تایپ کنید‪:‬‬

‫هد‬ ‫متغ‬ ‫تابع‬
‫یر‬

‫مقلوب ‪x‬‬ ‫‪n‬‬ ‫ماااالول‬

‫عدد ورودی‬ ‫‪x‬‬ ‫اصلی‬
‫عددی که باید مقلوب آن حساب شود‬ ‫پااارا‬ ‫‪Revers‬‬
‫‪e‬‬
‫متر ‪n‬‬

‫مقلوب عدد ‪n‬‬ ‫‪s‬‬

‫عددی که باید رقم آن باه تاوان رقام بعادی برساد(از سامت‬ ‫پااارا‬
‫راست)‬ ‫متر ‪n‬‬ ‫‪powDi‬‬
‫‪gits‬‬
‫توان ارقام‬ ‫‪p‬‬

‫‪def reverse(n):‬‬
‫‪s=0‬‬
‫‪while n > 0:‬‬
‫‪s = s * 10 + n % 10‬‬
‫‪n = n // 10‬‬
‫‪return s‬‬
‫‪def powDigits(n):‬‬
‫‪p = n % 10‬‬
‫‪n = n // 10‬‬
‫‪while n > 0:‬‬
‫)‪p = p ** ( n % 10‬‬
‫‪n = n // 10‬‬
‫‪return p‬‬
‫))"‪x = int( input("Enter x:‬‬
‫)‪n = reverse(x‬‬
‫))‪print("Result:", powDigits(n‬‬
‫ماژول‌اصلی‪ ،‬ابتدا عدد را خوانده‪ ،‬آن را مقلوب میکند و در ‪ n‬قرار مایدهاد‪ ،‬ساپس باا فراخاوانی‬
‫تابع )(‪ ،powDigits‬ارقام مقلوب شده را از سمت راست به توان هم میرساند‪.‬‬
‫تابع‌)(‪ ،reverse‬عدد ‪ n‬را به عنوان پارامتر دریافت کرده‪ ،‬آن را مقلوب مینمایاد و در ‪ s‬قارار مای‪-‬‬
‫دهد و ‪ s‬را برمیگرداند‪.‬‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪11‬‬

‫را دریافت کرده‪ ،‬ارقام آن را از سمت راست جدا کرده‪ ،‬هر رقم را به‬ ‫تابع‌)(‪ ،powDigits‬پارامتر ‪n‬‬

‫توان رقم دیگر میرساند( در ‪ p‬قرار میدهد) و نتایج را به توان رقم بعادی مایرسااند‪ .‬ایان عمال را تاا‬
‫آخرین رقم ادامه میدهد و در پایان‪ p ،‬را برمیگرداند‪.‬‬
‫‪ .2‬پروله را ذخیره و اجرا کرده‪ ،‬عدد ‪ 0906‬را وارد کنید تا خروجی را به زیر ببینید‪:‬‬
‫‪Enter x:2351‬‬
‫‪Result: 32768‬‬
‫‪‬مثال ‪ .2‬برنامهای‌که‌عددی‌را‌خواند ‪‌،‬تشخیص‌میدهد‌اول‌یا‌نام‌است‪‌.‬عددی‌اول‌است‌که‌مجموع‌مقسوم‌‬
‫علیههای‌کوچکتر‌از‌خودش‌برابر‌یک‌باشد‌و‌عددی‌تام‌(کامل)‌است‌که‌مجموع‌مقسهوم‌علیهه‌ههای‌کوچهک‌تهر‌از‌‬
‫خودش‌برابر‌خودش‌باشد‪.‬‬
‫مراحل‌طراحی‌و‌اجرا‪:‬‬

‫‪ .1‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را به صورت زیر تایپ کنید‪:‬‬

‫هد‬ ‫متغ‬ ‫تابع‬
‫یر‬

‫عدد ورودی‬ ‫‪x‬‬ ‫مااااااالول‬

‫اصلی‬
‫عددی که باید مجموع مقسوم علیههای آن حسااب‬ ‫پااارا‬ ‫‪sumDivi‬‬
‫‪ded‬‬
‫‪def sumDivided(n):‬‬ ‫شود‪.‬‬ ‫متر ‪n‬‬
‫‪s=0‬‬
‫‪for i in range(1, n):‬‬ ‫مجموع مقسوم علیهها‬ ‫‪s‬‬
‫‪if n % i == 0:‬‬
‫شمارنده از ‪ 6‬تا ‪n-1‬‬ ‫‪i‬‬
‫‪s += i‬‬
‫‪return s‬‬
‫عددی که باید تعیین شود اول است یا خیر؟‬
‫‪def isPrimary(n):‬‬
‫پااارا‬
‫‪isPrimar‬‬
‫‪return sumDivided(n) == 1‬‬ ‫متر ‪k‬‬ ‫‪y‬‬
‫‪def isPerfect(n):‬‬
‫عددی که باید تعیین شود کامل است یا خیر؟‬ ‫پاارام‬
‫‪isPerfect‬‬
‫تر ‪k‬‬

‫‪@PythonForever‬‬
 ‫‪ 11‬فصل اول‬

‫‪return sumDivided(n) == n‬‬

‫))"‪x = int( input("Enter a number:‬‬
‫‪if isPrimary(x) == True :‬‬
‫)"‪print("Yes primary‬‬
‫‪else:‬‬
‫)"‪print("No primary‬‬
‫‪if isPerfect(x) == True :‬‬
‫)"‪print("Yes perfect‬‬
‫‪else:‬‬
‫)"‪print("No perfect‬‬
‫ماژول‌اصلی‪ ،‬عدد ‪ x‬را خوانده‪ ،‬با فراخوانی تابع )(‪ ،isPrimary‬تعیین مایکناد اول اسات یاا ناه؟ در‬
‫ادامه با فراخوانی تابع )(‪ isPerfect‬تعیین میکند عدد خوانده شده تام است یا نه؟‬
‫تابع‌)(‪‌،sumDivided‬پارامتر ‪ n‬را دریافت کرده‪ ،‬مجماوع مقساوم علیاههاای آن را محاسابه کارده‪،‬‬
‫برمیگرداند‪.‬‬
‫تابع‌)(‪ ،isPrimary‬پارامتر ‪ k‬را دریافت کرده‪ ،‬اگر مجموع مقسوم علیههای آن برابر باا یاک باشاد‪،‬‬
‫مقدار ‪ ،True‬وگرنه مقدار ‪ False‬را برمیگرداند‪.‬‬
‫تابع‌)(‪ ،isPerfect‬پارامتر ‪ k‬را دریافت کرده‪ ،‬اگر مجموع مقسوم علیههای آن برابار ‪ k‬باشاد‪،True ،‬‬
‫وگرنه ‪ False‬را برمیگرداند‪.‬‬
‫‪ .2‬مالول را ذخیره و اجرا کنید‪ .‬اکنون‪ ،‬عدد ‪ 7‬را وارد کرده تا خروجی زیر را ببینید‪:‬‬
‫‪Enter a number:7‬‬
‫‪Yes primary‬‬
‫‪No perfect‬‬
‫‪‬مثال ‪ .3‬برنامهای‌که‌مجموع‌کلیه‌اعداد‌چهار‌رقمی‌بدون‌رقم‌صفر‌را‌محاسبه‌مینماید‌که‌بهر‌‪‌8‬بخهش‌پهذیر‌‬
‫هستند‪.‬‬
‫مراحل‌طراحی‌و‌اجرا‪:‬‬

‫‪ .1‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را به صورت زیر تایپ کنید‪:‬‬

‫هد‬ ‫متغ‬ ‫تابع‬

‫یر‬

‫مجموع اعدادی که ص درفر رقم آنها نباشد و بار ‪ 7‬بخاش‬ ‫‪su‬‬ ‫ماااااالول‬
‫‪m‬‬
‫پذیرند‬ ‫اصلی‬
‫اعداد ‪ 6222‬تا ‪3333‬‬ ‫‪i‬‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪11‬‬

‫عددی که باید تعیین شود آیا رقم صفر در آن وجود دارد یاا‬ ‫‪n‬‬ ‫‪nonZero‬‬

‫نه؟‬
‫‪def nonZero(n):‬‬
‫‪while n > 0:‬‬
‫‪if n % 10 == 0:‬‬
‫‪return False‬‬
‫‪n = n // 10‬‬
‫‪return True‬‬
‫‪sum = 0‬‬
‫‪for i in range(1000, 10000):‬‬
‫‪if i % 7 == 0 and nonZero(i) == True:‬‬
‫‪sum += i‬‬
‫)‪print("Sum:", sum‬‬
‫ماژول‌اصلی‪‌،‬ابتدا ‪ sum‬را برابر صفر قرار داده‪ ،‬با استفاده از یک حلقه تکرار اعداد ‪ 6222‬تاا ‪3333‬‬
‫که در ارقام آنها صفر نباشد و بر ‪ 7‬بخش پذیرناد را باا ‪ sum‬جماع کارده‪ ،‬در پایاان‪ sum ،‬را نماایش‬
‫میدهد‪.‬‬
‫تابع‌)(‪ ،nonZero‬پارامتر ‪ n‬را دریافت کرده‪ ،‬اگر در ارقاام آن صافر نباشاد‪ ،‬مقادار ‪ ،True‬وگرناه‬
‫مقدار ‪ False‬را برمیگرداند‪.‬‬
‫‪ .2‬مالول را ذخیره و اجرا کرده تا خروجی زیر را ببینید‪:‬‬
‫‪Sum: 5211759‬‬

‫‪@PythonForever‬‬
 ‫‪ 11‬فصل اول‬

‫فصل‬
‫آرایهها و بسته ‪NumPy‬‬
‫‪4‬‬

‫تاکنون برنامههایی که نوشتهشدهاند‪ ،‬هر متغیر حداکثر یک مقدار را در یاکلحظاه نگاهداری مای‪-‬‬
‫کرد‪ .‬یعنی‪ ،‬داده جدید جایگزین داده فعلی در یک مکان حافظه میشود‪ .‬بهعنوانمثال‪ ،‬دساتورات زیار‬
‫را در نظر بگیرید‪:‬‬
‫‪sum = 0‬‬
‫‪for i in range(5):‬‬
‫))"‪num = int(input("Enter a number:‬‬
‫‪sum += num‬‬
‫)‪print(sum / 5‬‬
‫این دستورات ‪ 0‬عدد را خوانده‪ ،‬میانگین آنها را نمایش میدهند‪ .‬حال‪ ،‬اگر بخواهیاد اعادادی کاه‬
‫بزرگتر از میانگین هستند را نمایش دهید‪ ،‬به دادههای خواندهشده قبلی نیاز دارید‪ .‬در این برناماه داده‪-‬‬
‫های خواندهشده در ‪ num‬قرار میگیرند‪ .‬بنابراین‪ ،‬پس از خواندن ‪ 0‬عدد‪ ،‬فقط پنجمین عادد در ‪num‬‬

‫قرار دارد‪ .‬جهت حل این مشکل باید دادههای خواندهشده را نگهداری نمود‪ .‬برای این منظور‪ ،‬مایتاوان‬
‫به دو طریق زیر عمل کرد‪:‬‬
‫‪ .0‬میتوان پنج متغیر (با نامهای متفاوت) در نظر گرفت و هر داده را در یک متغیر ذخیره کارد‪ .‬ایان‬
‫روش دو مشکل عمده دارد که عبارتاند از‪:‬‬

‫اگر تعداد مقادیر زیاد شود‪ ،‬تعداد متغیرها نیز زیاد خواهد شد‪.‬‬

‫از حلقه تکرار نمیتوان برای پردازش مقادیر استفاده نمود‪.‬‬

‫لذا‪ ،‬این روش معقول نمیباشد‪.‬‬

‫‪ .2‬میتوان از ساختار داده جدیدی به نام آرایه‪ 1‬استفاده کرد‪ .‬آرایه‪ ،‬مجموعهای از عناصر اسات کاه‬
‫دارای ویژگیهای زیر باشند‪:‬‬

‫‪1‬‬
‫‪.Array‬‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪11‬‬

‫چند خانه از حافظه که دارای‌یک‌نام‌باشند‪ .‬اگر چند نام بارای خاناههاای حافظاه در نظار گرفتاه‬
‫شود‪ ،‬همان مشکل تعریف متغیر و غیرقابلپردازش بودن توسط حلقههای تکرار وجود خواهد داشت‪.‬‬
‫دارای یک‌نوع باشند و بهصورت‌پشت‌سرهم در حافظه ذخیره شوند‪ .‬چون‪ ،‬اگر عناصر آرایه از‬
‫یک نوع نباشند و به صوت پشت سرهم ذخیر ‌نشوند‪ ،‬پیمایش عناصر مشاکل خواهاد شاد‪ .‬بناابراین‪،‬‬
‫عناصر آرایه باید دارای یک نوع باشند و بهصورت پشات سارهم ذخیاره گردناد تاا باا داشاتن آدرس‬
‫شروع آرایه ( همان نام آرایه)‪ ،‬بتوان آدرس هر خانه را بهسادگی حساب کرد‪ .‬این عمل بهصورت زیر‬
‫انجام میشود‪:‬‬
‫;‌(نوع‌آرایه)‌‪‌ + i * sizeof‬آدرس‌شروع‌آرایه‌ =‌‌آدرس‌خانه‪i‬ام‌‬

‫بهعنوانمثال‪ ،‬اگار آدرس شاروع آرایاه ‪ a‬باا ناوع صاحیح‪ 6222 ،‬باشاد‪ ،‬آدرس شاروع خاناه ساوم‬
‫بهصورت زیر محاسبه میگردد‪:‬‬
‫‪‌= 1000 + 3 * sizeof (int) = 1000 + 12 =1012=100CH‬آدرس‌شروع‌خانه‌سوم‌‬

‫برای دسترسی به عناصر آرایه از اندیا‪( 6‬شماره خانه) استفاده میشود‪ .‬باه هماین دلیال‪ ،‬ناام دیگار‬
‫آرایهها متغیرهای‌اندیا‌دار است‪ .‬آرایهها میتوانند با توجه به تعداد اندیس آنها چند ناوع باشاند کاه‬
‫عبارتاند از‪:‬‬
‫های‌یکبعدی‪‌،‬دارای یک اندیس هستند‪.‬‬
‫‌‬ ‫‪ .0‬آرایه‬

‫‪ .2‬آرایههای‌دوبعدی‪ ،‬دارای دو اندیس هستند‪.‬‬

‫‪ .3‬آرایههای‌چندبعدی‪‌،‬دارای چند اندیس هستند‪.‬‬

‫‪ .4 – 0‬آرایههای یکبعدی‬
‫همانطور که بیان گردید‪ ،‬آرایههای یکبعدی‪ ،‬یک اندیس دارند‪ .‬برای استفاده از آرایهها بایاد دو‬
‫عمل زیر انجام شود‪:‬‬

‫‪ .4-1-1‬تعریف آرایه‬

‫‪1‬‬
‫‪.Index‬‬

‫‪@PythonForever‬‬
 ‫‪ 11‬فصل اول‬

‫برای تعریف آرایه میتوانید از کالس ‪ array‬استفاده کنید‪ .‬این کالس در مالول ‪ array‬قارار دارد‪.‬‬
‫لذا‪ ،‬برای استفاده از این کالس ابتدا باید مالول ‪ array‬را با دستور زیر به برنامه اضافه کنید‪:‬‬
‫* ‪from array import‬‬

‫اکنون میتوانید از کالس آرایه بهصورت زیر استفاده کنید‪:‬‬

‫‪array(typecode [, initializer]) -> array‬‬

‫این کالس دو پارامتر را دریافات مایکناد‪ .‬پاارامتر ‪ ،typecode‬ناوع آرایاه را مشاخص مایکناد‪.‬‬
‫مقادیری که این پارامتر میپذیرد در جدول ‪ ۳ - 6‬آمدهاند و پارامتر ]‪ ،[initalizer‬مقادیر اولیه آرایه را‬
‫تعیین میکند‪.‬‬
‫جدول‌‪‌3‌-1‬مقادیر‌پارامتر‌‪‌TypeCode‬برای‌تعریف‌آرایه‪‌.‬‬
‫حداکثر‌‬ ‫نوع‌‪C‬‬ ‫م‬ ‫حداکثر‌‬ ‫نوع‌‪‌C‬‬ ‫م‬
‫انداز ‌‬ ‫قدار‌‬ ‫انداز ‌‬ ‫قدار‌‬
‫‪ 6‬بایت‬ ‫عاادد صاااحیح بااادون‬ ‫‪'B‬‬ ‫‪ 6‬بایت‬ ‫عاادد صاااحیح باااا‬ ‫‪'b‬‬
‫'‬ ‫'‬
‫عالمت‬ ‫عالمت‬
‫‪ 0‬بایت‬ ‫عدد صحیح با عالمت‬ ‫'‪'h‬‬ ‫‪ 0‬بایت‬ ‫کاراکتری یونیکد‬ ‫‪'u‬‬
‫'‬
‫‪ 0‬بایت‬ ‫عدد صحیح با عالمت‬ ‫'‪'i‬‬ ‫‪ 0‬بایت‬ ‫عاادد صااحیح باادون‬ ‫'‬
‫عالمت‬ ‫'‪H‬‬

‫‪ ۳‬بایت‬ ‫عدد صحیح با عالمت‬ ‫'‪'l‬‬ ‫‪ 0‬بایت‬ ‫عاادد صااحیح باادون‬ ‫'‪'I‬‬
‫عالمت‬

‫‪ 8‬بایت‬ ‫عدد صحیح با عالمت‬ ‫'‪'q‬‬ ‫‪ ۳‬بایت‬ ‫عاادد صااحیح باادون‬ ‫‪'L‬‬
‫عالمت‬ ‫'‬

‫‪ ۳‬بایت‬ ‫عدد اعشاری‬ ‫'‪'f‬‬ ‫‪ 8‬بایت‬ ‫عاادد صااحیح باادون‬ ‫'‬

‫عالمت‬ ‫'‪Q‬‬

‫‪ 8‬بایت‬ ‫عدد اعشاری‬ ‫‪'d‬‬

‫'‬
‫بهعنوانمثال‪ ،‬دستورات زیر را ببینید‪:‬‬
‫* ‪>>> from array import‬‬
‫)][ ‪>>> a = array('i',‬‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪10‬‬

‫دستور اول‪ ،‬مالول ‪ array‬را به برنامه اضاافه مایکناد‪ ،‬دساتور دوم‪ ،‬آرایاهای باه ناام ‪ a‬بادون هایچ‬
‫عضوی با نوع صحیح ‪ 61‬بیتی تعریف میکند‪.‬‬
‫پس از ایجاد آرایه‪ ،‬اکنون میتوانید با متدهای آن اعمالی را روی آرایه انجام دهیاد‪ .‬برخای از ایان‬
‫متدها و خواص کالس ‪ array‬عبارتاند از‪:‬‬
‫متد‌)(‪ ،append‬برای اضافه کردن مقداری به انتهای آرایه به کار میرود‪ .‬بهعنوانمثاال‪ ،‬دساتورات‬
‫زیر را ببینید‪:‬‬
‫* ‪>>> from array import‬‬
‫)][ ‪>>> a = array('i',‬‬
‫)‪>>> a.append(12‬‬
‫)‪>>> print(a‬‬
‫این دستورات ابتدا‪ ،‬آرایهای به نام ‪ a‬با نوع صحیح ‪ 61‬بیتی تعریف کرده‪ 60 ،‬را به انتهای آن اضاافه‬
‫میکند و دستور آخر مقدار آرایه ‪( a‬یعنی‪٬‬‫)]‪array('i', [12‬‫)‫را نمایش میدهد‪.‬‬
‫متد‌)(‪،buffer_info‬‫تاپلی را برمیگرداند که آدرس و طول آرایه میباشد‪.‬‬
‫متد‌)(‪ ،tobytes‬مقادیر آرایه را به بایت تبدیل میکند‪ .‬بهعنوانمثال‪ ،‬دستورات زیر را ببینید‪:‬‬
‫* ‪>>> from array import‬‬
‫)][ ‪>>> a = array('I',‬‬
‫‪>>> for i in range(65, 80):‬‬
‫)‪a.append(i‬‬
‫))(‪>>> print(a.tobytes‬‬
‫این دستورات‪ ،‬آرایهای به نام ‪ a‬با نوع عدد صحیح بدون عالمت تعریف کرده‪ ،‬مقادیر ‪ 10‬تاا ‪ 73‬باه‬
‫آرایه اضافه میکند و در پایان‪ ،‬اعضای آرایه را به بایت تبدیل میکند و نمایش میدهد(خروجی زیر)‪:‬‬
‫\‪b'A\x00\x00\x00B\x00\x00\x00C\x00\x00\x00D\x00\x00\x00E\x00\x00\x00F\x00\x00‬‬
‫‪x00G\x00\x00\x00H\x00\x00\x00I\x00\x00\x00J\x00\x00\x00K\x00\x00\x00L\x00\x00\x0‬‬
‫'‪0M\x00\x00\x00N\x00\x00\x00O\x00\x00\x00‬‬
‫متد‌)(‪ ،extend‬یک سری عناصر را به انتهای آرایه اضافه میکند‪ .‬بهعنوانمثاال‪ ،‬دساتورات زیار را‬
‫ببینید‪:‬‬
‫* ‪>>> from array import‬‬
‫)]‪>>> a = array('i', [1, 2, 3‬‬
‫)]‪>>> a.extend([3, 4‬‬
‫))‪>>> print(str(a‬‬

‫‪@PythonForever‬‬
 ‫‪ 11‬فصل اول‬

‫این دستورات‪ ،‬ابتدا آرایهای با نوع صحیح به ناام ‪ a‬باا مقاادیر اولیاه ]‪ [1, 2, 3‬ایجااد کارده‪ ،‬ساپس‬
‫مقادیر ]‪ [3, 4‬را به انتهای آن اضافه کرده و در پایان آرایه ‪ a‬را به صورت زیر نمایش میدهند‪:‬‬
‫)]‪array('i', [1, 2, 3, 3, 4‬‬
‫متد‌)(‪ ،count‬تعداد تکرار مقداری را در آرایه شمارش میکند‪ .‬باهعناوانمثاال‪ ،‬دساتورات زیار را‬
‫ببینید‪:‬‬
‫* ‪>>> from array import‬‬
‫)]‪>>> a = array('b', [1, 2, 3, 1, 4, 1‬‬
‫))‪>>> print(a.count(1‬‬
‫این دستورات‪ ،‬ابتدا آرایهای به نام ‪ a‬با نوع بایت با مقادیر اولیه ]‪ [1, 2, 3, 1, 4, 1‬تعریف میکنناد‬
‫و در پایان‪ ،‬تعداد عناصر آرایه را شمارش کرده‪( ،‬یعنی ‪ )9‬نمایش میدهد‪.‬‬
‫متد‌)(‪ ،index‬مکان اولین وقوع مقداری را برمیگرداند‪ .‬اگر مقدار در آرایه موجاود نباشاد‪ ،‬پیغاام‬
‫خطای صادر خواهد شد‪ .‬بهعنوانمثال‪ ،‬دستورات زیر را ببینید‪:‬‬
‫* ‪>>> from array import‬‬
‫)]‪>>> a = array('b', [1, 2, 3, 1, 4, 2‬‬
‫))‪>>> print(a.index(2‬‬
‫))‪>>> print(a.index(5‬‬
‫این دستورات‪ ،‬ابتدا آرایهای به نام ‪ a‬با نوع بایت تعریف کارده‪ ،‬مقاادیر اولیاه ]‪ [1, 2, 3, 1, 4, 2‬را‬
‫به آن تخصیص میدهند‪ ،‬سپس مکان اولین وقوع مقدار ‪( 0‬یعنای‪ )6 ،‬را نماایش مایدهناد و در پایاان‪،‬‬
‫چون مقدار ‪ 0‬در آرایه وجود ندارد‪ ،‬پیغام خطای زیر را صادر میکنند‪:‬‬
‫‪Traceback (most recent call last):‬‬
‫>‪File "<pyshell#57>", line 1, in <module‬‬
‫))‪print(a.index(5‬‬
‫‪ValueError: array.index(x): x not in list‬‬
‫متد‌)(‪ ،insert‬عنصری را در مکان خاصی از آرایه اضافه میکند‪ .‬این متد دو پاارامتر را مایگیارد‪،‬‬
‫پارامتر اول‪ ،‬مکانی است که مقدار پارامتر دوم باید قبل از آن درج شود‪ .‬اگر مقدار پارامتر اول‪ ،‬بیش‪-‬‬
‫تر از تعداد عناصر آرایه باشد‪ ،‬مقدار پارامتر دوم را به انتهای آرایه اضاافه مایکناد‪ .‬دساتورات زیار را‬
‫ببینید‪:‬‬
‫* ‪>>> from array import‬‬
‫)]‪>>> a = array('B', [1, 2, 3, 1, 4, 2‬‬
‫)‪>>> a.insert(1, 45‬‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪11‬‬

‫)‪>>> print(a‬‬
‫)‪>>> a.insert(10, 45‬‬
‫)‪>>> print(a‬‬
‫این دستورات‪ ،‬ابتدا آرایه ‪ a‬را با نوع بدون عالمت تعریف میکنند‪ ،‬سپس مقادیر ‪[1, 2, 3, 1, 4,‬‬

‫]‪ 2‬را به آن تخصیص میدهند‪ ،‬در ادامه‪ ،‬مقدار ‪ ۳0‬را به قبل از مقدار ‪( 0‬اندیش یک) اضافه کرده‪،‬‬
‫آرایه ‪( a‬یعنی )]‪array('B', [1, 45, 2, 3, 1, 4, 2‬‫) را نمایش میدهند و در پایان‪ ،‬مقدار ‪ ۳0‬را به انتهای‬
‫آرایه ‪ a‬اضافه نموده و آرایه ‪( a‬یعنی )]‪ ) array('B', [1, 45, 2, 3, 1, 4, 2, 45‬را نمایش میدهند‪.‬‬
‫متد‌)(‪ ،remove‬مقداری را از آرایه حذف میکند (اولین وقوع مقدار را از آرایه حذف میکناد)‪.‬‬
‫اگر مقدار در آرایه وجود نداشته باشد‪ ،‬پیغام خطای صادر خواهد شد‪ .‬بهعنوانمثال‪ ،‬دساتورات زیار را‬
‫در نظر بگیرید‪:‬‬
‫* ‪>>> from array import‬‬
‫)]‪>>> a = array('d', [1, 2, 3, 1‬‬
‫)‪>>> a.remove(1‬‬
‫)‪>>> print(a‬‬
‫)‪>>> a.remove(4‬‬
‫این دستورات‪ ،‬ابتدا آرایهای به نام ‪ a‬با نوع اعشاری با دقت مضاعف کرده‪ ،‬مقادیر ]‪ [1, 2, 3, 1‬را‬
‫به اعضای آن تخصیص میدهند‪ ،‬سپس اولین مقدار ‪ 6‬را حذف کرده‪ ،‬آرایه ‪( a‬یعنی ‪array('d', [2.0,‬‬

‫)]‪ ) 3.0, 1.0‬را نمایش میدهند‪ .‬دستور آخر‪ ،‬میخواهد مقدار ‪ 0‬را از آرایه ‪ a‬حذف کند‪ ،‬چون در‬
‫آرایه وجود ندارد‪ ،‬پیغام خطای زیر را صادر میکند‪:‬‬
‫‪Traceback (most recent call last):‬‬
‫>‪File "<pyshell#71>", line 1, in <module‬‬
‫)‪a.remove(4‬‬
‫‪ValueError: array.remove(x): x not in list‬‬
‫متد‌)(‪ ،pop‬مقدار عنصری از آرایه را با توجه به اندیس آن برمایگرداناد و آن عنصار را از آرایاه‬
‫حذف میکند‪ .‬اگر اندیس که برای برگرداندن عناصر آرایه به کاار رود بازرگتار یاا مسااوی تعاداد‬
‫عناصر آرایه و کوچکتر از صفر باشد‪ ،‬پیغام خطای صادر میشود‪ .‬باهعناوانمثاال‪ ،‬دساتورات زیار را‬
‫ببینید‪:‬‬
‫* ‪>>> from array import‬‬
‫)]‪>>> a = array('d', [1, 2, 3, 4‬‬
‫))‪>>> print(a.pop(2‬‬

‫‪@PythonForever‬‬
 ‫‪ 11‬فصل اول‬

‫))‪>>> print(a.pop(5‬‬
‫)‪>>> print(a‬‬
‫دستور دوم‪ ،‬آرایهای به نام ‪ a‬با نوع عدد اعشاری با دقت مضاعف تعریف کرده‪ ،‬مقادیر ‪[1.0, 2.0,‬‬

‫]‪ 3.0, 4.0‬را به آن تخصیص میدهد‪ .‬دستور سوم‪ ،‬عنصر ساوم (یعنای‪ ،‬عنصار باا انادیس ‪ ) 0‬آرایاه را‬
‫برمیگرداند و از آرایه حذف مینماید (مقادار ‪ 3.0‬را نماایش مایدهاد)‪ ،‬دساتور چهاارم‪ ،‬مایخواهاد‬
‫عنصری با اندیس ‪ 0‬را برگرداند و از آرایه حاذف کناد‪ ،‬چاون ایان عنصار در آن وجاود نادارد‪ ،‬پیغاام‬
‫خطای زیر را صادر مینماید‪:‬‬
‫‪Traceback (most recent call last):‬‬
‫>‪File "<pyshell#75>", line 1, in <module‬‬
‫))‪print(a.pop(5‬‬
‫‪IndexError: pop index out of range‬‬
‫در پایان‪ ،‬عناصر آرایه ‪ a‬را نمایش میدهد(خروجی زیر)‪:‬‬
‫)]‪array('d', [1.0, 2.0, 4.0‬‬
‫متد‌)(‪ ،reverse‬عناصر آرایه را معکوس میکند‪ .‬بهعنوانمثال‪ ،‬دستورات زیر را در نظر بگیرید‪:‬‬
‫* ‪>>> from array import‬‬
‫)]‪>>> a = array('d', [1, 2, 3, 4‬‬
‫)(‪>>> a.reverse‬‬
‫)‪>>> print(a‬‬
‫این دستورات‪ ،‬آرایهای به نام با نوع اعشاری با دقت مضاعف و مقادیر اولیاه ]‪[1.0, 2.0, 3.0, 4.0‬‬

‫تعریف کرده‪ ،‬آن را معکوس مینمایند و نمایش میدهند(خروجی زیر)‪:‬‬

‫)]‪array('d', [4.0, 3.0, 2.0, 1.0‬‬
‫خاصیت‌‪ ،itemsize‬اندازه هر عنصر آرایه را برمیگرداند‪ .‬بهعنوانمثال‪ ،‬دستورات زیر را ببینید‪:‬‬
‫* ‪>>> from array import‬‬
‫)]‪>>> a = array('d', [1, 2, 3, 4‬‬
‫)‪>>> print(a.itemsize‬‬
‫این دستورات‪ ،‬آرایهای به نام ‪ a‬با نوع اعداد اعشاری باا دقات مضااعف و مقاادیر ‪[1.0, 2.0, 3.0,‬‬

‫]‪ 4.0‬تعریف کرده‪ ،‬اندازه هر عنصر آرایه ‪ ( a‬یعنی‪ ) 8 ،‬را نمایش میدهند‪.‬‬
‫خاصیت‌‪ ،typecode‬مقدار ‪ typecode‬آرایهای را برمایگرداناد‪ .‬باهعناوانمثاال‪ ،‬دساتورات زیار را‬
‫ببینید‪:‬‬
‫* ‪>>> from array import‬‬
‫)]‪>>> a = array('I', [1, 2, 3, 4‬‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪11‬‬

‫))‪>>> print(str(a.typecode‬‬
‫این دستورات‪ ،‬آرایهای به نام ‪ a‬با نوع عددی صحیح ‪ 61‬بیتی بدون عالمت تعریاف کارده‪ ،‬مقاادیر‬
‫]‪ [1, 2, 3, 4‬را به آن تخصیص میدهند‪ ،‬در پایان‪ ،‬مقدار ‪ typecode‬آرایه (یعنی‪ ،‬هماان ‪ )I‬را نماایش‬
‫میدهند‪.‬‬

‫‪ .4-1-2‬دسترسی به عناصر آرایه‬

‫همانطور که بیان گردید‪ ،‬برای دسترسی به عناصر آرایاه از انادیس آن باهصاورت زیار اساتفاده‬
‫میشود‪:‬‬
‫]‌اندیا[‌نام‌آرایه‌‬

‫اندیس‪ ،‬شماره خانه آرایه را تعیین میکند‪ .‬اندیس آرایه در پایتون از صفر شروع میشود‪ .‬بناابراین‪،‬‬
‫حداکثر مقداری که اندیس میتواند بپذیرد‪ ،‬برابر با‌]‪‌-1‬تعداد‌عناصر‌آرایه[ اسات‪ .‬یعنای‪ ،‬آرایاهای باا ‪0‬‬
‫عنصر‪ ،‬بهصورت زیر نمایش داده میشود‪:‬‬

‫]‪a[0‬‬ ‫]‪a[1‬‬ ‫]‪a[2‬‬ ‫]‪a[3‬‬ ‫]‪a[4‬‬

‫همانطور که در شکل میبینید‪ ،‬آخرین خانه آرایه دارای اندیس ‪ ۳‬است‪ .‬اکناون دساتورات زیار را‬
‫ببینید‪:‬‬

‫))"‪a[2] = int (input("Enter a number:‬‬

‫)]‪print (a[2‬‬
‫دستور اول‪ ،‬عنصر سوم آرایه (]‪ )a[2‬را میخواند و دستور دوم‪ ،‬مقدار عنصر ساوم آرایاه (]‪ )a[2‬را‬
‫نمایش میدهد‪.‬‬
‫مثال ‪ .4 – 2‬برنامهای‌که‌ابتدا‌‪‌n‬را‌خواند ‪‌n‌،‬عدد‌تصادفی‌بین‌‪‌-80‬تا‌‪‌80‬تولید‌کرد ‪‌،‬در‌آرایهای‌قرار‌میدهد‪‌.‬‬
‫سپا‌اعمال‌زیر‌را‌انجام‌میدهد‪‌:‬‬

‫‪ .0‬بزرگترین عدد و مکان آن را نمایش میدهد‪.‬‬

‫‪ .2‬دومین عدد ازلحاظ کوچکی و مکان آن را نمایش میدهد‪.‬‬
‫‪ .3‬عناصر آرایه را معکوس مینماید‪ .‬یعنی‪ ،‬جای اولین عدد و آخرین عادد‪ ،‬یکای ماناده باه آخارین‬
‫عدد و دومین عدد را تعویض میکند و همین روند را ادامه میدهد‪.‬‬

‫‪@PythonForever‬‬
 ‫‪ 11‬فصل اول‬

‫مراحل‌طراحی‌و‌اجرا‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫هد ‌‬ ‫متغیر‌‬ ‫تابع‌‬
‫آرایهی ورودی‬ ‫‪a‬‬ ‫‪main‬‬

‫تعداد عناصر آرایه‬ ‫‪n‬‬

‫بزرگترین عنصر آرایه‬ ‫‪max‬‬

‫مکان بزرگترین عنصر آرایه‬ ‫‪lmax‬‬

‫دومین عدد کوچک‬ ‫‪min2‬‬

‫مکان دومین عدد کوچک‬ ‫‪lmin‬‬

‫تعداد عناصر آرایه (تعداد اعداد تصادفی)‬ ‫‪n‬‬ ‫‪createRandom‬‬

‫شمارندهای که از صفر تا ‪ n-1‬شمارش میکند‪.‬‬ ‫‪i‬‬

‫آرایهای که اعضای آن باید نمایش داده شود‪.‬‬ ‫‪a‬‬ ‫‪printArray‬‬

‫هر یک از عناصر آرایه ‪a‬‬ ‫‪i‬‬

‫آرایهای که بزرگترین عنصر آن باید پیدا شود‪.‬‬ ‫‪A‬‬ ‫‪findMax‬‬

‫تعداد عناصر آرایه ‪a‬‬ ‫‪N‬‬

‫بزرگترین عنصر‬ ‫‪Max‬‬

‫مکان بزرگترین عنصر‬ ‫‪Lmax‬‬

‫اندیس عناصر از ‪ 6‬تا ‪ n-1‬شمارش میکند‪.‬‬ ‫‪I‬‬

‫آرایهای که دومین عدد ازلحاظ کاوچکی ب ذر آن ایاد پیادا‬ ‫‪A‬‬ ‫‪findSecondMin‬‬

‫شود‪.‬‬
‫تعداد عناصر آرایه ‪a‬‬ ‫‪N‬‬

‫کوچکترین عدد‬ ‫‪min1‬‬

‫مکان کوچکترین عدد‬ ‫‪lmin1‬‬

‫دومین عدد ازلحاظ کوچکی‬ ‫‪min2‬‬

‫مکان دومین عدد ازلحاظ کوچکی‬ ‫‪lmin2‬‬

‫شمارندهای که از ‪ 0‬تا ‪ n-1‬را شمارش میکند‬ ‫‪I‬‬

‫* ‪from array import‬‬
‫‪import random‬‬
‫‪def createRandom(n):‬‬
‫)][ ‪a = array('i',‬‬

‫‪@PythonForever‬‬
11 ‫آشنایی با زبان پایتون‬

for i in range(0, n):

a.append(random.randint(-20, 20))
return a
def printArray(a):
for i in a:
print(i, end = '\t')
print()
def findMax(a, n):
max = a[0]
lMax = 0
for i in range(1, n):
if a[i] > max:
max = a[i]
lMax = i
return max, lMax
def findSecondMin(a, n):
if a[0] < a[1]:
min1 = a[0]
min2 = a[1]
lMin1 = 0
lMin2 = 1
else:
min1 = a[1]
min2 = a[0]
lMin1 = 1
lMin2 = 0
for i in range(2, n):
if a[i] < min1:
min2 = min1
lMin2 = lMin1
min1 = a[i]
lMin1 = i
elif a[i] < min2 :
min2 = a[i]
lMin2 = i
return min2, lMin2
def main():
a = array('i', [])
n = int(input("Enter n:"))
a = createRandom(n)
print("Orginal array ")
printArray(a)

@PythonForever
 ‫‪ 11‬فصل اول‬

‫)‪max, lMax = findMax(a, n‬‬

‫)‪print("Max is ", max, " Location max is ", lMax‬‬
‫)‪min2, lMin2 = findSecondMin(a, n‬‬
‫)‪print("Second min is ", min2, " Location second min is ", lMin2‬‬
‫)(‪a.reverse‬‬
‫)" ‪print("Reverse array‬‬
‫)‪printArray(a‬‬
‫)(‪main‬‬
‫متد‌)(‪ ،createRandom‬تعداد عناصر )‪ (n‬را بهعنوان پارامتر دریافت کارده‪ n ،‬عادد تصاادفی باین‬
‫‪ -02‬تا ‪ 02‬ایجاد مینماید و در آرایه ‪ a‬قرار میدهد‪ .‬در پایان‪ ،‬آرایه ‪ a‬را برمیگرداند‪.‬‬
‫متد‌)(‪ ،printArray‬آرایه ‪ a‬را بهعنوان پارامتر دریافت کرده‪ ،‬عناصر آن را نمایش میدهد‪.‬‬
‫متد‌)(‪ ،findMax‬آرایه ‪ a‬و تعداد عناصر آن )‪ (n‬را بهعناوان پاارامتر دریافات کارده‪ ،‬بازرگتارین‬
‫عنصر و مکان آن را برمیگرداند‪ .‬برای این منظور‪ ،‬ابتدا عنصار اول آرایاه ]‪ a[0‬را در ‪ max‬و ‪( 0‬مکاان‬
‫اولین عنصر) را در ‪ lMax‬قرار میدهد‪ .‬سپس از دومین عنصر تا عنصار ‪n‬ام‪ ،‬عناصار را یکای‪ ،‬یکای باا‬
‫‪ max‬مقایسه میکند (داخل ‪ ،)for‬اگر عنصری بزرگتار از ‪ max‬باشاد‪ ،‬آن عنصار (یعنای‪ )a[i] ،‬را در‬
‫و مکان آن (یعنی‪ )i ،‬را در ‪ lMax‬قرار میدهد‪ .‬در پایان‪ max ،‬و ‪ lMax‬را برمیگرداند‪.‬‬ ‫‪max‬‬

‫متد‌)(‪ ،findSecondMin‬آرایه ‪ a‬و تعداد عناصر آن (‪ )n‬را بهعنوان پارامتر دریافت کارده‪ ،‬دوماین‬
‫عدد ازلحاظ کوچکی و مکان آن را برمیگرداند‪ .‬برای این منظور‪ ،‬ابتادا اولاین عادد آرایاه )]‪ (a[0‬باا‬
‫دومین عدد آرایه )]‪ (a[1‬مقایسه میکند‪ ،‬عدد کوچکتر را در ‪ min1‬و مکان آن را در ‪ lMin1‬و عادد‬
‫بزرگتر را در ‪ min2‬و مکان آن را در ‪ lMin2‬قرار میدهد‪ .‬در ادامه‪ ،‬با یک حلقه ‪ for‬از ساومین عادد‬
‫تا ‪n‬امین عدد‪ ،‬ابتدا عدد ‪i‬ام را با ‪ min1‬مقایسه میکند‪ ،‬اگر کوچاکتار از ‪ min1‬باشاد‪ ،‬عادد ‪ min1‬را‬
‫در ‪ ،min2‬مکان ‪ (lMin1)min1‬را در ‪ lMin2‬قرار داده‪ ،‬عادد ‪i‬ام را در ‪ min1‬و ‪ i‬را ‪ lMin1‬قارار مای‪-‬‬
‫دهد‪ .‬وگرنه‪ ،‬اگر عدد ‪i‬ام کوچکتر از ‪ min2‬باشاد‪ ،‬عادد ‪i‬ام را در ‪ min2‬و ‪ i‬را در ‪ lMin2‬قارار مای‪-‬‬
‫دهد‪ .‬در پایان‪ min2 ،‬و ‪ lMin2‬را برمیگرداند‪.‬‬

‫‪ .0‬مالول را ذخیره و اجرا کنید تا خروجی زیر را مشاهده نمایید‪:‬‬

‫‪Enter n:8‬‬
‫‪Orginal array‬‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪11‬‬

‫‪15 6‬‬ ‫‪-1‬‬ ‫‪-7‬‬ ‫‪8‬‬ ‫‪-11‬‬ ‫‪-7‬‬ ‫‪18‬‬

‫‪Max is 18 Location max is 7‬‬
‫‪Second min is -7 Location second min is 3‬‬
‫‪Reverse array‬‬
‫‪18 -7‬‬ ‫‪-11‬‬ ‫‪8‬‬ ‫‪-7‬‬ ‫‪-1‬‬ ‫‪6‬‬ ‫‪15‬‬

‫‪ .4-5‬بسته ‪NumPy‬‬
‫عملیات پایهای مورداستفاده در برنامهنویسی علمی‪ ،‬آرایهها‪ ،‬ماتریسها‪ ،‬حلکنندههای معاادلهاای‬
‫دیفرانسیل‪ ،‬آمار و غیره را در برمیگیرد که بهصورت پیشفارض باهجاز شاماری از عملگرهاای سااده‬
‫ریاضیاتی که تنها بر روی یک متغیر‪ ،‬و نه آرایهها و ماتریس‪ ،‬قابلاستفادهاند‪ .‬پایتون چنین قابلیاتهاایی‬
‫را بهطور ذاتی در اختیار ندارد‪ .‬با بسته ‪ NumPy‬میتوان برخی از این قابلیتها را به زبان پاایتون اضاافه‬
‫نمود‪ NumPy .‬مختص پردازشهای عددی بهوسیلهی آرایههای چندبعادی ‪ narrays‬اسات کاه در آن‬
‫آرایهها میتوانند محاسبات درایه به درایه را انجام دهند‪ .‬بدون اینکه نیاز به تغییر یا اصاال آرایاههاای‬
‫‪ Numpy‬باشد‪ ،‬میتوان از فرمولهای جبر خطی نیز استفاده کرد‪ .‬عالوه بر این انادازهی آرایاه را مای‪-‬‬
‫توان بهصورت پویا تغییر داد‪.‬‬
‫دقت داشته باشید که بسته ‪ Numpy‬یک افزونه است که بایاد بار روی مفسار پاایتون نصاب‬
‫گردد‪ .‬یعنی‪ ،‬در هنگام نصب نرمافزار پایتون‪ ،‬این بسته باهطاور خودکاار بار روی پاایتون نصاب‬
‫نمیشود‪ .‬فرآیند نصب ‪ Numpy‬بر روی سیستمعامل مختلاف‪ ،‬متفااوت اسات‪ .‬لاذا‪ ،‬مایتوانناد‬
‫فرآیند نصب مالول ‪ Numpy‬را از سایت انتشارات فناوری نوین دانلود کنید‪.‬‬

‫‪ .4-5-1‬آرایههای ‪NumPy‬‬

‫‪ ،Numpy‬یک بسته بنیادی پایتون برای محاسبات علمی است‪ .‬این بسته قابلیتهای آرایه ‪N‬بعادی‪،‬‬
‫عملیات درایه به درایه‪ ،‬عملیات اصلی مانند جبر خطی توانایی فراخوانی کادها ‪ C ،ّFortran‬و ‪ C++‬را‬
‫جمعآوری کرده است‪ .‬عملیات بر روی آرایهها از طریق ‪ Numpy‬تقریبااً حادود ‪ 00‬برابار ساریعتار از‬
‫حالت معمولی انجام میشود‪ .‬به همین دلیل‪ ،‬در این بخش بسته ‪ Numpy‬را میآموزیم‪.‬‬

‫‪@PythonForever‬‬
 ‫‪ 11‬فصل اول‬

‫تعریف آرایه ‪NumPy‬‬

‫مهمترین شیء تعریفشده در ‪ ،Numpy‬یک نوع آرایه ‪ N‬بعادی کاه ‪ ndarray‬نامیاده مایشاود‪،‬‬
‫است‪ .‬آرایه ‪ ،ndarray‬مجموعهای از عناصر هم نوع هستند‪ .‬اندیس شاروع عناصار صافر اسات‪ .‬انادازه‬
‫همه عناصر یکی است‪ .‬هر عنصر در ‪ ndarray‬یک شیء از شایء ناوع داده (‪ dtype‬نامیاده مایشاود)‪،‬‬
‫است‪.‬‬
‫‪ Numpy‬پایه با استفاده از تابع ‪ array‬در ‪ Numpy‬بهصورت زیر ایجاد میشود‪:‬‬
‫‪Numpy.array‬‬
‫برای ایجاد آرایه میتوانید از متد ‪ array‬بهصورت زیر استفاده کنید‪:‬‬
‫)‪Numpy.array(object, dtype = none, copy = tyue, order = none, subok = false, ndmin=0‬‬
‫پارامتر ‪ ،object‬شی مربوطه را تعین میکند‪.‬‬
‫پارامتر ‪ ،dtype‬نوع عناصر آرایه را تعیین میکند‪.‬‬
‫پارامتر ‪ ،copy‬تعیین میکند آیا شیء کپی شود یا نه؟‬
‫پارامتر ‪ ،order‬روش ذخیاره آرایاه را تعیاین مایکناد‪ ،'C' ،‬ذخیارهساازی باهصاورت ساطری‪،'F' ،‬‬
‫ذخیرهسازی بهصورت ستونی و '‪( 'A‬هر دو) میباشد‪.‬‬
‫پارامتر ‪ ،ndmin‬حداقل تعداد ابعاد آرایه را مشخص میکند‪.‬‬

‫‪>>> import numpy as np‬‬

‫)]‪>>> a = np.array([1, 2, 3, 4‬‬
‫)‪>>> print(a‬‬
‫بهعنوانمثال‪ ،‬دستورات زیر را ببینید‪:‬‬
‫دستور اول‪ ،‬مالول ‪ np‬را از بسته ‪ numpy‬به برنامه اضافه میکند‪ ،‬دستور دوم‪ ،‬آرایاه یاکبعادی باا‬
‫‪[1‬‬ ‫مقادیر ‪ 9 ،0 ،6‬و ‪ ۳‬ایجاد مینماید و دستور سوم‪ ،‬عناصر آرایه ایجادشده ‪ a‬را نمایش میدهد (یعنی‪،‬‬
‫]‪)2 3 4‬‫‪ .‬اکنون دستورات زیر را ببینید‪:‬‬
‫‪>>> import numpy as np‬‬
‫)]]‪>>> a = np.array([[1, 2], [3, 4‬‬
‫)‪>>> print(a‬‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪10‬‬

‫دستور اول مالول ‪ numpy‬را با نام ‪ np‬به برنامه اضافه میکناد‪ ،‬دساتور دوم‪ ،‬آرایاه دوبعادی باا دو‬
‫سطر و دو ستون باه برناماه اضاافه مای کناد و دساتور ساوم‪ ،‬اطالعاات آرایاه دوبعادی را نماایش مای‪-‬‬
‫دهد(خروجی زیر)‪:‬‬
‫]‪[[1 2‬‬ ‫]]‪[3 4‬‬
‫دستورات زیر یک آرایه ایجاد میکنند که نوع هر عنصر آن مختلط میباشد و سپس‬
‫‪)[ 1.+0.j‬‫را نمایش میدهند‪:‬‬ ‫خروجی (یعنی ]‪2.+0.j 3.+0.j 4.+0.j‬‬

‫‪>>> import numpy as np‬‬

‫)‪>>> a = np.array([1, 2, 3, 4], dtype = complex‬‬
‫)‪>>> print(a‬‬
‫توجه داشته باشید که نوع هر نوع آرایه )‪ (dtype‬میتواند ‪( bool‬مقادیر ‪ true‬یا ‪int ،)false‬‬

‫(نوع صحیح پیشفرض ‪ 90‬یا ‪ 1۳‬بیتی)‪( intc ،‬ناوع صاحیح زباان ‪( intp )c‬عادد صاحیح کاه‬
‫برای شاخص گذاری استفاده میشود)‪( int8 ،‬بایت)‪( int16 ،‬عادد صاحیح ‪ 61‬بیتای)‪int32 ،‬‬

‫(عدد صحیح ‪ 90‬بیتی) ‪( int64‬عدد صحیح ‪ 1۳‬بیتی) ‪( float‬عدد اعشاری ‪ 1۳‬بیتی)‪float16 ،‬‬

‫(عدد اعشاری ‪ 61‬بیتی)‪( float32 ،‬عدد اعشاری ‪ 90‬بیتی)‪( float64 ،‬عدد اعشاری ‪ 1۳‬بیتی)‪،‬‬
‫‪( complex‬عدد مختلط ‪ 608‬بیتی)‪( complex64 ،‬عدد مختلط ‪ 1۳‬بیتی(دو عدد ‪ 90‬بیتی)) و‬
‫‪( complex128‬عدد مختلط ‪ 608‬بیتی) باشد‪.‬‬
‫متد‌)(‪ ،dtype‬این متد یک شیء نوع داده ایجاد میکند که بهصورت زیر به کار میرود‪:‬‬
‫)‪numpy.dtype (object, align, copy‬‬
‫پارامتر ‪ ،object‬برای تبدیل شیء به نوع داده به کار میرود‪.‬‬
‫پارامتر ‪ ،align‬اگر ‪ true‬باشد‪ ،‬الیه گذاری اضافه میکند تا ساختار شبیه ‪ C‬را به وجود آورد‪.‬‬
‫پارامتر ‪ ،copy‬اگار ‪ true‬باشاد‪ ،‬یاک کپای جدیاد از شایء ‪ dtype‬ایجااد مایکناد‪ ،‬وگرناه ارجااع‬
‫ایجادشده در شیء نوع داده را برمیگرداند‪.‬‬
‫بهعنوانمثال‪ ،‬دستورات زیر را ببینید‪:‬‬
‫‪>>> import numpy as np‬‬
‫)‪>>> dt = np.dtype(np.int32‬‬
‫)‪>>> print(dt‬‬
‫)'‪>>> dt1 = np.dtype('i4‬‬
‫)‪>>> print(dt1‬‬

‫‪@PythonForever‬‬
 ‫‪ 11‬فصل اول‬

‫)])‪>>> dt2 = np.dtype([('age', np.int8‬‬

‫)‪>>> print(dt2‬‬
‫دستور اول‪ ،‬مالول‪ numpy‬را با نام ‪ np‬به برنامه اضاافه مایکناد‪ ،‬دساتور دوم‪ dt ،‬را باا ناوع ‪int32‬‬

‫(صحیح ‪ 90‬بیتی) در نظر میگیرد‪ ،‬دستور سوم‪ ،‬مقادار ‪ dt‬را نماایش مایدهاد (هماان ‪ ،)int32‬دساتور‬
‫چهارم‪ dt1 ،‬را با نوع ‪ int32‬در نظر میگیرد ( زیارا باهجاای ‪ int32 ،int16 ،int8‬و ‪ int64‬باه ترتیاب‬
‫میتاوان معاادل آنهاا '‪ 'i3' ،'i2' ،'i1‬و '‪ 'i4‬را جاایگزین کارد)‪ ،‬دساتور پانجم‪ ،‬مقادار ‪ )int32( dt1‬را‬
‫نمایش میدهد‪ ،‬دستور ششم‪ ،‬یک نوع داده ساخته یافته ایجااد کارده‪ ،‬در ‪ dt2‬قارار مایدهاد و دساتور‬
‫هفتم‪ ،‬مقدار ‪ )[('age', 'i1')]( dt2‬را نمایش میدهد‪.‬‬
‫اکنون دستورات زیر را ببینید‪:‬‬
‫‪>>> import numpy as np‬‬
‫)])‪>>> dt = np.dtype([('age', np.int8‬‬
‫)‪>>> a = np.array([(5, ), (10, ), (15, )], dtype = dt‬‬
‫)]'‪>>> print(a['age‬‬
‫دستور اول‪ ،‬مالول ‪ numpy‬را با نام ‪ np‬باه برناماه اضاافه مایکناد‪ ،‬دساتور دوم‪ ،‬سااختاری از ناوع‬
‫دیکشنری ایجاد کرده‪ ،‬در ‪ dt‬قرار میدهد‪ ،‬دستور سوم‪ ،‬آرایهای با سه عنصر به ناام ‪ a‬باا ناوع ‪ dt‬ایجااد‬
‫مینماید و دستور چهارم‪ ،‬اطالعات آرایه ‪ )[ 5 10 15]( a‬را نمایش میدهد‪.‬‬
‫خاصیت‌‪ ،ndarray.shape‬این خاصیت تاپلی را برمیگرداند که شاامل ابعااد آرایاه اسات‪ .‬از ایان‬
‫خاصیت میتوان برای تغییر اندازه آرایه نیز استفاده کرد‪ .‬بهعنوانمثال‪ ،‬دستورات زیر را ببینید‪:‬‬

‫‪>>> import numpy as np‬‬

‫)]]‪>>> a = np.array([[1, 3, 5], [2, 4, 6‬‬
‫)‪>>> print(a.shape‬‬
‫)‪>>> a.shape = (3, 2‬‬
‫)‪>>> print(a‬‬
‫دستور اول‪ ،‬مالول ‪ numpy‬را با نام ‪ np‬به برنامه اضافه میکند‪ ،‬دستور دوم‪ ،‬آرایهای دوبعادی ‪× 9‬‬
‫‪ 0‬به نام ‪ a‬ایجاد میکند و عناصر آن را مقادار مایدهاد‪ ،‬دساتور ساوم‪ ،‬تعاداد ابعااد آرایاه ‪ )0, 9( a‬را‬
‫نمایش میدهد‪ ،‬دستور چهارم‪ ،‬ابعاد آرایه ‪ a‬را به ‪( 9 × 0‬سه سطر و دو ستون) تغییر مایدهاد و دساتور‬
‫پنجم‪ ،‬محتوی آرایه ‪ )9 × 0( a‬را پس از تغییر ابعاد نمایش میدهد(خروجی زیر)‪:‬‬

‫]‪[[1 3‬‬
‫]‪[5 2‬‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪11‬‬

‫]]‪[4 6‬‬
‫متد‌)(‪ ،reshape‬برای تغییر ابعاد آرایه به کار میرود‪ .‬این متد بهصورت زیر استفاده میشود‪:‬‬
‫)'‪ .reshape (shape, order = 'c‬نام آرایه‬
‫پارامتر ‪ ،shape‬تعاداد ابعااد را مشاخص مایکناد‪ .‬عملکارد پاارامتر ‪ order‬را در متاد ‪ array‬دیدیاد‪.‬‬
‫بهعنوانمثال‪ ،‬دستورات زیر را ببینید‪:‬‬

‫‪>>> import numpy as np‬‬

‫)]]‪>>> a = np.array([[1, 3, 5], [2, 4, 6‬‬
‫)‪>>> b = a.reshape(3, 2‬‬
‫)‪>>> print(b‬‬
‫دستور اول‪ ،‬مالول ‪ numpy‬را با نام ‪ np‬به برنامه اضافه میکند‪ ،‬دستور دوم‪ ،‬آرایهای ‪ 0 × 9‬باه ناام‬
‫‪ a‬ایجاد میکند‪ ،‬دستور سوم‪ ،‬از طریق آرایه ‪ a‬یک آرایه ‪ 9 × 0‬ایجاد کرده‪ ،‬در آرایهای باه ناام ‪ b‬قارار‬
‫میدهد و دستور چهارم‪ ،‬اطالعات آرایه ‪ b‬را نمایش میدهد(خروجی زیر)‪:‬‬

‫]‪[[1 3‬‬
‫]‪[5 2‬‬
‫]]‪[4 6‬‬
‫خاصیت‌‪ ،rdarray.ndim‬تعداد ابعاد آرایه را برمیگرداند‪.‬‬
‫خاصیت‌‪ ،ndarray.itemsize‬اندازه عناصر آرایه را برمیگرداند‪ .‬بهعناوانمثاال‪ ،‬دساتورات زیار را‬
‫ببینید‪:‬‬
‫‪>>> import numpy as np‬‬
‫)‪>>> a = np.array([[1, 3, 5], [2, 4, 6], [3, 7, 8]], dtype=np.float32‬‬
‫)‪>>> print(a.ndim‬‬
‫)‪>>> print(a.itemsize‬‬
‫دستور اول‪ ،‬مالول ‪ numpy‬را با نام ‪ np‬به برنامه اضافه میکند‪ ،‬دستور دوم‪ ،‬آرایهای ‪ 9 × 9‬به نام باا‬
‫نوع ‪ float32‬ایجاد میکند‪ ،‬دستور سوم‪ ،‬تعداد ابعاد آرایه ‪( a‬یعنی ‪ )0‬را نمایش میدهد‪ ،‬دستور چهارم‪،‬‬
‫اندازه هر عنصر (یعنی ‪ ۳‬برای ‪ )float32‬را نمایش میدهد‪.‬‬
‫متد‌)(‪ ،numpy.empty‬یک آرایه بدون مقدار اولیه ایجاد میکند که بهصورت زیار باه کاار مای‪-‬‬
‫رود‪:‬‬
‫)‪numpy.empty (shape, dtype, order‬‬

‫‪@PythonForever‬‬
 ‫‪ 11‬فصل اول‬

‫پارامترهااای ‪ dtype ،shape‬و ‪ order‬هماننااد پارامترهااای متااد )(‪ arrary‬هسااتند‪ .‬بااهعنااوانمثااال‪،‬‬

‫دستورات زیر را ببینید‪:‬‬

‫‪>>> import numpy as np‬‬

‫)‪>>> a = np.empty([2,2], dtype = np.int8‬‬
‫)‪>>> print(a‬‬
‫دستور اول‪ ،‬مالول ‪ numpy‬را با نام ‪ np‬به برنامه اضافه میکند‪ ،‬دساتور دوم‪ ،‬یاک آرایاه ‪ 0 × 0‬باه‬
‫نام ‪ a‬که هر عنصر آن از نوع بایت است‪ ،‬ایجاد میکند و عناصر آن را بهصورت تصادفی مقدار مای‪-‬‬
‫دهد و دستور سوم‪ ،‬محتوی آرایه ‪ a‬را نمایش میدهد(خروجی زیر)‪:‬‬
‫]]‪[[6 0] [0 0‬‬
‫متد‌)(‪،numpy.zeros‬آرایهای را ایجاد کرده و مقادیر اولیه صافر باه عناصار آن تخصایص‬
‫میدهد‪ .‬این متد بهصورت زیر به کار میرود‪:‬‬
‫)‪numpy.zeros (shape, dtype, order‬‬
‫عملکرد پارامترهای ‪ dtype ،shape‬و ‪ order‬را در متد )(‪ arrary‬دیدید‪ .‬بهعنوانمثال‪ ،‬دساتورات‬
‫‪[ 0. 0. 0.‬‬ ‫زیر‪ ،‬آرایهای یکبعدی ‪ ۳‬عنصری با مقادیر صفر ایجاد کرده‪ ،‬نماایش مایدهاد(مقاادیر‬
‫]‪)0.‬‫‪:‬‬

‫‪>>> import numpy as np‬‬

‫)‪>>> a = np.zeros (4‬‬
‫)‪>>> print(a‬‬
‫متد‌)(‪ ،numpy.ones‬آرایهای ایجاد کرده و عناصر آن را به یک پر میکناد‪ .‬ایان متاد باهصاورت‬
‫زیر به کار میرود‪:‬‬
‫)‪numpy.ones (shape, dtype, order‬‬
‫عملکرد پارامترهای ‪ dtype ،shape‬و ‪ order‬را در متد )(‪ arrary‬مشاهده کردید‪ .‬دستورات زیار‬
‫آرایهای به نام ‪ a‬با ابعاد ‪ 0 × 9‬ایجاد کارده‪ ،‬عناصار آن را باا ‪ 6.2‬پار مایکناد و در پایاان‪ ،‬آرایاه ‪ a‬را‬
‫نمایش میدهد‪.‬‬

‫‪>>> import numpy as np‬‬

‫)‪>>> a = np.ones((2,3), dtype = np.float32‬‬
‫)‪>>> print(a‬‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪11‬‬

‫متد‌)(‪ ،numpy.asarray‬آرایهای ایجاد کرده‪ ،‬عناصر آن را با دادهای موجود پر میکند‪ .‬ایان متاد‬
‫بهصورت زیر به کار میرود‪.‬‬
‫)‪numpy.asarray (a, dtype, order‬‬
‫‪ ،a‬پارامتری است که داده ورودی را تعیین میکند که آرایه باید با آن پر شود‪ .‬این داده میتواناد‬
‫لیست تاپلی‪ ،‬تاپلی از تاپل یا تاپلی از لیست باشد‪ .‬با پارامترهای ‪ dtype‬و ‪ order‬در متد )(‪ array‬آشنا‬
‫‪[ 1. 4.‬‬ ‫شدید‪ .‬بهعنوانمثال‪ ،‬دستورات زیر اطالعات لیست ‪ x‬را در آرایه ‪ a‬قرار میدهند و آرایاه ‪( a‬‬
‫‪ )6.‬را نمایش میدهند‪:‬‬ ‫]‪8.‬‬

‫‪>>> import numpy as np‬‬

‫]‪>>> x = [1, 4, 6 , 8‬‬
‫)‪>>> a = np.asanyarray(x, dtype = np.float64‬‬
‫)‪>>> print(a‬‬

‫‪@PythonForever‬‬
 ‫‪ 11‬فصل اول‬

‫فصل‬
‫رشتهها‬
‫‪5‬‬
‫‌‬
‫رشته‪ ،‬یکی از پرکاربردترین انواع داده در پایتون است‪ .‬رشتهها‪ ،‬دنبالهای از کاراکترها هستند که‬
‫در داخل تک کتیشن(') یا جفت کتیشن(") قرار میگیرند‪ .‬بهعنوانمثال‪ ،‬دستوارت زیر را ببینید‪:‬‬
‫'‪>>> url = 'www.fanavarienovin.net‬‬
‫"‪>>> language = "Python programming‬‬
‫دستور اول‪ ،‬رشتهای به ناام ‪ url‬تعریاف کارده‪ ،‬مقادار `‪ `www.fanavarienovin.net‬را در آن قارار‬
‫میدهد‪ ،‬دستور دوم‪ ،‬متغیری به نام ‪ language‬با مقدار "‪ "Phython.Programming‬ایجاد میکند‪.‬‬

‫‪ .5-1‬عملگرهای رشتهای‬

‫جدول‌‪‌‌6‌–‌1‬عملگرهای‌رشتهای‪‌.‬‬
‫هد ‌‬ ‫نام‌‬ ‫عملگر‌‬

‫بین دو رشته قرارگرفته‪ ،‬رشتهای را به رشته دیگر متصل میکند‪.‬‬ ‫‪ +‬اتصال‬

‫بین یکرشته و یک عدد قرارگرفته‪ ،‬رشته را به تعداد عدد تکرار میکند و‬ ‫* تکرار‬
‫رشته جدیدی ایجاد مینماید‪.‬‬
‫کاراکتر با اندیس خاصی از رشته را برمیگرداند‪.‬‬ ‫] [ برش‬
‫این عملگر دو اندیس میپذیرد که اندیس شروع (مشخصکننده اولین‬ ‫] ‪ [ :‬برش در یک‬
‫کاراکتر) و اندیس پایان (آخرین کاراکتر) هستند و کاراکترهای بین این‬ ‫محدوده مشخص‬
‫دو اندیس را برمیگرداند‪.‬‬
‫عضویت کاراکتری را در رشته بررسی میکند‪ ،‬در صورت موجود بودن‬ ‫‪ In‬عضویت‬
‫کاراکتری در رشته ‪ ،True‬وگرنه ‪ False‬را برمیگرداند‪.‬‬
‫در صورت موجود نبودن کاراکتری در رشته ‪ ،True‬وگرنه ‪ False‬را‬ ‫‪ not in‬عضو نبودن‬
‫برمیگرداند‪.‬‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪11‬‬

‫عملکرد و معنی اصلی کاراکتر را لغو میکند‪.‬‬ ‫‪ r/R‬رشتهی خام‬

‫یکرشته را قالببندی میکند‪.‬‬ ‫‪ %‬فرمت دهی‬

‫عملگرهایی وجود دارند که برای کار بر روی رشتهها استفاده میشوند‪ .‬خالصه این عملگرها در‬
‫جدول ‪ 0-6‬آمدهاند‪ .‬در ادامه شر کامل این عملگرها را میبینید‪.‬‬
‫عملگر‪ ،+‬برای اتصال دو رشته به کار میرود‪ .‬بهعنوانمثال‪ ،‬دستورات زیر را ببینید‪:‬‬
‫"‪>>> name = "fanavarienovin‬‬
‫"‪>>> url = "www." + name + ".net‬‬
‫)‪>>> print(url‬‬
‫دستور اول‪ ،‬رشتهای به نام ‪ name‬با مقدار "‪ "fanavarienovin‬ایجاد میکند‪ ،‬دستور دوم‪ ،‬رشتههای‬
‫"‪ "www.‬و `‪ `.net‬را به ترتیب به ابتدا و انتهای رشته ‪ name‬اضافه میکند تا رشته ‪ url‬را تولید کند و‬
‫دستور سوم‪ ،‬محتوی ‪( url‬یعنی‪)www.fanavarienovin.net"" ،‬را نمایش میدهد‪.‬‬
‫عملگر*‪ ،‬رشتهای را چندین بار تکرار میکند‪ .‬بهعنوانمثال‪ ،‬دستورات زیر را ببینید‪:‬‬
‫‪>>> s1 = "Python" * 5‬‬
‫)‪>>> print(s1‬‬
‫دستور اول‪ ،‬رشته "‪ "Python‬را پنج بار تکرار کرده‪ ،‬در متغیر رشتهای به نام ‪ s1‬قرار میدهد‪،‬‬
‫دستور دوم‪ ،‬محتوی رشته ‪ ( s1‬مقدار ‪)PythonPythonPythonPythonPython‬را نمایش میدهد‪.‬‬
‫عملگر] [‪ ،‬کاراکتر خاصی از رشته را برمیگرداند‪ .‬بهعنوانمثال‪ ،‬دستورات زیر را ببینید‪:‬‬
‫"‪>>> s = "Python‬‬
‫)]‪>>> print(s[3], s[4], s[1‬‬
‫دستور اول‪ ،‬رشته ‪ s‬را با مقدار "‪ "Python‬تعریف میکند‪ .‬اکنون کاراکترهای رشته بهصورت زیر‬
‫اندیس گذاری میشوند‪:‬‬
‫‪P‬‬ ‫‪y‬‬ ‫‪t‬‬ ‫‪h‬‬ ‫‪o‬‬ ‫‪n‬‬
‫]‪s[0‬‬ ‫]‪s[1‬‬ ‫]‪s[2‬‬ ‫]‪s[3‬‬ ‫]‪s[4‬‬ ‫]‪s[5‬‬
‫دستور دوم‪ ،‬مقادیر اندیسهای ‪ )`0`( 4 ،)`h`( 3‬و ‪ )`y`( 1‬را به ترتیب نمایش میدهد(مقدار‬
‫‪.)hoy‬‬
‫دقت کنید که اگر بخواهید به اندیسی دسترسی داشته باشید که وجود ندارد‪ ،‬از طرف مفسر پایتون‬
‫خطا صادر میشود‪ .‬بهعنوانمثال‪ ،‬دستور زیر را ببینید‪:‬‬

‫‪@PythonForever‬‬
 ‫‪ 11‬فصل اول‬

‫)]‪>>> print(s[10‬‬

‫چون اندیس ‪ 62‬برای رشته ‪ s‬وجود ندارد‪ ،‬پیغام خطای زیر صادر خواهد شد‪:‬‬
‫‪Traceback (most recent call last):‬‬
‫>‪File "<pyshell#13>", line 1, in <module‬‬
‫)]‪print(s[10‬‬
‫‪IndexError: string index out of range‬‬
‫برش‌رشتهها)‪ ،‬برای برش رشته به کار میرود‪ ،‬بهطوریکه از کاراکتر ‪ n‬رشته تا‬
‫‌‬ ‫عملگر‌]‪(‌[n:m‬‬

‫کاراکتر ‪ m‬آن را جدا میکند‪ .‬قبل از اینکه به برش رشته بپردازیم‪ ،‬نحوه ذخیرهسازی و اندیس‬
‫گذاری رشته را شر میدهیم‪ .‬بهعنوانمثال‪ ،‬دستور زیر را مشاهده کنید‪:‬‬
‫"‪>>> s = "www.fanavarienovin.net‬‬

‫این دستور رشته ‪ s‬را بهصورت زیر اندیس گذاری میکند‪:‬‬

‫‪-22‬‬ ‫‪-21‬‬ ‫‪-20‬‬ ‫‪-19‬‬ ‫‪-18‬‬ ‫‪-17‬‬ ‫‪-16‬‬ ‫‪-15‬‬ ‫‪-14‬‬ ‫‪-13‬‬ ‫‪-12‬‬ ‫‪-11‬‬ ‫‪-10‬‬ ‫‪-9‬‬ ‫‪-8‬‬ ‫‪-7‬‬ ‫‪-6‬‬ ‫‪-5‬‬ ‫‪-4‬‬ ‫‪-3‬‬ ‫‪-2‬‬ ‫‪-1‬‬
‫‪w‬‬ ‫‪w‬‬ ‫‪w‬‬ ‫‪.‬‬ ‫‪f‬‬ ‫‪a‬‬ ‫‪n‬‬ ‫‪a‬‬ ‫‪v‬‬ ‫‪A‬‬ ‫‪r‬‬ ‫‪i‬‬ ‫‪e‬‬ ‫‪n‬‬ ‫‪o‬‬ ‫‪v‬‬ ‫‪i‬‬ ‫‪n‬‬ ‫‪.‬‬ ‫‪n‬‬ ‫‪e‬‬ ‫‪t‬‬
‫‪0‬‬ ‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪5‬‬ ‫‪6‬‬ ‫‪7‬‬ ‫‪8‬‬ ‫‪9‬‬ ‫‪10‬‬ ‫‪11‬‬ ‫‪12‬‬ ‫‪13‬‬ ‫‪14‬‬ ‫‪15‬‬ ‫‪16‬‬ ‫‪17‬‬ ‫‪18‬‬ ‫‪19‬‬ ‫‪20‬‬ ‫‪21‬‬

‫در هنگام برش رشته‪ ،‬اندیسها میتوانند مثبت یا منفی باشند‪ .‬اگر اندیسها مثبت باشند‪ ،‬با توجه به‬
‫مقادیر ‪ n‬و ‪ m‬کاراکترهای اندیس ‪ n‬تا ‪ m‬رشته را برمیگرداند(کاراکتر اندیس ‪ m‬را برنمیگرداند)‪.‬‬
‫بهعنوانمثال‪ ،‬دستور زیر را ببینید‪:‬‬
‫)]‪>>> print(s[5:12‬‬
‫‪>>> print(s[8:19]).‬‬
‫دستور اول‪ ،‬کاراکترهایی از اندیس ‪ 0‬تا ‪ 66‬رشته ‪ s‬را نمایش میدهد (یعنی‪ ،‬از کاراکتر ‪ a‬تا‬
‫کاراکتر ‪ i‬همان رشته "‪ ) "anavari‬و دستور دوم‪ ،‬از کاراکتر ‪ 8‬تا کاراکتر ‪ 68‬رشته ‪( s‬یعنی‪ ،‬همان‬
‫رشته "‪ )"varienovin.‬را برمیگرداند‪ .‬در هنگام برش رشته میتوان ‪ m‬را حذف کرد ( یعنی بهصورت‬
‫]‪ [n:‬استفاده نمود)‪ .‬در این صورت‪ ،‬از ‪n‬امین کاراکتر تا انتهای رشته را برمیگرداند‪ .‬بهعنوانمثال‪،‬‬
‫دستورات زیر را ببینید‪:‬‬
‫)]‪>>> print(s[15:‬‬
‫)]‪>>> print(s[13:‬‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪11‬‬

‫دستور اول از کاراکتر ‪ 60‬رشته ‪ s‬تا انتهای آن (یعنی‪ 7 ،‬کاراکتر آخر رشته همان "‪ )"vin.net‬را‬
‫نمایش میدهد و دستور دوم‪ ،‬از کاراکتر ‪ 69‬رشته ‪ s‬تا انتهای آن (یعنی‪ ،‬رشته "‪ )"novin.net‬را نمایش‬
‫میدهد‪.‬‬
‫در هنگام برش رشته میتوان ‪ n‬را حذف کرد (یعنی بهصورت ]‪ [:m‬استفاده کرد)‪ .‬در این صورت‪،‬‬
‫از شروع رشته تا قبل از کاراکتر ‪ m‬آن را برمیگرداند‪ .‬بهعنوانمثال‪ ،‬دستورات زیر را ببینید‪:‬‬
‫)]‪>>> print(s[:8‬‬
‫‪>>> print(s[:4]).‬‬
‫دستور اول‪ ،‬از کاراکتر شروع تا کاراکتر ‪ 8‬رشته (یعنی‪ ،‬همان `‪ ) `www.fana‬را نمایش میدهد و‬
‫دستور دوم‪ ،‬از کاراکتر شروع تا کاراکتر چهارم (یعنی `‪ )`www.‬را نمایش میدهد‪.‬‬
‫در هنگام برش رشته میتوان ‪ m‬و ‪ n‬را دو عدد منفی وارد کرد‪ .‬در این صورت‪ ،‬بهجای استفاده از‬
‫اندیسهای پایین رشته از اندیسهای باالی رشته شکل فوق استفاده میکند‪ .‬بهعنوانمثال‪ ،‬دستورات‬
‫زیر را ببینید‪:‬‬
‫)]‪>>> print(s[-4:-1‬‬
‫)]‪>>> print(s[-17:-10‬‬
‫دستور اول‪ ،‬کاراکترهای از اندیس ‪ -4‬تا اندیس ‪ -2‬رشته را جدا کرده (یعنی `‪ )`.ne‬و نمایش‬
‫میدهد و دستور دوم‪ ،‬کاراکترهای از اندیس ‪ -17‬تا ‪ -11‬را جدا کرده (یعنی‪ ) `anavari` ،‬و نمایش‬
‫میدهد‪ .‬مانند حالتهای قبل میتوان اندیسهای ‪ m‬و ‪ n‬را حذف کرد‪ .‬درصورتیکه اندیس ‪ m‬حذف‬
‫شود و ‪ n‬منفی باشد‪ ،‬از اندیس ‪ –n‬تا انتهای رشته را برمیگرداند‪ .‬بهعنوانمثال‪ ،‬دستور زیر را ببینید‪:‬‬
‫)]‪>>> print(s[-4:‬‬

‫این دستور از اندیس ‪ -4‬تا انتهای رشته (یعنی "‪ )".net‬را نمایش میدهد‪.‬‬
‫اگر اندیس ‪ n‬حذف شود‪ ،‬از کاراکترهای ابتدای رشته تا اندیس ‪ – m - 1‬را برمیگرداند‪.‬‬
‫بهعنوانمثال‪ ،‬دستور زیر را ببینید‪:‬‬
‫)]‪>>> print(s[:-10‬‬

‫این دستور از ابتدای رشته (یعنی‪ ،‬اندیس ‪ )-22‬تا اندیس ‪ -11‬آن را نمایش میدهد (یعنی‪ ،‬رشته‬
‫`‪ `www.fanavari‬را نمایش میدهد)‪.‬‬

‫‪@PythonForever‬‬
 ‫‪ 11‬فصل اول‬

‫در هنگام برش رشته‪ ،‬چنانچه اندیس اول بزرگتر یا مساوی اندیس دوم باشد‪ ،‬نتیجه برش‬
‫یکرشته تهی خواهد بود‪ .‬بهعنوانمثال‪ ،‬دستورات زیر را ببینید‪:‬‬
‫)]‪>>> print(s[12:11‬‬
‫)]‪>>> print(s[-11:-12‬‬
‫)]‪>>> print(s[14:14‬‬
‫دستور اول‪ ،‬میخواهد از اندیس ‪ 60‬تا ‪ 66‬را برش دهد‪ ،‬چون ‪ 60‬بزرگتر از ‪ 66‬است‪ ،‬یکرشته‬
‫تهی (خالی) را نمایش میدهد‪ ،‬دستور دوم‪ ،‬نیز یکرشته تهی را برمیگرداند‪ .‬چون ‪ -11‬بزرگتر از ‪-‬‬

‫‪ 12‬است و دستور سوم‪ ،‬همچنین یکرشته تهی را برمیگرداند‪ ،‬چون ‪ 14‬برابر ‪ 14‬است‪.‬‬
‫عملگر‌‪ ،in‬رشتهای را در رشته دیگر جستوجو میکند‪ .‬چنانچه رشته اول در رشته دوم باشد‪،‬‬
‫‪ ،True‬وگرنه ‪ False‬را برمیگرداند‪ .‬بهعنوانمثال‪ ،‬دستورات زیر را ببینید‪:‬‬
‫"‪>>> s = "Python‬‬
‫)‪>>> print("th" in s‬‬
‫دستور اول‪ ،‬رشته ‪ s‬را با مقدار `‪ `Python‬تعریف میکند و دستور دوم‪ ،‬رشته `‪ `th‬را در ‪s‬‬

‫جستوجو میکند و نتیجه را نمایش میدهد‪ ،‬چون `‪ `th‬در ‪ s‬وجود دارد‪ ،‬نتیجه ‪ True‬نمایش داده‬
‫میشود‪.‬‬
‫عملگر‌‪‌،not in‬رشتهای را در رشته دیگر جستوجو میکند‪ ،‬چنانچه رشته اول در رشته دوم موجود‬
‫نباشد‪ ، True ،‬وگرنه ‪ False‬را برمیگرداند‪ .‬دستورات زیر را مشاهده کنید‪:‬‬
‫"‪>>> s = "Python‬‬
‫)‪>>> print("th" not in s‬‬
‫دستور اول‪ ،‬رشته ‪ s‬را با مقدار "‪ "Python‬تعریف میکند و دستور دوم‪ ،‬مقدار ‪ False‬را نمایش‬
‫میدهد‪ ،‬چون رشته ‪ th‬در رشته ‪ s‬وجود دارد‪.‬‬
‫ای‌که‌رشتهای‌را‌خواند ‪‌،‬اعمال‌زیر‌را‌انجام‌می‌دهد‌(هد ‌این‌برنامه‌آشنایی‌با‌‬
‫‌‬ ‫‌‬
‫برنامه‬‫مثال‪‌.6-1‬‬
‫عملگرهای‌رشته‌است)‪‌:‬‬

‫جایگکین‌میکند‪‌.‬‬
‫‌‬ ‫‪ .6‬قبل‌از‌رشته‌عبارت‌"‪‌"Hello‬را‌قرار‌داد ‌و‌با‌‌رشته‌خواند ‌شد ‌‬

‫‪‌n .8‬را‌خواند ‪‌،‬کاراکتر‌‪‌n‬رشته‌را‌برمیگرداند‪‌.‬‬

‫رشتهای‌دیگری‌را‌خواند ‪‌،‬اگر‌رشته‌خواند ‌شد ‌دوم‌در‌رشته‌اول‌وجود‌داشت‪‌‌،‌"Yes"‌،‬وگرنه‌"‪‌"No‬را‌‬
‫‪‌ ‌.4‬‬
‫چاپ‌میکند‪‌.‬‬
‫‪‌ n‌‌.3‬و‌‪‌m‬را‌خواند ‌از‌کاراکتر‌‪n‬ام ‌تا‌‪m‬ام ‌رشته‌را‌نمایش‌میدهد‌(عمل‌‪‌‌3‬را‌‌‪6‬بار‌انجام‌دهد)‪‌.‬‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪10‬‬

‫مراحل‌طراحی‌و‌اجرا‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات زیر را تایپ کنید‪:‬‬

‫هد ‌‬ ‫متغیر‌‬

‫‪ s‬رشته ورودی‬
‫‪ n‬اندیس کاراکتری که باید برگردانده شود یا اندیس شروع کاراکتری که باید برگردانده شود‪.‬‬
‫‪ s1‬رشتهای که باید جستوجو گردد‪.‬‬
‫‪ i‬شمارنده ‪ 6‬تا ‪0‬‬
‫‪ m‬اندیس پایان کاراکتری که باید برگردانده شود‪.‬‬

‫)"‪s = input("Enter a string:‬‬

‫‪s = "Hello " + s‬‬
‫)‪print(s‬‬
‫))"‪n = int(input("Enter n:‬‬
‫‪if n < len( s) :‬‬
‫)]‪print(s[n‬‬
‫)"‪s1 = input("Enter a string for search:‬‬
‫‪if s1 in s:‬‬
‫)"‪print("Yes‬‬
‫‪else:‬‬
‫)"‪print("No‬‬
‫‪for i in range(1, 6):‬‬
‫))"‪n = int(input("Enter n:‬‬
‫))"‪m = int(input("Enter m:‬‬
‫)]‪print(s[n:m‬‬

‫‪ .0‬مالول را ذخیره و اجرا کنید‪ .‬نمونه خروجی این مالول در زیر آمده است‪:‬‬
‫‪Enter a string:python‬‬
‫‪Hello python‬‬
‫‪Enter n:7‬‬
‫‪y‬‬
‫‪Enter a string for search:llo‬‬
‫‪Yes‬‬
‫‪Enter n:1‬‬
‫‪Enter m:3‬‬
‫‪el‬‬
‫‪Enter n:-7‬‬
‫‪Enter m:-4‬‬

‫‪@PythonForever‬‬
 ‫‪ 11‬فصل اول‬

‫‪py‬‬
‫‪Enter n:3‬‬
‫‪Enter m:9‬‬
‫‪lo pyt‬‬
‫‪Enter n:-4‬‬
‫‪Enter m:-6‬‬
‫‪Enter n:6‬‬
‫‪Enter m:6‬‬
‫شروع‌میشوند‪‌.‬‬
‫‌‬ ‫جدول‌‪‌6-8‬کاراکترهای‌چاپ‌نشدنی‌که‌با‌\‌‬
‫هد ‌‬ ‫معادل‌مبنای‌‪‌16‬‬ ‫متغیر‌‬

‫‪ 0x07‬بوق یا هشدار سیستم را به صدا در میآورد‪.‬‬ ‫‪\a‬‬

‫‪ 0x08‬کاراکتر برگشت به عقب (‪ )Backspace‬را تایپ میکند‪.‬‬ ‫‪\b‬‬

‫کاراکتر ‪ ctrl + x‬میباشد‪.‬‬ ‫‪\cx‬‬

‫کاراکتر ‪ ctrl + x‬است‪.‬‬ ‫‪\c-x‬‬

‫‪ 0x1b‬کاراکتر ‪ Escape‬میباشد‪.‬‬ ‫‪\e‬‬

‫‪ 0x0c‬برای ایجاد صفحه جدیدی (‪ )formfeed‬میباشد‪.‬‬ ‫‪\f‬‬

‫‪ 0x0a‬برای ایجاد سطر جدیدی (‪ )new line‬میباشد‪.‬‬ ‫‪\n‬‬

‫نشانگذاری هشت را انجام میدهد که در آن هر ‪ n‬عدد بین ‪ 2‬تا ‪ 7‬است‪.‬‬ ‫‪\nnn‬‬

‫‪ 0x0d‬به سر سطر فعلی برمیگردد‪.‬‬ ‫‪\r‬‬

‫‪ 0x20‬جای خالی (‪ )Space‬ایجاد میکند‪.‬‬ ‫‪\s‬‬

‫‪ 0x09‬برای انتقال مکاننما به تب بعدی به کار میرود‪.‬‬ ‫‪\t‬‬

‫‪ 0x0b‬چندین سطر خالی بهصورت عمودی ایجاد میکند‪.‬‬ ‫‪\v‬‬

‫کاراکتر ‪ x‬را نمایش میدهد‪.‬‬ ‫‪\x‬‬

‫نشانگذاری مبنای ‪ 61‬را انجام میدهد که در آن ‪ n‬بین ‪ 2‬تا ‪،`C` ،`B` ،`A` ،3‬‬ ‫‪\xnn‬‬

‫`‪`E` ،`D‬یا `‪ `F‬میباشد‪.‬‬

‫عملگر‌\‪ ،‬کاراکترهای غیرقابلچاپ (چاپ نشدنی) را ارائه میدهد که هریک از کاراکترها مفهوم‬
‫خاصی دارند‪ .‬تاکنون با نمونه این کاراکترها `‪ `\t‬آشنا شدید‪ .‬در جدول ‪ 0-0‬برخی از کاراکترهای‬
‫چاپ نشدنی و مفهوم آنها که با کاراکتر \ شروع میشوند‪ ،‬آمدهاند‪.‬‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪11‬‬

‫عملگر‪ ،%‬یکی از عملگرهای جالب پایتون است که برای قالببندی رشته به کار میرود‪.‬‬
‫کاراکترهای که بعدازاین عملگر قرار میگیرند‪ ،‬هریک برای قالببندی دادههای خاصی به کار‬
‫میروند‪ .‬برخی از این کاراکترها و عملکردهای آنها در جدول ‪ 0-9‬آمدهاند‪.‬‬
‫میروند‪‌.‬‬
‫یی‌که‌برای‌قالببندی‌به‌کار‌ ‌‬
‫‌‬ ‫‌‬
‫کاراکترها‬ ‫جدول‪‌6-‌4‬‬
‫هد ‌‬ ‫متغیر‌‬

‫‪ %c‬برای قالببندی کاراکترها به کار میرود‪.‬‬

‫‪ %C‬برای قالببندی رشته به کار میرود‪.‬‬
‫‪ %i ,‬برای قالببندی عدد صحیح عالمتدار در مبنای ‪ 62‬به کار میرود‪.‬‬
‫‪%d‬‬
‫برای قالببندی عدد صحیح بدون عالمت در مبنای ‪ 62‬به کار میرود‪.‬‬ ‫‪%v‬‬

‫‪ %o‬برای قالببندی عدد در مبنای ‪ 8‬به کار میرود‪.‬‬

‫برای قالببندی عدد صحیح در مبنای ‪ 61‬به کار میرود و حروف `‪ `A‬تا `‪`Z‬‬ ‫‪%x‬‬

‫را با حروف کوچک نمایش میدهد‪.‬‬

‫برای قالببندی عدد صحیح در مبنای ‪ 61‬به کار میرود و حروف `‪ `A‬تا `‪`Z‬‬ ‫‪%X‬‬

‫را با حروف بزرگ نمایش میدهد‪.‬‬

‫برای قالببندی نماد توانی(نمایی) با حرف ‪ e‬به کار میرود‪ .‬یعنی‪ ،‬حروف ’‪‘A‬‬ ‫‪%e‬‬

‫تا ’‪ ‘F‬را با حروف کوچک نمایش میدهد‪.‬‬

‫‪ %E‬برای قالببندی نماد توانی (نمایی) با حرف ‪ E‬به کار میرود‪ .‬یعنی‪ ،‬حروف‬
‫’‪ ‘A‬تا ’‪ ‘F‬را با حروف بزرگ نمایش میدهد‪.‬‬
‫‪ %f‬برای قالببندی اعداد حقیقی با ممیز شناور به کار میرود‪.‬‬
‫‪ %g‬برای قالببندی با فرم کوتاهتر ‪ %f‬و ‪ %e‬میباشد‪.‬‬

‫برای قالببندی با فرم کوتاهتر ‪ %f‬و ‪ %E‬میباشد‪.‬‬ ‫‪%G‬‬

‫کاراکترهای قالببندی را میتوان با برخی کاراکترهای دیگر به کار برد که هر یک از این‬

‫کاراکترها کار خاصی را انجام میدهند‪ .‬برخی از این کاراکترها و عملکرد آنها در جدول ‪0-۳‬‬
‫آمدهاند‪.‬‬
‫بهعنوانمثال‪ ،‬دستورات زیر را مشاهده کنید‪:‬‬

‫‪@PythonForever‬‬
 ‫‪ 11‬فصل اول‬

‫‪>>> a = 20‬‬
‫)))‪>>> print( %10i, %18d, %E" %(a, -a, float(a‬‬
‫با اجرای این دستورات ‪ a‬برابر ‪ 22‬شده و خروجی زیر نمایش داده میشود‪:‬‬
‫‪20,‬‬ ‫‪-20, 2.000000E+01‬‬
‫همانطور که در این خروجی میبینید‪ ،‬قبل از عدد ‪ 02‬هشت فاصله نمایش دادهشده است‪ .‬چون‪،‬‬
‫‪ 02‬با فرمت ‪ %62i‬چاپ شد که در چاپ به شکل زیر عمل میکند‪:‬‬
‫‪2‬‬ ‫‪0‬‬

‫بیست را به سمت چپ انتقال داده و ‪ 8‬فاصله قبل از آن نمایش داده است‪ .‬سپس‪ ،‬یک کاما نمایش‬
‫داده است و عدد ‪ )-20( –a‬را با فرمت ‪ %18d‬چاپ کرده است که ‪ 60‬فاصله قبل از آن قرار میگیرد‬
‫(بهصورت زیر عمل میکند)‪:‬‬
‫‪-‬‬ ‫‪2‬‬ ‫‪0‬‬

‫سپس یک عالمت کاما نمایش داده است و معادل عدد اعشاری ‪ a‬را بهصورت ‪ 20000000E+01‬با‬
‫فرمت ‪ %E‬نمایش داده است‪.‬‬
‫اکنون دستورات زیر را در نظر بگیرید‪:‬‬
‫‪>>> a = 125‬‬
‫))‪>>> print("%d\t%o\t %x\t%X\n%08i" % (a, a, a, a, a‬‬
‫دستور اول‪ a ،‬را برابر ‪ 600‬قرار میدهد و دستور دوم‪ ،‬خروجی زیر را نمایش میدهد‪:‬‬
‫‪125‬‬ ‫‪175‬‬ ‫‪7d‬‬ ‫‪7D‬‬
‫‪00000125‬‬
‫همانطور که در این خروجی مالحظه میشود‪ ،‬عدد ‪ 125‬با فرمت ‪ %d‬نمایش داده میشود‪ ،‬سپس‬
‫چون کاراکتر ‪ \t‬آمده است‪ ،‬مکاننما به تب بعدی انتقال مییابد و عدد صحیح ‪ 125‬به مبنای ‪8‬‬
‫تبدیلشده و خروجی ‪ 175‬نمایش داده میشود‪ ،‬با کاراکتر `‪ `\t‬مکاننما به تب بعدی میرود و مقدار‬
‫‪ 125‬با فرمت ‪ %x‬به عدد مبنای ‪ 61‬یعنی ‪ 7d‬تبدیلشده و نمایش داده میشود‪ ،‬در ادامه کاراکتر `‪`\t‬‬

‫مکاننما را به تب بعدی انتقال میدهد و عدد ‪ 125‬با فرمت ‪ %x‬به مبنای ‪ 61‬تبدیلشده و مقدار ‪7D‬‬

‫نمایش داده میشود‪ ،‬در پایان‪ ،‬کاراکتر `‪ `\n‬مکاننما را به سطر بعدی انتقال میدهد و عدد ‪ 125‬با‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪11‬‬

‫فرمت ‪ %08i‬بهصورت ‪ 00000125‬نمایش داده میشود که بهجای کاراکتر ‪ Space‬قبل از عدد با صفر‬
‫پر میشود‪.‬‬

‫‪ .5-6‬مسائل حل شده‬
‫کند‌و‌نمایش‌میدهد‪‌.‬‬
‫‌‬ ‫‌‬
‫ای‌را‌در‌رشته‌دیگر‌پیدا‌می‬ ‫برنامهای‌که‌با‌تابعی‌که‌تعداد‌ت رار‌رشته‌‬
‫‌‬ ‫مثال ‪‌.1‬‬
‫مراحل‌طراحی‌و‌اجرا‌‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫هد ‌‬ ‫متغیر‌‬ ‫ماژول‌‬

‫‪ mainStr‬رشته ورودی‬
‫‪ subStr‬رشتهای که باید جستجو شود‬ ‫مالول اصلی‬

‫‪ len1‬طول رشته مورد جستجو‬ ‫‪countSubstr‬‬

‫‪ len2‬طول رشته اصلی‬

‫‪ i‬شمارنده هر کاراکتر رشته‬
‫‪ count‬تعداد تکرار رشته مورد جستوجو‬

‫‪def countSubStr(str, substr):‬‬

‫)‪len1 = len(substr‬‬
‫)‪len2 = len(str‬‬
‫‪i = -1‬‬
‫‪count = 0‬‬
‫‪if len1 > len1:‬‬
‫)"‪return ("error:>>> substr is len1onger than str‬‬
‫‪while i <= len2 - len1 + 1:‬‬
‫‪i=i+1‬‬
‫‪if substr == str[ i : i + len1]:‬‬
‫‪count=count + 1‬‬
‫‪return count‬‬
‫)"‪mainStr = input("Enter a string:‬‬
‫)"‪subStr = input("Enter a string for find:‬‬
‫))‪print("Count is ", countSubStr(mainStr, subStr‬‬
‫رشته اصلی (‪ )str‬و رشته مورد جستوجو (‪ )substr‬را بهعنوان پارامتر‬ ‫تابع ‌()‪،countSubstr‬‬

‫قرار‬ ‫‪len2‬‬ ‫و طول رشته اصلی (‪ )str‬را در‬ ‫‪len1‬‬ ‫دریافت کرده‪ ،‬طول رشته مورد جستوجو را به‬
‫قرار میدهد و تعداد تکرار رشته را برابر صفر قرار‬ ‫‪-1‬‬ ‫میدهد‪ .‬اندیس پیمایش رشته ‪ i‬را برابر‬

‫‪@PythonForever‬‬
 ‫‪ 11‬فصل اول‬

‫میدهد‪ ،‬اگر طول رشته مورد جستوجو (‪ )len1‬بیش از طول رشته اصلی (‪ )len2‬باشد‪ ،‬یک پیغام را‬
‫برمیگرداند‪ ،‬وگرنه‪ ،‬تا زمانی که ‪ i‬کوچکتر یا مساوی ‪ len2 - len1 + 1‬باشد‪ ،‬ابتدا به ‪ i‬یک واحد‬
‫اضافه میکند و ‪ substr‬را با ]‪( str[i : i + len1‬یعنی مکان فعلی رشته تا طول رشته مورد جستوجو‬
‫جلو میرود‪ .‬بدین معنی که به طول رشته مورد جستوجو از رشته اصلی جدا میکند) مقایسه کرده و‬
‫اگر این دو مقدار برابر باشند‪ ،‬به ‪ count‬یک واحد اضافه میکند‪ ،‬سپس شرط حلقه را بررسی میکند‪.‬‬
‫عمل مقایسه را برای رشتههای بعدی که از مکانهای بعدی رشته اصلی جدا میگردد‪ ،‬انجام میدهد‪.‬‬
‫در پایان‪ count ،‬را برمیگرداند‪.‬‬
‫‪ .0‬مالول را ذخیره و اجرا کرده‪ ،‬اطالعات زیر را وارد کنید تا خروجی را ببینید‪:‬‬
‫‪Enter a string:C++ is a very good language. Python is a good language.‬‬
‫‪Enter a string for find:good‬‬
‫‪Count is 2‬‬
‫ای‌که‌رشته ای‌را‌خواند ‪‌،‬تمام‌کاراکترهای‌کوچک‌رشته‌را‌به‌بکرگ‌و‌کاراکترهای‌‬
‫‌‬ ‫‌‬
‫برنامه‬‫مثال‪‌.8‬‬
‫بکرگ‌را‌به‌کوچک‌تبدیل‌می‌کند‪‌.‬‬
‫مراحل‌طراحی‌و‌اجرا‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫هد ‌‬ ‫متغیر‌‬ ‫ماژول‌‬

‫‪ str‬رشته ورودی‬ ‫مالول اصلی‬

‫‪ str‬آرگومان که رشته ورودی را دریافت میکند‬
‫‪ s‬رشته تغییریافته‬ ‫‪charChange‬‬

‫اندیس هر کاراکتر رشته ‪str‬‬ ‫‪i‬‬

‫‪def charChange(str):‬‬
‫"" = ‪s‬‬
‫‪for i in range(0, len(str)):‬‬
‫‪if str[i].islower() == True:‬‬
‫)(‪s += str[i].upper‬‬
‫‪else:‬‬
‫)(‪s += str[i].lower‬‬
‫‪return s‬‬
‫)"‪str = input("Enter a string:‬‬
‫)‪str = charChange(str‬‬
‫)‪print("Result is ", str‬‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪11‬‬

‫تابع‌)(‪ ،charChange‬رشته ‪ str‬را بهعنوان پارامتر دریافت کرده‪ ،‬ابتدا رشته ‪( s‬رشته تغییریافته) را‬
‫خالی میکند‪ ،‬سپس با حلقه ‪ for‬هر کاراکتر رشته ‪ str‬را پیمایش میکند‪ ،‬اگر کاراکتر رشته حرف‬
‫کوچک باشد‪ ،‬آن را به حرف بزرگ تبدیل کرده‪ ،‬به انتهای رشته ‪ s‬اضافه میکند‪ ،‬در غیر این‬
‫صورت‪ ،‬حرف کوچک ]‪ str[i‬را به انتهای رشته ‪ s‬اضافه میکند‪ .‬در پایان‪ ،‬رشته ‪ s‬را برمیگرداند‪.‬‬
‫‪ .0‬مالول را ذخیره و اجرا کرده‪ ،‬نمونه خروجی برنامه را بهصورت زیر ببینید‪:‬‬
‫‪Enter a string:Python Is A gooD lanGuage.‬‬
‫‪Result is pYTHON iS a GOOd LANgUAGE.‬‬

‫فصل‬
‫لیستها‪ ،‬چندتاییها‪ ،‬دیکشنریها و مجموعهها‬
‫‪6‬‬

‫تاکنون در فصلهای ‪ 6‬تا ‪ 0‬با انواع دادهها از قبیل اعداد‪ ،‬رشتهها و آرایهها آشنا شدید‪ .‬در این‬
‫فصل انواع دادهای جدیدی از قبیل لیستها‪ ،‬چندتاییها‪ ،6‬دیکشنریها و مجموعهها را میآموزیم‪.‬‬

‫‪ .6-1‬لیستها‬
‫یکی از انواع آماده دیگر در پایتون نوع لیست‪ 0‬است‪ .‬لیست در پایتون مجموعهای از مقادیر هستند‬
‫که در یک متغیر قرار میگیرند‪ .‬یعنی‪ ،‬لیست مانند رشته از دنبالهای از مقادیر تشکیل میشود‪ ،‬اما‬
‫برخالف رشته‪ ،‬یک نوع تغییرپذیر‪‌4‬است‪ .‬هر عضو لیست میتواند هر نوع داده باشد‪ .‬یعنی‪ ،‬اعضای‬
‫لیست میتوانند انواع مختلف داشته باشند‪ .‬بهعبارتدیگر‪ ،‬یک عضو رشتهای باشد و عضو دیگر‬
‫عددی باشد‪ .‬حتی گاهی اوقات اعضای آن میتوانند از نوع لیست باشند‪ .‬اعضای لیست با کاما (‪ ),‬از‬
‫یکدیگر جدا میشوند‪ .‬برای تعریف لیست از عملگرهای ] [ استفاده میشود‪ .‬بهعنوانمثال‪ ،‬دستور زیر‬
‫را ببینید‪:‬‬
‫][ = ‪>>> list1‬‬

‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬

‫‪Tuples‬‬ ‫‪. List‬‬ ‫‪. Mutable‬‬

‫‪@PythonForever‬‬
 ‫‪ 11‬فصل اول‬

‫این دستور یک لیست خالی بهنام ‪ list1‬ایجاد میکند‪ .‬بهجای این دستور میتوان از دستور زیر‬
‫استفاده کرد‪:‬‬
‫)(‪>>> list1 =list‬‬

‫اکنون دستورات زیر را ببینید‪:‬‬

‫]‪>>> list1 = ["Fanavarienovin", 2, True‬‬
‫]‪>>> list1[0‬‬
‫دستور اول‪ ،‬یک لیست بهنام ‪ list1‬ایجاد میکند و به اعضای آن را به ترتیب "‪ 0 ،"Fanavarienovin‬و‬
‫‪ True‬تخصیص میدهد‪ ،‬دستور دوم‪ ،‬محتوی عضو اول آن (]‪ )list1[0‬یعنی‪ ،‬همان `‪`Fanavarienovin‬‬

‫را نمایش میدهد‪.‬‬

‫اندیس لیست از صفر شروع میشود و با استفاده از اندیس میتوان به اعضای لیست دسترسی‬
‫یافت‪ .‬عالوه بر اندیس با استفاده از عملگر ‪ slice‬میتوان به بخشی از لیست دسترسی یافت‪.‬‬
‫بهعنوانمثال‪ ،‬دستورات زیر را ببینید‪:‬‬
‫]]"‪>>> list1 = [1, "Python", "Program language", True, [3, "Ali‬‬
‫]‪>>> list1[2:4‬‬
‫دستور اول‪ ،‬لیستی به نام ‪ list1‬با پنج عضو تعریف کرده‪ ،‬مقادیری را به آنها تخصیص میدهد‪،‬‬
‫دستور دوم‪ ،‬اعضای سوم و چهارم ‪ list1‬را نمایش میدهد )خروجی زیر)‪:‬‬
‫['‪]'Program language', True‬‬
‫ای‌که‌یکرشته‌را‌خواند ‪‌،‬کلمات‌رشته‌را‌جدا‌می‌نماید‌و‌در‌یک‌لیست‌قرار‌می‌دهد‪‌.‬‬
‫‌‬ ‫‌‬
‫برنامه‬‫مثال‪‌.7-1‬‬
‫در‌پایان‪‌،‬اطالعات‌لیست‌را‌نمایش‌میدهد‌( هد ‌این‌برنامه‌آشنایی‌با‌ایجاد‌لیست‌و‌چاپ‌اعضای‌آن‌‬
‫‌‬
‫است)‪‌.‬‬
‫مراحل‌طراحی‌و‌اجرا‪:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫)(‪words=list‬‬ ‫هد ‌‬ ‫متغیر‌‬
‫)"‪s=input("Enter a string:‬‬
‫‪ words‬لیستی از کلمات‬
‫)(‪words=s.split‬‬
‫)‪print(words‬‬ ‫‪ s‬رشته خواندهشده‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪11‬‬

‫دستور اول‪ ،‬یک لیست خالی به نام ‪ words‬ایجاد میکند‪ ،‬دستور دوم‪ ،‬با یک پیغام یکرشته را‬
‫میخواند‪ ،‬در ‪ s‬قرار میدهد‪ ،‬دستور سوم‪ ،‬کلمات رشته را جدا کرده‪ ،‬در لیست ‪ words‬قرار میدهد و‬
‫دستور چهارم‪ ،‬محتوای لیست ‪ words‬را نمایش میدهد‪.‬‬
‫را وارد‬ ‫‪www fanavarienovin net‬‬ ‫‪ .0‬مالول را ذخیره و اجرا کنید‪ .‬اکنون جلوی ‪ string:‬عبارت‬
‫کرده تا خروجی زیر را ببینید‪:‬‬
‫‪Enter a string:www fanavarienovin net‬‬
‫['‪]'www', 'fanavarienovin', 'net‬‬

‫‪ .6-1-1‬عملگرهای کار بر روی لیست‬

‫عملگرهای زیادی برای کار بر روی لیست به کار میروند‪ .‬برخی از این عملگرها عبارتاند از‪:‬‬
‫عملگر‪ ،+‬برای پیوند (اتصال) دو لیست به کار میرود‪ .‬بهعنوانمثال‪ ،‬دستورات زیر را ببینید‪:‬‬
‫]‪>>> list1 = [1, 2‬‬
‫]‪>>> list2 = [3, 4‬‬
‫‪>>> list1 = list1 + list2‬‬
‫‪>>> list1‬‬
‫دستور اول‪ ،‬شیای به نام ‪ list1‬با نوع لیست و مقادیر ‪ 6‬و ‪ 0‬ایجاد میکند‪ ،‬دستور دوم‪ ،‬شیء‬
‫دیگری به نام ‪ list2‬با نوع لیست و مقادیر ‪ 9‬و ‪ ۳‬ایجاد مینماید‪ ،‬دستور سوم‪ ،‬اعضای ‪ list2‬را به انتهای‬
‫‪ list1‬پیوند میزند و دستور چهارم‪ ،‬اعضای ‪ list1‬را نمایش میدهد (خروجی زیر)‪:‬‬
‫]‪[1, 2, 3, 4‬‬
‫عملگر*‪ ،‬برای تکرار اعضای لیست به کار میرود و بهصورت زیر به کار میرود‪:‬‬
‫تعداد تکرار * متغیر لیست >>>‬

‫بهعنوانمثال‪ ،‬دستورات زیر را مشاهده کنید‪:‬‬

‫‪>>> list1 = ['Python'] * 4‬‬
‫‪>>> list1‬‬
‫دستور اول‪ ،‬شیای به نام ‪ list1‬ایجاد کرده‪ ،‬چهار عضو با مقدار "‪ "Python‬در آن قرار میدهد و‬
‫دستور دوم‪ ،‬اعضای‪ list1‬را نمایش میدهد (خروجی زیر)‪:‬‬
‫]'‪['Python', 'Python', 'Python', 'Python‬‬
‫عملگر==‪ ،‬برای مقایسه برابری دو لیست به کار میرود‪ .‬بهعنوانمثال‪ ،‬دستور زیر را ببینید‪:‬‬

‫‪@PythonForever‬‬
 ‫‪ 011‬فصل اول‬

‫]'‪>>> ['Python', 'Program'] == ['Python', 'Program‬‬

‫این دستور اعضای دو لیست را نظیر به نظیر را باهم مقایسه کرده‪ ،‬چون برابرند‪ ،‬خروجی زیر را‬
‫نشان میدهد‪:‬‬
‫‪True‬‬
‫اکنون دستورات زیر را ببینید‪:‬‬
‫]'‪>>> ['Python', 'Program'] == ['PYTHON', 'Program‬‬

‫این دستور دو لیست را باهم مقایسه میکند‪ ،‬چون عضو `‪ `Python‬از لیست اول با عضو‬
‫‪ PYTHON‬از لیست دوم برابر نیست‪ ،‬پس خروجی زیر را نمایش میدهد‪:‬‬
‫‪False‬‬
‫عملگر ‌‪ ،in‬برای بررسی عضویت یک مقدار در یک لیست به کار میرود‪ .‬چنانچه مقدار عضو‬
‫لیست باشد‪ ،‬این عملگر ‪ ،True‬وگرنه ‪ False‬را برمیگرداند‪ .‬بهعنوانمثال‪ ،‬دستورات زیر را ببینید‪:‬‬
‫]]‪>>> list1 = [1, [2, 3], [4,5‬‬
‫‪>>> [4, 5] in list1‬‬
‫‪>>> 5 in list1‬‬
‫دستور اول‪ ،‬یک لیست به نام ‪ list1‬را تعریف میکند و اعضای آن را مقدار میدهد‪ ،‬دستور دوم‪،‬‬
‫تعیین میکند ]‪ [4, 5‬در لیست ‪ list1‬وجود دارد یا نه؟ چون‪ ،‬این عضو در ‪ list1‬وجود دارد‪ ،‬خروجی‬
‫این دستور ‪ True‬میباشد‪ .‬دستور سوم‪ ،‬تعیین میکند که آیا ‪ 5‬در ‪ list1‬وجود دارد یا نه؟ چون ‪ 5‬عضو‬
‫‪ list1‬نیست‪ ،‬خروجی ‪ False‬نمایش داده میشود (‪ 0‬بهتنهایی عضو ‪ list1‬نیست‪ ،‬بلکه لیست ]‪[4, 5‬‬

‫عضو ‪ list1‬است)‪.‬‬
‫‪9‬‬ ‫‪0‬‬
‫است‪.‬‬ ‫مقدار‬ ‫و‬ ‫نوع‬ ‫همانطور که بیان گردید‪ ،‬هر شیء در پایتون شامل شناسه‪،6‬‬ ‫عملگر ‌‪،is‬‬

‫عملگر== دو شیء را ازلحاظ یکسان بودن مقدار آنها بررسی میکند‪ .‬درحالیکه عملگر ‪ is‬دو شیء‬
‫را ازلحاظ یکسان بودن شناسه (خروجی تابع )(‪ )id‬مقایسه میکند‪ .‬بهعنوانمثال‪ ،‬دستورات زیر را‬
‫ببینید‪:‬‬
‫]‪>>> list1 = [1, 2, 3‬‬
‫‪>>> list2 = list1‬‬
‫‪>>> list1 == list2‬‬
‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬
‫‪.Identity‬‬ ‫‪. Type‬‬ ‫‪. Value‬‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪010‬‬

‫‪>>> list2 is list2‬‬

‫دستور اول‪ ،‬شیای به نام ‪ list1‬ایجاد کرده‪ ،‬مقادیر‪ 0 ،6‬و ‪ 9‬را به اعضای آن تخصیص میدهد‪،‬‬
‫دستور دوم‪ ،‬آدرس ‪ list1‬را در ‪ list2‬قرار میدهد‪ ،‬دستور سوم‪ ،‬مقادیر اعضای ‪ list1‬و ‪ list2‬را باهم‬
‫مقایسه میکند‪ ،‬چون نظیر به نظیر باهم برابرند‪ ،‬خروجی زیر را نمایش میدهد‪:‬‬
‫‪True‬‬
‫دستور چهارم‪ ،‬شناسه ‪ list1‬و ‪ list2‬را باهم مقایسه مینماید‪ ،‬چون برابر هستند‪ ،‬خروجی زیر را‬
‫نمایش میدهد‪:‬‬
‫‪True‬‬
‫اکنون‪ ،‬دستورات زیر را ببینید‪:‬‬
‫]‪>>> list1 = [1, 2‬‬
‫]‪>>> list2 = list1[:‬‬
‫‪>>> list1 == list2‬‬
‫‪>>> list2 is list1‬‬
‫دستور اول‪ ،‬شیای به نام ‪ list1‬با اعضای ‪ 6‬و‪ 0‬تعریف میکند‪ ،‬دستور دوم‪ ،‬اعضای ‪ list1‬را در‬
‫‪ list2‬کپی میکند‪ ،‬در دستور سوم‪ ،‬چون مقادیر اعضای ‪ list1‬و ‪ list2‬برابر هستند‪ ،‬عملگر == خروجی‬
‫زیر را نمایش میدهد‪:‬‬
‫‪True‬‬
‫امّا‪ ،‬در دستور چهارم‪ ،‬چون شناسه شیء ‪ list1‬و ‪ list2‬باهم برابر نیستند‪ ،‬عملگر ‪ is‬خروجی زیر را‬
‫برمیگرداند‪:‬‬
‫‪False‬‬
‫برنامه ای‌که‌ابتدا‌اعضای‌یک‌لیست‌را‌خواند ‪‌،‬سپا‌از‌طریق‌نمایش‌یک‌منو‌و‌انتخا ‌‬
‫‌‬ ‫مثال‪‌.7-4‬‬
‫گکینهای‌توسط‌کاربر‪‌،‬ی ی‌از‌اعمال‌زیر‌را‌انجام‌می‌دهد‪‌:‬‬
‫‌‬
‫عضوی‌را‌به‌لیست‌اضافه‌میکند‪.‬‬
‫‌‬ ‫‪.1‬‬
‫‪ .8‬عضوی‌را‌در‌م انی‌خاص‌از‌لیست‌درج‌می‌کند‪.‬‬
‫‪ .4‬عضوی‌را‌از‌لیست‌حذ ‌می‌کند‪.‬‬
‫اعضای‌لیست‌را‌مرتب‌میکند‪.‬‬
‫‌‬ ‫‪.3‬‬
‫اعضای‌لیست‌را‌وارد‌میکند‪.‬‬
‫‌‬ ‫‪.6‬‬
‫‪ .7‬تعداد‌ت رار‌مقداری‌را‌در‌لیست‌شمارش‌می‌کند‪.‬‬
‫یست‌پیدا‌میکند‪.‬‬
‫‌‬ ‫‪ .8‬م ان‌یک‌مقدار‌را‌در‌ل‬

‫‪@PythonForever‬‬
 ‫ فصل اول‬011

‌‫‌و‬count()‌،reverse()‌،sort()‌،remove()‌،insert()‌،append()‌‫هد ‌این‌برنامه‌آشنایی‌با‌متدهای‬
‌.‫‌بر‌روی‌لیست‌است‬indext()
‌:‫مراحل‌طراحی‌و‌اجرا‬

:‫ دستورات آن را بهصورت زیر تایپ کنید‬،‫ مالول جدیدی ایجاد کرده‬.6

‌‌ ‫هد‬ ‌‫متغیر‬ ‌‫تابع‬
.‫متغیری از نوع لیست که اطالعات لیست را نگهداری میکند‬ list1

.‫رشته دریافتی که کلمات آن جدا میشوند‬ s

‫ حذف شود یا مکان آن و تعداد تکرار آن پیدا‬،‫ درج‬،‫عنصری که باید اضافه‬ x ‫مالول اصلی‬
.‫گردد‬
.‫ در آن قرار دارد‬x ‫ درج شود یا اندیسی که‬x ‫مکانی که باید‬ index

menu() ‫مقدار برگشتی تابع‬ choose

.‫گزینهای که کاربر انتخاب کرده است‬ choose menu

def menu():
print ( "1: Append ")
print ( "2: Insert")
print ( "3: Remove")
print ( "4: Sort")
print ( "5: Reverse")
print ( "6: Count")
print ( "7: Index")
print ( "8: Exit")
choose = int(input("Select 1 to 8:"))
return choose
list1= []
s=input("Enter list elements:")
list1=s.split()
print(list1)
while 1:
choose=menu()
if choose == 8 :
break;
elif choose == 1:
x = input("Enter a element for append:")
list1.append(x)
print("List is ", list1)
elif choose == 2:
x = input("Enter a element for insert:")

@PythonForever
011 ‫آشنایی با زبان پایتون‬

index = int(input("Enter insert index:"))

if index < len(list1):
list1.insert(index, x)
print("List is ", list1)
elif choose == 3:
x = input("Enter a remove element:")
if x in list1:
list1.remove(x)
print("List is ", list1)
elif choose == 4:
list1.sort()
print("List is ", list1)
elif choose == 5:
list1.reverse()
print("List is ", list1)
elif choose == 6:
x = input("Enter a element for count:")
print("Count is ", list1.count(x))
elif choose == 7:
x = input("Enter a element for find index:")
if x in list1:
index = list1.index(x)
else:
index = 0
print("Index is ", index)
else:
print("Invalid choose")
print("-"*40)
:‫ نمونهای از خروجی برنامه در زیر آمده است‬.‫ مالول را ذخیره و اجرا کنید‬.0
Enter list elements:Ali Reza
['Ali', 'Reza']
1: Append
2: Insert
3: Remove
4: Sort
5: Reverse
6: Count
7: Index
8: Exit
Select 1 to 8:2
Enter a element for insert:Book
Enter insert index:1

@PythonForever
 ‫ فصل اول‬011

List is ['Ali', 'Book', 'Reza']

----------------------------------------
1: Append
2: Insert
3: Remove
4: Sort
5: Reverse
6: Count
7: Index
8: Exit
Select 1 to 8:4
List is ['Ali', 'Book', 'Reza']
----------------------------------------
1: Append
2: Insert
3: Remove
4: Sort
5: Reverse
6: Count
7: Index
8: Exit
Select 1 to 8:8
‫بقیه گزینهها را خودتان آزمایش نمایید‬

@PythonForever
‫آشنایی با زبان پایتون ‪011‬‬

‫فصل‬
‫کالسها و وراثت‬
‫‪7‬‬

‫برنامههایی که در فصلهای ‪ 6‬تا ‪ 1‬نوشتهایم‪ ،‬همه شامل کاالسهاای آمااده بودناد کاه قابالً توساط‬
‫مفسر زبان ایجاد گردیدند‪ .‬گاهی نیاز است کالسهای جدیدی ایجاد کنید‪ .‬در این فصال روش ایجااد‬
‫کالس جدید و استفاده از آن را میآموزیم‪.‬‬
‫‪ .7 – 0‬کالسها‬
‫دنیای واقعی پر از اشیا است‪ .‬کافی است به اطاراف خودتاان نگااه کنیاد‪ ،‬اطرافتاان از اشایایی نظیار‬
‫دانشگاهها‪ ،‬هواپیماها‪ ،‬انسانها‪ ،‬حیوانات‪ ،‬ماشینها‪ ،‬ساختمانها‪ ،‬موبایلها‪ ،‬رایانهها و غیره تشاکیل شاده‬
‫است‪ .‬در زبانهای برنامهنویسی ساختیافته نظیر ‪ ،C‬پاسکال‪ ،‬برناماهنویساان بار روی اعمهال‌‪(6‬کارهاا یاا‬
‫وظایف (‪ ))Tasks‬بهجای شیء‪ 0‬تمرکز میکردند ( برنامهنویسان در دنیای واقعی زندگی مایکنناد‪ ،‬اماا‬
‫تفکر آنها شیءگرایی نیست)‪ .‬این امر موجب میگردد تا برنامههای نوشتهشده دارای مشکالت زیار ‪-‬‬
‫باشند‪:‬‬
‫‪ .0‬واحدهای تشکیلدهنده برنامه نمیتوانند بهسادگی نشاندهناده اشایای دنیاای واقعای باشاند‪ .‬لاذا‪،‬‬
‫‌مجدد‪ 9‬مناسبی نخواهند داشت‪.‬‬ ‫بخشهای تشکیلدهنده برنامه قابلیت‌استفاد‬

‫‪ .2‬بخشهای تشکیلدهنده برنامه اشیای دنیای واقعی را مدلسازی نمیکنند‪ .‬لذا‪ ،‬پیچیدگی افازایش‬
‫مییابد‪.‬‬
‫‪ .3‬امکان تغییرپذیری دادهها و توابع سخت است‪.‬‬
‫‪ .4‬نگهداری و پشتیبانی برنامهها مشکلتر خواهد شد‪.‬‬
‫اما‪ ،‬در برنامه‌نویسی‌شیگراء‪ ،‬کالسها ایجاد میشوند‪ .‬چون کالسها‪ ،‬اشایای دنیاای واقعای را مادل‪-‬‬
‫سازی میکنند‪ .‬لذا‪ ،‬مزایای زیر را در پی خواهند داشت‪:‬‬

‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬

‫‪.Actions‬‬ ‫‪.Object‬‬ ‫‪.Reuse‬‬

‫‪@PythonForever‬‬
 ‫‪ 011‬فصل اول‬

‫‌مجدد‌افکایش‌مییابد‪‌،‬زیرا‪ ،‬اشیاء را بهراحتی میتوان در برناماههاای مختلاف اساتفاده‬ ‫‪‌ .0‬قابلیت‌استفاد‬

‫نمود‪.‬‬
‫‪‌ .2‬به‌کارگیری‌اشیاء‌راحتتر‌خواهد‌بود‪ ،‬زیرا‪ ،‬این اشیا‪ ،‬اشیای دنیای واقعی را مدلسازی خواهناد کارد‪.‬‬
‫بنابراین‪ ،‬موجب کاهش پیچیدگی خواهند شد‪.‬‬
‫‪‌ .3‬قابلیت‌نگهداری‌اشیاء‌راحتتر‌است‪ .‬در ادامه خواهید دید که هر یک از اشایاء باهطاور مساتقل نگاه‪-‬‬
‫داری میشوند‪ .‬لذا‪ ،‬تغییرپذیری‪ ،‬توسعه و نگهداری آنها آسانتر خواهد شد‪.‬‬
‫همانطور که بیان گردید‪ ،‬کالسها برای مدلسازی اشیای دنیای واقعای باه کاار مایروناد‪ .‬اشایای‬
‫دنیای واقعی یکسری ویژگیهایی از قبیل رنگ‪ ،‬وزن‪ ،‬اندازه‪ ،‬نام‪ ،‬جنس و غیره دارند که‌شه ل‌‌ظهاهری‌‬

‫آنها را تعیین میکنند‪ .‬این ویژگیها صفات‌اشیاء نام دارند‪ .‬صافات اشایاء هماان اعضاای دادهای آنهاا‬
‫میباشند‪ .‬اشیاء عالوه بر صفات‪ ،‬یکسری رفتارها نیز از خودشان نشان میدهند‪ .‬این رفتارهاا‪ ،‬تهابع‌‌عضهو‌‌‬
‫(متد) نام دارند‪ .‬متدها‪ ،‬عملیاتی هستند که بر روی اعضای دادهای قابلاجرا هستند‪.‬‬
‫برای درک بهتر این موضوعات به طرز کار کالسهاا مایپاردازیم‪ .‬در حالات عاادی هار شایء در‬
‫دنیای واقعی به سه جنبه زیر شناخته میشود‪:‬‬
‫‪ .9‬رفتار شیء‬ ‫‪ .0‬وضعیت شیء‬ ‫‪ .6‬نام شیء‬
‫بهعنوانمثال‪ ،‬شیء پخاشکنناده ‪ CD‬را در نظار بگیریاد‪ .‬ناام ایان شایء پخاشکنناده ‪ CD‬اسات‪.‬‬
‫پخشکننده ‪ CD‬میتواند ‪ CD‬را پخش کند‪ ،‬بین آهنگها سوئیچ کند و اعماالی دیگاری انجاام دهاد‪.‬‬
‫اینها رفتارهای یک پخشکننده ‪ CD‬هستند‪ .‬منظور از وضعیت این شیء ایان اسات کاه پخاشکنناده‬
‫میزان بلندی صدا را کنترل میکند یا میداند که اکنون چه مقدار از ادامه آهنگ باقیمانده است‪.‬‬
‫سان‌میباشهند‌‪ .‬باهعناوانمثاال‪ ،‬کاالس ماشاین‬ ‫کالس ها‪‌،‬الگوهایی‌برای‌اشیاء‌با‌صفات‌مشترک‌و‌رفتارهای‌ی‬

‫خواصی مانند رنگ‪ ،‬وزن‪ ،‬تعداد‌درها‪‌،‬تعداد‌چرخها و غیره دارد که شکل ظاهری ماشین را تعیین میکنند‪.‬‬
‫روشن‌شدن‪‌،‬خاموش‌شدن‪‌،‬سهرعت‌گهرفتن‌و‌ترمه‌ک‌کهردن‌‬ ‫ماشینها عالوه بر صفات یکسری متدهای از قبیل‬
‫دارند‪ .‬بنابراین‪ ،‬برای استفاده از ماشین باید از متدهایش استفاده نمود‪ .‬برای استفاده از کالسهاا دو کاار‬
‫باید انجام گردد که عبارتاند از‪:‬‬
‫‪ .8‬نمونهسازی‌از‌کالسها‬ ‫‪ .1‬تعریف‌کالسها‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪011‬‬

‫‪ .7 – 1 – 1‬تعریف کالسها‬
‫بیان گردید که کالسها برای مدلسازی اشیاء به کاار مایروناد‪ .‬بارای تعریاف کاالس ابتادا بایاد‬
‫اعضای دادهای آن را مشخص کرد‪ .‬سپس اعضای تابعی آن را پیادهسازی نماود‪ .‬ناام کاالس‪ ،‬از قاانون‬
‫نامگذاری شناسهها پیروی میکند و اعضای تشکیلدهنده کالس‪ ،‬متغیرها و متدهایی هستند که کالس‬
‫از آنها تشکیل میشود‪ .‬اعضای تشکیلدهنده کالس عبارتاند از‪:‬‬
‫‪ .۳‬متدها‬ ‫‪ . 9‬مخربها‬ ‫‪ .0‬سازندهها‬ ‫‪ .6‬فیلدها‬
‫بهعنوانمثال‪ ،‬دستورات زیر را ببینید‪:‬‬
‫‪>>> class Circle:‬‬
‫‪PI = 3.1415‬‬
‫این دستور کالس ‪ Circle‬با یک عضو به نام ‪ PI‬ایجاد میکند‪.‬‬
‫در ادامه در مورد هر یک از اعضای کالس بهطور مفصل بحث خواهیم کرد‪.‬‬

‫‪ .7 – 1 – 2‬نمونهسازی کالسها‬
‫همانطور که در فصل اول دیدید‪ ،‬برای استفاده از انواعی نظیر ‪ char ،double ،int‬و ‪ ...‬میبایسات‬
‫نمونهای از این انواع تعریف میگردید‪ .‬برای استفاده از کالس باید نمونهای (شیایی) از کاالس ایجااد‬
‫کنید‪ .‬برای این منظور‪ ،‬بهصورت زیر عمل میشود‪:‬‬
‫()‌نام‌کالس‌‌ =‌ نام‌نمونه‌‌‌‌‌‌‌‌‌‌‌‬

‫نام‌نمونه‪ ،‬از قانون نامگذاری متغیرها پیروی میکند‪.‬‬

‫دسترسی به اعضای کالس به صورتهای زیر میباشد‪:‬‬
‫نام‌عضو‌‪‌.‬نام‌نمونه ‪1.‬‬
‫نام‌عضو‌‪‌.‬نام‌کالس ‪2.‬‬

‫ساختار اول‪ ،‬برای دسترسی به اعضای معمولی کالس به کار میرود و ساختار دوم‪ ،‬برای دسترسای‬
‫به اعضای نوع ‪ static‬کالس استفاده میشود که در ادامه خواهید دید‪.‬‬
‫اکنون دستورات زیر را ببینید‪:‬‬
‫)(‪>>> c1 = Circle‬‬

‫‪@PythonForever‬‬
 ‫‪ 011‬فصل اول‬

‫این دستور نمونهای به نام ‪ c1‬از نوع ‪ Circle‬ایجاد میکند‪ .‬اکنون ‪ c1.‬را تایپ کرده و کلید ‪ctrl +‬‬

‫‪ space‬را فشار دهید تا شکل زیر ظاهر شود‪:‬‬

‫همانطور که در این شکل میبینید‪ ،‬این کالس فقط یک عضو ‪ PI‬دارد‪.‬‬

‫‪ .7 – 2‬اعضای کالس‬
‫همانطور که دیدید‪ ،‬برای استفاده از کالس باید اعضای آن را پیادهسازی کرد‪ .‬قبل از پیاادهساازی‬
‫اعضای کالس باید آنها را شناخت‪ .‬یعنی‪ ،‬اینکه تعیین نمود کاه کاالس از چاه اعضاای تشاکیلشاده‬
‫است‪ .‬برای این منظور میتوان از واله ‪( HAS A‬دارد‌یک) استفاده نمود‪ .‬بهعنوانمثال‪ ،‬کاالس دایاره را‬
‫در نظر بگیرید‪:‬‬
‫‪ .6‬کالس دایره یک شعاع دارد‪.‬‬

‫‪ .0‬کالس دایره یک عدد ثابت دارد‪.‬‬

‫‪ .9‬کالس دایره یک قطر دارد‪.‬‬
‫‪ .۳‬کالس دایره یک محیط دارد‪.‬‬
‫‪ .0‬کالس دایره یک مساحت دارد‪.‬‬
‫اما‪ ،‬کالس استاد را در نظر بگیرید‪.‬‬
‫‪ .6‬کالس استاد‪ ،‬یک شماره استادی دارد‪.‬‬
‫‪ .0‬کالس استاد‪ ،‬یک نام دارد‪.‬‬
‫‪ .9‬کالس استاد‪ ،‬یک نام خانوادگی دارد‪.‬‬
‫‪ .۳‬کالس استاد‪ ،‬ساعت حقالتدریس دارد‪.‬‬
‫‪ .0‬کالس استاد‪ ،‬یک مبلغ به ازای هر ساعت حقالتدریس دارد‪.‬‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪011‬‬

‫‪ .1‬کالس استاد‪ ،‬مبلغ دریافتی حقالتدریس دارد‪.‬‬

‫و کالس‌استاد دیدهاید‪ ،‬مقدار ثابت ‪ ،‬شعاع دایره‪ ،‬قطر دایره‪،‬‬ ‫همانطور که در مثالهای کالس‌دایر‬

‫محیط و مساحت دایره اعضای کالس دایره هستند‪ .‬اما‪ ،‬کد استادی‪ ،‬نام‪ ،‬نام خاانوادگی‪ ،‬تعاداد سااعت‬
‫حقالتدریس‪ ،‬مبلغ حقالتدریس به ازای هر ساعت و مبلغ دریافتی حقالتدریس‪ ،‬اعضاای کاالس اساتاد‬
‫هستند‪ .‬پا‌برای‌تعیین‌اعضای‌کالس‌باید‌ببینیم‌که‌یک‌کالس‌چه‌اطالعاتی‌دارد‪.‬‬

‫‪ .7 – 2-0‬دسترسی به اعضای کالس‬

‫قبل از اینکه به تعریف اعضای کالس بپردازیم‪ ،‬ابتدا به چگونگی دسترسی اعضای کاالس مای‪-‬‬
‫پردازیم‪ .‬به دو روش میتوان به اعضای کالس دسترسی داشت‪:‬‬
‫‪ .6‬دسترسی‌به‌اعضای‌کالس‌از‌درون‌کالس‪ :‬در حالت معمولی در درون کالس میتوان از طریاق عباارت‬
‫زیر به اعضای کالس دسترسی یافت‪‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌‌:‬نام‌عضو ‪self.‬‬

‫‪ .0‬دسترسی‌به‌اعضای‌کالس‌در‌بیرون‌کالس‪ :‬برای دسترسی باه اعضاای عماومی کاالس دو روش وجاود‬

‫دارد که عبارتاند از‪:‬‬
‫دسترسی‌عضو‌از‌طریق‌نام‌کالس‪ ،‬نام کالس برای دسترسی به اعضای ‪ static‬کاالس باه کاار مایرود‪.‬‬
‫بهعنوانمثال‪ ،‬دستور زیر به عضو ‪( Sqrt‬عضو ‪ )static‬کالس ‪ Math‬به کار میرود‪:‬‬
‫;)‪Math.Sqrt (1.5‬‬
‫دسترسی‌از‌طریق‌نام‌نمونه‪ ،‬برای دسترسی به اعضای غیر ‪ static‬کالس باید از آن نموناهساازی کارد‪.‬‬
‫سپس از طریق نمونه ایجادشده به اعضای آن دسترسی نمود‪ .‬قبالً نمونه ‪ c1‬از کالس ‪ Circle‬را دیدید‪.‬‬
‫‪ .7 – 2-2‬انواع اعضای کالس‬
‫کالس معموالً از دو نوع عضو تشکیل میشود که عبارت انداز‪:‬‬
‫ای‪ ،‬اعضایی هستند که مقادیر موردنیااز کاالس را نگاهداری مایکنناد‪ .‬باهعناوانمثاال‪،‬‬ ‫اعضای‌داد‬

‫کالس دایره دارای دو عضو دادهای است‪ .‬عضو دادهای اول ‪ PI‬است کاه عادد ‪ 3.14159‬مایباشاد و‬
‫عضو دادهای دوم شعاع (‪ )r‬است که شعاع دایره در آن قرار میگیرد‪.‬‬

‫‪@PythonForever‬‬
 ‫‪ 001‬فصل اول‬

‫اعضای‌متدی‪ ،‬اعمالی را تعیین میکنند که کالس میخواهد انجام دهاد‪ .‬اعضاای متادی مایتوانناد‬
‫سازندهها‪ ،‬مخربها و متدهای کالس باشند‪ .‬بهعنوانمثال‪ ،‬دایره دارای متدهایی جهت محاسابه محایط‬
‫و مساحت میباشد‪ .‬بنابراین کالس میتواند اعضای زیر را داشته باشد‪:‬‬
‫‪ .0‬و غیره‬ ‫‪ .۳‬متدها‬ ‫‪ .9‬مخربها‬ ‫‪ .0‬سازندهها‬ ‫‪ .6‬فیلدها‬
‫فیلدها‌‬
‫فیلدها‪ ،‬اعضایی از کالس هستند که مقدار دادهای کالس را نگهداری میکنند (مانند شعاع دایاره)‪.‬‬
‫اعضای فیلد کالس‪ ،‬همان متغیرهای کالس هستند‪.‬‬
‫بهعنوانمثال‪ ،‬دستورات زیر را ببینید‪:‬‬
‫‪>>> import math‬‬
‫‪>>> class Circle:‬‬
‫‪PI = math.pi‬‬
‫‪r=0‬‬
‫دستور اول‪ ،‬مالول ‪ math‬را به برنامه اضافه میکند و دستور دوم‪ ،‬کالسی به نام ‪ Circle‬ایجاد‬

‫و ‪ ،r‬شعاع دایره میباشد‪.‬‬ ‫می‪-‬نماید که دو عضو دادهای ‪ PI‬و ‪ r‬دارد‪ ،PI .‬عدد ثابت‬
‫متدها‌‬
‫همانطور که بیان گردید‪ ،‬کالس عالوه بر اعضای دادهای مایتواناد دارای متاد نیاز باشاد‪ .‬متادها‪،‬‬
‫اعمالی هستند که میخواهید بر رویداده انجام دهید‪ .‬متد بهصورت زیر تعریف میشود (به فصل ساوم‬
‫مراجعه کنید)‪:‬‬
‫‪(:‬لیست‌پارامترها‌و‌‪‌)self‬نام‌متد‌‌‌‌‌‪def‬‬
‫‌‌‌‌ دستورات‌پیاد سازی‌متد‌‌‌‬
‫]مقدار[ ‪return‬‬

‫بهعنوانمثال‪ ،‬دستورات زیر را ببینید‪:‬‬

‫‪class Circle:‬‬
‫‪PI = math.pi‬‬
‫‪r=0‬‬
‫‪def Area(self) :‬‬
‫)‪return (self.PI* self.r ** 2‬‬
‫‪def Perime(self):‬‬
‫‪return 2 * self.PI * self.r‬‬
‫‪def __str__(self):‬‬
‫)‪s = "R : "+ str(self.r‬‬

‫‪@PythonForever‬‬
‫آشنایی با زبان پایتون ‪000‬‬

‫))(‪s += "\t\tArea : " + str(self.Area‬‬

‫))(‪s += "\t\tPerime : "+str(self.Perime‬‬
‫‪return s‬‬
‫این دستورات‪ ،‬کالسی به نام ‪ Circle‬با دو عضو دادهای ‪( PI‬عدد ثابت )‪( r ،‬شاعاع دایاره) و ساه‬
‫متد زیر را تعریف میکنند‪:‬‬
‫متد‌)(‪ ،Area‬این متد مساحت دایره را محاسبه میکند‪ .‬همانطور که در این متد مشاهده میگردد‪،‬‬
‫یک پارامتر ‪ self‬دارد و برای دسترسی به اعضاء کاالس در متاد ‪ Area‬از ناام عضاو‪ self.‬اساتفادهشاده‬
‫است‪.‬‬
‫متد‌)(‪ ،Perime‬برای محاسبه محیط دایره به کار میرود‪.‬‬
‫متد‌)(__‪ ،__str‬متد )(‪ str‬را برای این کالس پیادهسازی میکند‪ .‬این متد شعاع‪ ،‬مسااحت و محایط‬
‫را با پیغام مناسب برمیگرداند‪.‬‬
‫مثال‌‪‌.8‌–‌1‬برنامهای‌که‌کالس‌‌دایر ‌را‌پیاد ‌سازی‌کرد ‪‌،‬نمونهای‌از‌آن‌ساخته‌و‌استفاد ‌مینماید‌(هد ‌برنامه‌‬
‫نمونهسازی‌آن‌میباشد)‪‌:‬‬
‫‌‬ ‫آشنایی‌با‌ایجاد‌کالس‌و‌‬
‫مراحل‌طراحی‌و‌اجرا‌‬

‫‪ .6‬مالول جدیدی را ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫‪import math‬‬
‫‪class Circle:‬‬
‫‪PI = math.pi‬‬
‫‪r=0‬‬
‫‪def Area(self) :‬‬
‫)‪return (self.PI* self.r ** 2‬‬
‫‪def Perime(self):‬‬
‫)‪return (2 * self.PI * self.r‬‬
‫‪def __str__(self):‬‬
‫)‪s = "R : "+ str(self.r‬‬
‫))(‪s += "\t\tArea : " + str(self.Area‬‬
‫))(‪s += "\t\tPerime : "+str(self.Perime‬‬
‫‪return s‬‬
‫)(‪c = Circle‬‬
‫))"‪c.r = int(input("Enter r:‬‬
‫))‪print(str(c‬‬
‫‪ .0‬مالول را ذخیره و اجرا کرده‪ ،‬جلوی ‪ R:‬عدد ‪ 62‬را وارد کنید تا خروجی زیر را ببینید‪:‬‬

‫‪@PythonForever‬‬
 ‫‪ 001‬فصل اول‬

‫‪Enter r:10‬‬
‫‪R : 10‬‬ ‫‪Area : 314.1592653589793‬‬ ‫‪Perime : 62.83185307179586‬‬

‫‪ .7 – 3‬سازندهها و مخربها‬
‫سازندهها برای مقداردهی اولیه به اعضای کاالس باه کاار مایروناد‪ .‬باا دو روش زیار مایتاوان باه‬
‫اعضای کالس مقدار اولیه تخصیص داد‪:‬‬
‫ای‌کالس‌در‌بدنه‌آن‪ ،‬در هنگام تعریف کالس در بدناه کاالس مایتاوان باه‬ ‫‪ .0‬مقداردهی‌به‌اعضای‌داد‬

‫اعضای دادهای آن مقدار اولیه داد‪ .‬این عمل بهصورت زیر انجام میشود‪:‬‬
‫مقدار‌اولیه‌=‌نام‌عضو‌داد ای‌‌‌‌‌‌‬

‫بهعنوانمثال‪ ،‬در کالس ‪ Circle‬به ‪ PI‬مقدار اولیه ‪ math.pi‬تخصیص داده شاد و باه ‪ r‬مقادار اولیاه‬
‫صفر تخصیص داده شد‪.‬‬
‫‪‌،‬در پایتون هار کاالس یاک متاد ساازنده باه ناام‬ ‫‪‌ .2‬مقداردهی‌اولیه‌به‌اعضای‌کالس‌از‌طریق‌متد‌سازند‬

‫)( __‪ __init‬دارد کاه بارای مقاداردهی اولیاه باه اعضاای دادهای کاالس باه کاار مایرود‪ .‬ایان متاد‬
‫بهصورت زیر پیادهسازی میشود‪:‬‬
‫‪):‬لیست‌پارامترها ‪def __init__ (self,‬‬
‫دستورات‌بدنه‌متد‬

‫‪def __init__(self, r):‬‬

‫‪self.r = r‬‬
‫بهعنوانمثال‪ ،‬دستورات زیر را ببینید‪:‬‬
‫این دستور سازنده کالس ‪ Circle‬را ایجاد میکند‬

‫‪ .7 – 11‬مسائل حل شده‬
‫مثال‌‪‌.1‬برنامهای‌که‌کالس‌‌دانشجو‌را‌پیاد ‌سازی‌میکند‪‌.‬هر‌دانشجو‌دارای‌اعضای‌کد‌(شمار ‌دانشجویی)‪‌،‬نهام‪‌،‬‬
‫نام‌خانوادگی‪‌،‬معدل‌و‌آیا‌مشروط‌شد ‌است‌یا‌خیر؟‌میباشد‪.‬‬
‫مراحل‌طراحی‌و‌اجرا‪‌:‬‬

‫‪ .6‬مالول جدیدی را ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫هد ‌‬ ‫متغیر‌‬ ‫ماژول‌‬
‫شماره دانشجویی‬ ‫‪code‬‬ ‫مالول‬

‫‪@PythonForever‬‬
001 ‫آشنایی با زبان پایتون‬

‫نام دانشجو‬ fnam ‫اصلی‬

e
‫نام خانوادگی دانشجو‬ lname

‫معدل‬ avera
ge
Student ‫نمونهای از کالس‬ s

.‫‫را پیادهسازی میکند‬Student ‫متدی که مخرب کالس‬ __del ‫کالس‫‬

__
Student
‫ به رشته‬Str ‫‫را با متد‬Student ‫متدی که سازنده نمونهای از کالس‬ __str
__
.‫تبدیل میکند‬
.‫ را پیادهسازی میکند‬Student ‫متدی که سازنده کالس‬ __ini
t__
‫متدی که تعیین میکند که آیا دانشجو مشروط شده است یا خیر؟‬ isPass

class Student:
def __init__(self, code, fname, lname, average):
self.code = code
self.fname = fname
self.lname = lname
self.average= average
def __del__(self):
print("object is deleted")
def isPass(self):
if self.average >= 12 :
return "Yes"
else :
return "No"
def __str__(self):
s = "Code : "+ self.code
s += "\t\tFirst name : " + self.fname
s += "\t\tLast name : " + self.lname
s += "\nAverage : "+str(self.average)
s += "\t\tPassed : "+str(self.isPass())
return s
code = input("Enter code:")
fname = input("Enter First name:")
lname = input("Enter Last name:")
average = float(input("Enter average:"))
s = Student(code, fname, lname, average)
print(str(s))

@PythonForever
 ‫ فصل اول‬001

del s
:‫ اطالعات زیر وارد را نمایید تا خروجی را ببینید‬،‫ مالول را ذخیره و اجرا کرده‬.0
Enter code:931216049
Enter First name:Ramin
Enter Last name:Baboli
Enter average:12.75
Code : 931216049 First name : Ramin Last name : Baboli
Average : 12.75 Passed : Yes object is deleted

@PythonForever
 ‫آشنایی با زبان پایتون ‪001‬‬

‫مسائل تکمیلی‬ ‫پیوست‬

‫ای‌که‌تاریخ‌و‌زمان‌فعلی‌را‌نمایش‌میدهد‪.‬‬
‫‌‬ ‫‌‬
‫برنامه‬ ‫‪.1‬‬
‫مراحل‌طراحی‌و‌اجرا‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫‫‬ ‫‪import datetime‬‬
‫)(‪now = datetime.datetime.now‬‬
‫))"‪print ("Current date and time : ", now.strftime("%Y-%m-%d %H:%M:%S‬‬
‫‪ .0‬مالول را ذخیره و اجرا کرده تا نمونه خروجی را بهصورت زیر ببینید‪:‬‬
‫‪‌Current date and time : 2017-06-10 20:22:32‬‬
‫فایل‌را‌نمایش‌میدهد‪.‬‬
‫‌‬ ‫برنامهای‌که‌نام‌فایلی‌را‌از‌کاربر‌خواند ‪‌،‬توسعه(پسوند)‌‬
‫‌‬ ‫‪.8‬‬
‫مراحل‌طراحی‌و‌اجرا‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫‫‬ ‫)" ‪filename = input("Input the Filename:‬‬
‫)"‪f_extns = filename.split(".‬‬
‫))]‪print ("The extension of the file is : " + repr(f_extns[-1‬‬
‫‪ .0‬مالول را ذخیره و اجرا کرده تا نمونه خروجی را بهصورت زیر ببینید‪:‬‬
‫‪Input the Filename: D:\\1.zip‬‬
‫'‪The extension of the file is : 'zip‬‬
‫را‌نمایش‌میدهد‪.‬‬
‫‌‬ ‫برنامهای‌که‌عدد‌صحیح‌‪‌n‬را‌خواند ‪‌،‬حاصل‌عبارت‌‪‌n+nn+nnn‬‬
‫‌‬ ‫‪.4‬‬
‫مراحل‌طراحی‌و‌اجرا‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫‫‬ ‫))" ‪a = int(input("Input an integer :‬‬
‫) ‪n1 = int( "%s" % a‬‬
‫) )‪n2 = int( "%s%s" % (a,a‬‬
‫) )‪n3 = int( "%s%s%s" % (a,a,a‬‬
‫)‪print (n1, " + ", n2," +", n3, " = ", n1+ n2 +n3‬‬
‫‪ .0‬مالول را ذخیره و اجرا کرده تا نمونه خروجی را بهصورت زیر ببینید‪:‬‬
‫‪Input an integer : 8‬‬
‫‪8 + 88 + 888 = 984.‬‬
‫را‌نشان‌میدهد‪.‬‬
‫‌‬ ‫برنامهای‌که‌سال‌و‌ما ‌را‌خواند ‪‌،‬تقویم‌‬
‫‌‬ ‫‪.3‬‬
‫مراحل‌طراحی‌و‌اجرا‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫‪@PythonForever‬‬
 ‫‪ 001‬فصل اول‬

‫‫‬ ‫‪import calendar‬‬

‫))" ‪y = int(input("Input the year :‬‬
‫))" ‪m = int(input("Input the month :‬‬
‫))‪print(calendar.month(y, m‬‬
‫‪ .0‬مالول را ذخیره و اجرا کرده تا نمونه خروجی را بهصورت زیر ببینید‪:‬‬
‫‪Input the year : 2017‬‬
‫‪Input the month : 8‬‬
‫‪August 2017‬‬
‫‪Mo Tu We Th Fr Sa Su‬‬
‫‪1 2 3 4 5 6‬‬
‫‪7 8 9 10 11 12 13‬‬
‫‪14 15 16 17 18 19 20‬‬
‫‪21 22 23 24 25 26 27‬‬
‫‪28 29 30 31‬‬
‫برنامهای‌که‌اختال ‌بین‌دو‌تاریخ‌را‌محاسبه‌کرد ‪‌،‬نمایش‌می‌دهد‪.‬‬
‫‌‬ ‫‪.6‬‬
‫مراحل‌طراحی‌و‌اجرا‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫‫‬ ‫‪from datetime import date‬‬
‫)‪f_date = date(2014, 7, 2‬‬
‫)‪l_date = date(2014, 7, 11‬‬
‫‪delta = l_date - f_date‬‬
‫)‪print('Day is ', delta.days‬‬
‫‪ .0‬مالول را ذخیره و اجرا کرده تا نمونه خروجی را بهصورت زیر ببینید‪:‬‬
‫‪Day is 9‬‬
‫برنامهای‌که‌یک‌لیست‌را‌دریافت‌کرد ‪‌،‬با‌ستار ‌و‌مقادیر‌لیست‌هیستوگرام‌را‌رسم‌می‌کند‪.‬‬
‫‌‬ ‫‪.7‬‬
‫مراحل‌طراحی‌و‌اجرا‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫‫‬ ‫‪def histogram( items ):‬‬
‫‪for n in items:‬‬
‫'' = ‪output‬‬
‫‪times = n‬‬
‫‪while( times > 0 ):‬‬
‫'*' =‪output +‬‬
‫‪times = times - 1‬‬
‫)‪print(output‬‬

‫)]‪histogram([3, 6, 4, 3, 6, 5‬‬
‫‪ .0‬مالول را ذخیره و اجرا کرده تا نمونه خروجی را بهصورت زیر ببینید‪:‬‬

‫‪@PythonForever‬‬
 ‫آشنایی با زبان پایتون ‪001‬‬

‫***‬
‫******‬
‫****‬
‫***‬
‫******‬
‫*****‬
‫را‌نمایش‌میدهد‪.‬‬
‫‌‬ ‫ترین‌مقسومعلیه‌مشترک‌(‪‌)GCO‬آنها‌‬
‫‌‬ ‫برنامهای‌که‌دو‌عدد‌را‌خواند ‪‌،‬بکرگ‌‬
‫‌‬ ‫‪.8‬‬
‫مراحل‌طراحی‌و‌اجرا‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫‫‬ ‫‪def gcd(x, y):‬‬
‫‪gcd = 1‬‬
‫‪if x % y == 0:‬‬
‫‪return y‬‬
‫‪for k in range(int(y / 2), 0, -1):‬‬
‫‪if x % k == 0 and y % k == 0:‬‬
‫‪gcd = k‬‬
‫‪break‬‬
‫‪return gcd‬‬
‫))"‪x = int(input("Enter x:‬‬
‫))"‪y = int(input("Enter y:‬‬
‫))‪print("gcd is ", gcd(x, y‬‬
‫‪ .0‬مالول را ذخیره و اجرا کرده تا نمونه خروجی را بهصورت زیر ببینید‪:‬‬
‫‪Enter x:12‬‬
‫‪Enter y:20‬‬
‫‪gcd is 4‬‬
‫را‌نمایش‌میدهد‪.‬‬
‫‌‬ ‫برنامهای‌که‌دو‌عدد‌را‌خواند ‪‌،‬کوچک‌ترین‌مضر ‌مشترک‌آن‌ها‌(‪‌)LCM‬‬
‫‌‬ ‫‪.7‬‬
‫مراحل‌طراحی‌و‌اجرا‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫‫‬ ‫‪def lcm(x, y):‬‬
‫‪if x > y:‬‬
‫‪z=x‬‬
‫‪else:‬‬
‫‪z=y‬‬
‫‪while(True):‬‬
‫‪if((z % x == 0) and (z % y == 0)):‬‬
‫‪lcm = z‬‬
‫‪break‬‬
‫‪z += 1‬‬
‫‪return lcm‬‬

‫))"‪x = int(input("Enter x:‬‬

‫‪@PythonForever‬‬
 ‫‪ 001‬فصل اول‬

‫))"‪y = int(input("Enter y:‬‬

‫))‪print("lcm is ", lcm(x, y‬‬
‫‪ .0‬مالول را ذخیره و اجرا کرده تا نمونه خروجی را بهصورت زیر ببینید‪:‬‬
‫‪Enter x:8‬‬
‫‪Enter y:12‬‬
‫‪lcm is 24‬‬
‫‪ .9‬برنامه‌ ای‌که‌مبلغ‌فعلی‪‌،‬نرخ‌بهر ‌و‌تعداد‌سال‌را‌خواند ‌و‌ارزش‌پول‌را‌برای‌چند‌سال‌آیند ‌کهه‌از‌‬
‫محاسبه‌میکند‪.‬‬
‫‌‬ ‫ورودی‌خواند ‪‌،‬‬
‫مراحل‌طراحی‌و‌اجرا‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫‫‬ ‫))"‪amt = int(input("Enter amount:‬‬
‫))"‪rate = float(input("Enter rate:‬‬
‫))"‪years = int(input("Enter years:‬‬
‫)‪future_value = amt*((1+(0.01*rate)) ** years‬‬
‫))‪print("Future_value is %12.0f" %(future_value‬‬
‫‪ .0‬مالول را ذخیره و اجرا کرده تا نمونه خروجی را بهصورت زیر ببینید‪:‬‬
‫‪Enter amount:1000000‬‬
‫‪Enter rate:7.5‬‬
‫‪Enter years:10‬‬
‫‪Future_value is‬‬ ‫‪2061032‬‬
‫ای‌که‌چک‌میکند‌آیا‌فایلی‌وجود‌دارد‌یا‌خیر؟‬
‫‌‬ ‫‌‬
‫برنامه‬ ‫‪.10‬‬
‫مراحل‌طراحی‌و‌اجرا‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫‫‬ ‫‪import os.path‬‬
‫)"‪fileName = input("Enter filename:‬‬
‫)'‪open(fileName, 'w‬‬
‫))‪print(os.path.isfile(fileName‬‬
‫‪ .0‬مالول را ذخیره و اجرا کرده تا نمونه خروجی را بهصورت زیر ببینید‪:‬‬
‫‪Enter filename:1.txt‬‬
‫‪True‬‬
‫تعیین‌میکند‌آیا‌پوسته‌اجرا‌‪‌48‬یا‌‪‌73‬بیتی‌است؟‬
‫‌‬ ‫برنامهای‌که‌‬
‫‌‬ ‫‪.11‬‬
‫مراحل‌طراحی‌و‌اجرا‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫‫‬ ‫‪import struct‬‬
‫)‪print(struct.calcsize("P") * 8‬‬

‫‪@PythonForever‬‬
 ‫آشنایی با زبان پایتون ‪001‬‬

‫‪ .0‬مالول را ذخیره و اجرا کرده تا نمونه خروجی را بهصورت زیر ببینید‪:‬‬

‫‪64‬‬
‫را‌نمایش‌میدهد‪.‬‬
‫‌‬ ‫ای‌که‌نام‌سیستمعامل‪‌،‬اطالعات‌پلت‌فرم‌‪‌release‬‬
‫‌‬ ‫‌‬
‫برنامه‬ ‫‪.18‬‬
‫مراحل‌طراحی‌و‌اجرا‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫‫‬ ‫‪import platform‬‬
‫‪import os‬‬
‫)‪print("Name is ", os.name‬‬
‫))(‪print("Platform system is ", platform.system‬‬
‫))(‪print("Platform release is ", platform.release‬‬
‫‪ .0‬مالول را ذخیره و اجرا کرده تا نمونه خروجی را بهصورت زیر ببینید‪:‬‬
‫‪Name is nt‬‬
‫‪Platform system is Windows‬‬
‫‪Platform release is 7‬‬
‫های‌پایتون‌را‌نمایش‌میدهد‪.‬‬
‫‌‬ ‫‌‬
‫ای‌که‌نام‌سایت‌بسته‬ ‫‌‬
‫برنامه‬ ‫‪.14‬‬
‫مراحل‌طراحی‌و‌اجرا‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫‫‬ ‫;‪import site‬‬
‫))(‪print("Site package is ", site.getsitepackages‬‬
‫‪ .0‬مالول را ذخیره و اجرا کرده تا نمونه خروجی را بهصورت زیر ببینید‪:‬‬
‫‪Site package is ['C:\\Users\\Fansno\\AppData\\Local\\Programs\\Python\\Python35',‬‬
‫]'‪'C:\\Users\\Fansno\\AppData\\Local\\Programs\\Python\\Python35\\lib\\site-packages‬‬
‫اجرایی‌خارجی‌را‌در‌پایتون‌اجرا‌میکند‪.‬‬
‫‌‬ ‫ای‌که‌یک‌برنامه‌‬
‫‌‬ ‫‌‬
‫برنامه‬ ‫‪.13‬‬
‫مراحل‌طراحی‌و‌اجرا‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫‫‬ ‫‪from subprocess import call‬‬
‫)]"‪call(["calc.exe‬‬
‫‪ .0‬مالول را ذخیره و اجرا کرده تا نمونه خروجی را ببینید‪.‬‬
‫ای‌که‌نام‌و‌مسیر‌فایل‌فعلی‌در‌حال‌اجرا‌را‌نمایش‌میدهد‪.‬‬
‫‌‬ ‫‌‬
‫برنامه‬ ‫‪.16‬‬
‫مراحل‌طراحی‌و‌اجرا‪‌:‬‬

‫‪ .6‬مالول جدیدی ایجاد کرده‪ ،‬دستورات آن را بهصورت زیر تایپ کنید‪:‬‬

‫‫‬ ‫‪import os‬‬
‫))__‪print("Current File Name : ",os.path.realpath(__file‬‬

‫‪@PythonForever‬‬
 ‫ فصل اول‬011

:‫ مالول را ذخیره و اجرا کرده تا نمونه خروجی را بهصورت زیر ببینید‬.0

Current File Name : D:\BookCSharp\phyton-book\program\site\py\15.py
.‫های‌رایانه‌را‌نمایش‌میدهد‬
‌ ‌ ‫برنامهای‌که‌تعداد‌پردازند‬
‌ .17
‌:‫مراحل‌طراحی‌و‌اجرا‬

:‫ دستورات آن را بهصورت زیر تایپ کنید‬،‫ مالول جدیدی ایجاد کرده‬.6

import multiprocessing
print("Count cpu is ", multiprocessing.cpucount())
:‫ مالول را ذخیره و اجرا کرده تا نمونه خروجی را بهصورت زیر ببینید‬.0
Count cpu is 2
.‫یابی‌پیدا‌میکند‬
‌ ‌
‫ای‌که‌به‌متغیرهای‌محیطی‌دست‬ ‌
‫برنامه‬ .18
‌:‫مراحل‌طراحی‌و‌اجرا‬

:‫ دستورات آن را بهصورت زیر تایپ کنید‬،‫ مالول جدیدی ایجاد کرده‬.6

import os
# Access all environment variables
print('*----------------------------------*')
print("Environment is ", os.environ)
print('*----------------------------------*')
# Access a particular environment variable
print("home is ", os.environ['HOME'])
print('*----------------------------------*')
print("Path is ", os.environ['PATH'])
print('*----------------------------------*')
:‫ مالول را ذخیره و اجرا کرده تا نمونه خروجی را بهصورت زیر ببینید‬.0
*----------------------------------*
Environment is environ({'COMSPEC': 'C:\\Windows\\system32\\cmd.exe',
'PROCESSOR_ARCHITECTURE': 'AMD64', 'LOGONSERVER': '\\\\FANSNO-PC',
'HOME': 'C:\\Users\\Fansno', 'LOCALAPPDATA':
'C:\\Users\\Fansno\\AppData\\Local', 'PROGRAMDATA': 'C:\\ProgramData',
'PROGRAMFILES': 'C:\\Program Files', 'OS': 'Windows_NT', 'PROGRAMW6432':
'C:\\Program Files', 'PROCESSOR_LEVEL': '20', 'COMMONPROGRAMFILES(X86)':
'C:\\Program Files ....

‫ ﺻﻔﺤﻪ اﺳﺖ ﮐﻪ ﻓﺎﯾﻞ اﻟﮑﺘﺮوﻧﯿﮑﻰ آن را‬381 ‫ﮐﺘﺎب ﺷﺎﻣﻞ‬

. ‫ﻣﻰﺗﻮاﻧﯿﺪ از ﺳﺎﯾﺖ ﮐﺘﺎﺑﺮاه ﺗﻬﯿﻪ ﮐﻨﯿﺪ‬

http://ktbr.ir/b29984

@PythonForever
‫آشنایی با زبان پایتون ‪010‬‬

‫‪@PythonForever‬‬
 ‫ فصل اول‬011

@PythonForever
‫آشنایی با زبان پایتون ‪011‬‬

‫‪@PythonForever‬‬
 ‫ فصل اول‬011

@PythonForever
‫آشنایی با زبان پایتون ‪011‬‬

‫‪@PythonForever‬‬
 ‫ فصل اول‬011

@PythonForever