کتاب Python Crash Course به فارسی

• 1: بخش یکم - مقدمات
• 1.1: آغاز به کار
• 1.1.1: برپا کردنِ محیطِ برنامه‌نویسی
• 1.1.2: پایتون بر روی سیستم عامل های مختلف
• 1.1.3: اجرای یک برنامه‌ی Hello World
• 1.1.4: اشکال‌زدایی
• 1.1.5: اجرا کردن برنامه‌های پایتون از ترمینال
• 1.1.6: خودآزمایی
• 1.1.7: خلاصه
• 1.2: متغیّرها و انواع ساده‌ی داده‌ها
• 1.2.1: هنگام اجرای hello_world.py در واقع چه اتّفاقی می‌افتد؟
• 1.2.2: متغیّرها
• 1.2.3: رشته‌ها
• 1.2.4: عددها
• 1.2.5: توضیحات
• 1.2.6: ذنِ پایتون
• 1.2.7: خلاصه
• 1.3: معرّفی لیست‌ها
• 1.3.1: لیست چیست؟
• 1.3.2: تغییر دادن، افزودن و حذف کردن عضوها
• 1.3.3: سازماندهی یک لیست
• 1.3.4: پرهیز از خطای شاخص هنگام کار کردن با لیست‌ها
• 1.3.5: خلاصه
• 1.4: کار کردن با لیست‌ها
• 1.4.1: حلقه زدن در کل یک لیست
• 1.4.2: کارهای بیشتر در یک حلقه‌ی for
• 1.4.3: کارهای بیشتر در یک حلقه‌ی for
• 1.4.4: پرهیز از خطای تورفتگی
• 1.4.5: ساختن لیست‌های عددی
• 1.4.6: کار کردن با بخشی از یک لیست
• 1.4.7: چندتایی‌ها
• 1.4.8: شکل‌دهی کدها
• 1.4.9: خلاصه
• 1.5: گزاره‌های شرطی
• 1.5.1: یک مثال ساده
• 1.5.2: آزمون‌های شرطی
• 1.5.3: بررسی شرط‌های چندگانه
• 1.5.4: گزاره‌های if
• 1.5.5: زنجیره‌ی if-elif-else
• 1.5.6: آزمودن چند شرط
• 1.5.7: به‌کارگیری گزاره‌های if در لیست‌ها
• 1.5.8: شکل‌دهی به عبارت‌های if
• 1.5.9: خلاصه
• 1.6: دیکشنری‌ها
• 1.6.1: یک دیکشنری ساده
• 1.6.2: کار کردن با دیکشنری
• 1.6.3: یک دیکشنری شامل اشیای مشابه
• 1.6.4: حلقه زدن در یک دیکشنری
• 1.6.5: تودرتوکردن
• 1.6.6: خلاصه
• 1.7: ورودی کاربر و حلقه‌های while
• 1.7.1: تابع input() چگونه کار می‌کند؟
• 1.7.2: نوشتن اعلان‌های شفّاف
• 1.7.3: عملگر پیمانه
• 1.7.4: آشنایی با حلقه‌های while
• 1.7.5: به‌کارگیری پرچم
• 1.7.6: استفاده از break و continue
• 1.7.7: پرهیز از حلقه‌های بی‌پایان
• 1.7.8: به‌کارگیری حلقه‌ی while در لیست‌ها و دیکشنری‌ها
• 1.7.9: خلاصه
• 1.8: تابع‌ها
• 1.8.1: تعریف کردن تابع
• 1.8.2: انتقال اطّلاعات به یک تابع
• 1.8.3: انتقال نشان‌وندها
• 1.8.4: مقدارهای برگشتی
• 1.8.5: انتقال لیست
• 1.8.6: انتقال تعداد دلخواهی نشان‌وند
• 1.8.7: ذخیره کردن تابع‌ها در ماژول‌ها
• 1.8.8: شکل‌دهی به تابع‌ها
• 1.9: کلاس‌ها
• 1.9.1: ساختن و به‌کارگیری یک کلاس
• 1.9.2: کار کردن با کلاس‌ها و نمونه‌ها
• 1.9.3: ارث‌بری
• 1.9.4: وارد کردن کلاس‌ها
• 1.9.5: کتابخانه‌ی استاندارد پایتون و شکل‌دهی به کلاس‌ها
• 1.10: فایل‌ها و استثناها
• 1.10.1: خواندن یک فایل
• 1.10.2: مسیر فایل‌ها
• 1.10.3: خواندن خط به خط
• 1.10.4: کار کردن با محتویّات یک فایل
• 1.10.5: خودآزمایی
• 1.10.6: نوشتن در یک فایل
• 1.10.7: خودآزمایی
• 1.10.8: استثناها
• 1.10.9: به‌کارگیری استثناها برای پیش‌گیری از از کار افتادن برنامه
• 1.10.10: رسیدگی به استثنای FileNotFoundError
• 1.10.11: کار کردن با چند فایل
• 1.10.12: خودآزمایی
• 1.10.13: ذخیره‌سازی داده‌ها
• 1.10.14: ذخیره کردن و خواندن داده‌هایی که کاربر تولید کرده
• 1.10.15: بازآرایی
• 1.10.16: خودآزمایی
• 1.10.17: خلاصه
• 1.11: آزمودن کد
• 1.11.1: آزمودن یک تابع
• 1.11.2: یک آزمون موفّق
• 1.11.3: آزمون ناموفّق
• 1.11.4: افزودن آزمون‌های جدید
• 1.11.5: آزمودن یک کلاس
• 1.11.6: متد setUp()
• 2: بخش دوم - پروژه‌ها
• 2.1: فصل دوازدهم
• 2.1.1: مرور پروژه و ساختن اوّلین موجود بیگانه
• 2.1.2: ساختن ناوگان موجودات بیگانه
• 2.1.3: به راه انداختن ناوگان
• 2.1.4: شلّیک به موجودات بیگانه
• 2.1.5: پایان دادن به بازی
• 2.2: فصل سیزدهم
• 2.2.1: افزودن دکمه‌ی Play
• 2.2.2: رسم دکمه روی صفحه و آغاز بازی
• 2.2.3: بازنشانی بازی و مدیریت دکمه
• 2.2.4: خودآزمایی و بالا بردن سطح بازی
• 2.2.5: بازنشانی سرعت و آغاز امتیازدهی
• 2.2.6: نمایش امتیازها و ساختن تابلوی امتیازات
• 2.2.7: به‌روزرسانی و بازنشانی امتیاز
• 2.2.8: گرد کردن امتیاز و بالاترین امتیاز
• 2.2.9: نمایش مرحله و تعداد سفینه‌ها
• 2.2.10: خودآزمایی و خلاصه
• 2.3: فصل چهاردهم
• 2.3.1: مقدّمه و نصب Matplotlib
• 2.3.2: رسم یک نمودار خطّی ساده
• 2.3.3: تغییر دادن نوشته‌ی برچسب و ضخامت خط
• 2.3.4: اصلاح نمودار
• 2.3.5: به‌کارگیری شیوه‌های پیش‌ساخته
• 2.3.6: رسم و شکل‌دهی نقاط با scatter()
• 2.3.7: رنگ‌آمیزی و ذخیره‌سازی نمودارها
• 2.3.8: گردش تصادفی
• 2.3.9: انتخاب جهت و رسم گردش تصادفی
• 2.4: فصل پانزدهم
• 2.4.1: نصب Matplotlib و رسم نمودار خطّی
• 2.4.2: رسم نقاط با scatter() و ذخیره‌سازی نمودارها
• 2.4.3: گردش تصادفی
• 2.4.4: شخصی‌سازی گردش تصادفی
• 2.4.5: تاس انداختن با پلات‌لی
• 2.4.6: پرتاب تاس‌های مختلف و خلاصه
• 2.5: فصل شانزدهم
• 2.5.1: شکل فایل CSV
• 2.5.2: رسم داده‌ها در یک نمودار دما
• 2.5.3: ماژول datetime
• 2.5.4: رسم تاریخ‌ها
• 2.5.5: رسم یک دوره‌ی زمانی طولانی‌تر
• 2.5.6: رسم یک دنباله‌ی داده‌ی دیگر
• 2.5.7: سایه زدن سطحی در نمودار
• 2.5.8: بررسی خطاها
• 2.5.9: بارگذاری داده‌هایی برای خود
• 2.5.10: رسم نقشه‌ی مجموعه‌ی داده‌های جهانی: قالب JSON
• 2.5.11: ساختن لیست تمام زمین‌لرزه‌ها
• 2.5.12: ساختن یک نقشه‌ی جهان
• 2.5.13: شخصی‌سازی اندازه‌ی نشان‌گرها
• 2.5.14: دیگر مقیاس‌های رنگی
• 2.5.15: خودآزمایی
• 2.5.16: خلاصه
• 2.6: فصل هفدهم
• 2.6.1: کار کردن با APIها
• 2.6.2: استفاده از یک API تحت وب
• 2.6.3: Git و GitHub
• 2.6.4: درخواست داده با یک فراخوانی API
• 2.6.5: نصب کردن Requests
• 2.6.6: پردازش پاسخ API
• 2.6.7: کار کردن با دیکشنری پاسخ
• 2.6.8: خلاصه کردن مخزن‌های برتر
• 2.6.9: پایش محدودیت نرخ API
• 2.6.10: بصری کردن مخزن‌ها به کمک پلات‌لی
• 2.6.11: بهبود نمودارهای پلات‌لی
• 2.6.12: افزودن تول‌تیپ‌های شخصی
• 2.6.13: افزودن پیوندهای قابل کلیک به نمودار
• 2.6.14: اطّلاعات بیشتر درباره‌ی پلات‌لی و API گیت‌هاب
• 2.6.15: API اخبار هکرها
• 2.6.16: خودآزمایی
• 2.6.17: خلاصه
• 2.7: فصل هجدهم
• 2.7.1: شروع کار با جانگو
• 2.7.2: برپا کردن یک پروژه
• 2.7.3: آغاز کردن یک برنامه
• 2.7.4: سایت مدیریّت جانگو
• 2.7.5: انتقال مدل Entry
• 2.7.6: ساختن صفحه‌ها: صفحه‌ی خانه‌ی Learning Log
• 2.7.7: ساختن صفحه‌های اضافی
• 2.7.8: صفحه‌های جداگانه‌ی هر موضوع
• 2.7.9: خلاصه
• 2.8: فصل نوزدهم
• 2.8.1: فراهم آوردن امکان ورود داده برای کاربران
• 2.8.2: افزودن موضوع‌های جدید
• 2.8.3: افزودن مطالب جدید
• 2.8.4: ویرایش مطلب‌ها
• 2.8.5: خودآزمایی
• 2.8.6: برپاکردن حساب‌های کاربری
• 2.8.7: صفحه‌ی ورود
• 2.8.8: پیوند دادن به صفحه‌ی ورود
• 2.8.9: خروج
• 2.8.10: صفحه‌ی ثبت نام
• 2.8.11: خودآزمایی
• 2.8.12: فراهم آوردن امکان در اختیار گرفتن داده‌ها برای کاربران
• 2.8.13: ایجاد ارتباط بین داده‌ها و کاربران
• 2.8.14: انتقال پایگاه داده
• 2.8.15: محدود کردن موضوعات به کاربران مربوطه
• 2.8.16: محافظت از موضوع‌های یک کاربر
• 2.8.17: نسبت دادن موضوع‌های جدید به کاربر فعلی
• 2.8.18: خودآزمایی
• 2.8.19: خلاصه
• 2.9: فصل بیستم
• 2.9.1: شکل‌دهی و استقرار
• 2.9.2: شکل دادن به پروژه
• 2.9.3: تغییر دادن base.html
• 2.9.4: تعریف کردن نوار پیمایش
• 2.9.5: تعریف قسمت اصلی صفحه
• 2.9.6: شکل‌دهی به صفحه‌ی خانه به کمک جامباترون
• 2.9.7: آراستن صفحه‌ی ورود
• 2.9.8: شکل دادن به صفحه‌ی موضوعات
• 2.9.9: شکل دادن به مطالب در صفحه‌ی موضوع‌ها
• 2.9.10: استقرار پروژه
• 2.9.11: ساختن فایل‌های پیکربندی
• 2.9.12: استفاده از Git برای ردگیری فایل‌های پروژه
• 2.9.13: ارسال به هروکو و برپا کردن پایگاه داده
• 2.9.14: بهبود استقرار هروکو
• 2.9.15: امن کردن پروژه‌ی در حال کار
• 2.9.16: ساختن صفحه‌های خطای شخصی
• 2.9.17: استفاده از get_object_or_404()
• 2.9.18: توسعه‌های آینده و نکته‌های پایانی
• 2.9.19: خلاصه
• 3: موخره
• 4: پیوست‌ها

1 - بخش یکم - مقدمات

بخشِ یکمِ این کتاب مفاهیمِ پایه‌ایِ ضروری‌ای را به شما می‌آموزد که برای نوشتنِ برنامه‌های پایتون لازم دارید. بسیاری از این مفاهیم بینِ تمامِ زبان‌های برنامه‌نویسی مشترک‌اند، پس در سراسرِ زندگیِ شما در جایگاهِ یک برنامه‌نویس کارآمد خواهند بود.

در فصل ۱ پایتون را روی رایانه‌ی خود نصب می‌کنید و اولین برنامه‌یتان را می‌نویسید، که پیامِ Hello World! را روی نمایشگر ظاهر می‌کند.

در فصل ۲ خواهید آموخت که چگونه اطلاعات را در متغیرها ذخیره و با مقادیرِ عددی و متنی کار کنید.

در دو فصل ۳ و فصل ۴ لیست‌ها معرفی می‌شوند. لیست‌ها می‌توانند هر اندازه اطلاعات را که بخواهید در یک متغیر ذخیره کنند. این باعث می‌شود بتوانید با داده‌ها به طورِ مؤثرتری کار کنید. قادر خواهید شد با صدها، هزاران و حتی میلیون‌ها مقدار در تنها چند خط برنامه کار کنید.

در فصل ۵ از دستورِ if برای نوشتنِ برنامه‌هایی استفاده خواهید کرد که با برآورده شدنِ شرط‌های خاصی یک جور پاسخ می‌دهند و در صورتِ برآورده نشدن جورِ دیگر.

فصل ۶ طرزِ به‌کارگیریِ دیکشنری‌های پایتون را به شما نشان می‌دهد که برقراریِ ارتباط بینِ قطعاتِ گوناگونِ اطلاعات را ممکن می‌کند. دیکشنری‌ها، همانندِ لیست‌ها، می‌توانند هر اندازه اطلاعات که بخواهید ذخیره کنند.

در فصل ۷ دریافت کردنِ ورودی را از کاربر فرامی‌گیرید، به منظورِ تعاملی کردنِ برنامه‌های‌تان.

در فصل ۸ تابع‌ها را ایجاد خواهید کرد. توابع قطعه‌های نام‌گذاری‌شده‌ای از برنامه‌ برای انجام دادنِ وظیفه‌ای مشخص‌اند و هر جا که لازم باشد می‌توانید آن‌ها را اجرا کنید.

در فصل ۹ با کلاس‌ها آشنا می‌شوید، که ساختن مدل از اشیا و موجوداتِ جهانِ واقعی —مانندِ سگ‌ها، گربه‌ها، مردم، خودروها، موشک‌ها، و چیزهای دیگر— را ممکن می‌سازند، تا برنامه‌ی شما بتواند هر چیزِ واقعی یا انتزاعی را نمایش دهد.

فصل ۱۰ به شما می‌آموزد چگونه با فایل‌ها کار کنید و مدیریتِ خطاها را برای جلوگیری از خراب شدنِ ناگهانیِ برنامه به عهده بگیرید. داده‌ها را پیش از بستن برنامه ذخیره و پس از اجرای مجددِ آن بازیابی می‌کنید. همچنین، در موردِ استثناها در پایتون خواهید آموخت. مدیریتِ استثنا به شما امکان می‌دهد که خطاها را پیش‌بینی کنید تا برنامه‌تان بدونِ دردسرْ خطاها را مدیریت کند.

در فصل ۱۱ خواهید آموخت که برای بررسیِ این‌که برنامه‌تان همان‌طور که انتظار دارید کار می‌کند یا نه، آزمون طراحی کنید. در نتیجه، می‌توانید برنامه‌های خود را بدونِ نگرانی از برخوردن به اشکالاتِ جدید گسترش دهید. آزمودنِ برنامه یکی از اولین مهارت‌هایی است که به شما در گذار از سطحِ مقدماتیِ برنامه‌نویسی به سطحِ متوسط یاری خواهد رساند.

1.1 - آغاز به کار

در این فصل، اولین برنامه‌ی پایتونِ خود، hello_wotrld.py، را می‌نویسید. ابتدا، باید بررسی کنید که آیا نسخه‌ی اخیرِ پایتون روی رایانه‌ی شما نصب شده یا نه. اگر این‌طور نباشد، آن را نصب می‌کنید. همچنین، یک ویرایشگرِ متن برای کار کردن با برنامه‌های پایتون نصب خواهید کرد. ویرایشگرهای متنْ کدِ پایتون را تشخیص می‌دهند و همان‌طور که برنامه را می‌نویسید، بخش‌های مختلف را هایلایت و رنگ‌آمیزی می‌کنند. این به شما کمک می‌کند تا ساختارِ برنامه‌تان را راحت‌تر درک کنید.

1.1.1 - برپا کردنِ محیطِ برنامه‌نویسی

پایتون در سیستم‌عامل‌های متفاوت کمی متفاوت عمل می‌کند، در نتیجه باید ملاحظات اندکی را در نظر داشته باشید. در بخش‌های آتی مطمئن می‌شویم که پایتون به‌درستی در سیستم‌تان نصب شده است.

نسخه‌های پایتون

هر زبانِ برنامه‌نویسی با ظهورِ فکرهای نو و فناوری‌های جدید تحول می‌یابد. توسعه‌دهندگانِ پایتون هم به طورِ مستمر این زبان را پرتوان‌تر کرده‌اند و آن را به سمتِ همه‌منظوره شدنِ هرچه بیشتر سوق داده‌اند. آخرین نسخه‌ی پایتون هنگامِ نوشتنِ این کتاب ۳.۷ بوده، ولی تمامِ برنامه‌های کتاب روی نسخه‌ی ۳.۶ و بعد از آن اجرا خواهند شد. در این بخش متوجه می‌شوید که آیا پایتون روی سیستمِ شما نصب شده و آیا به نصبِ نسخه‌ی جدیدتری نیاز دارید یا نه. پیوستِ آ راهنمای مفصلی است برای نصبِ آخرین نسخه‌ی پایتون بر روی هر کدام از سیستم‌عامل‌های اصلی. برخی پروژه‌های قدیمیِ پایتون هنوز از پایتونِ ۲ استفاده می‌کنند، اما شما از نسخه‌ی ۳ استفاده کنید. اگر پایتونِ ۲ روی سیستم‌تان نصب شده، احتمالاً‌ برای پشتیبانی از برخی برنامه‌های قدیمی است که سیستم‌تان نیاز دارد. ما نسخه‌ی ۲ را همان‌گونه که هست رها می‌کنیم و مطمئن می‌شویم که نسخه‌ی جدیدتری برای کار کردن نصب می‌کنید.

اجرای یک قطعه‌کد پایتون

شما می‌توانید مفسّر پایتون را در پنجره‌ی ترمینال اجرا کرده و به کمک آن و بدون این که به ذخیره‌سازی یا اجرای یک برنامه کامل نیاز داشته باشید، کدهای کوچک پایتون را امتحان کنید. در سراسر کتاب قطعه‌کد ها را به شکل زیر خواهید دید:

1
2

>>> print("Hello Python interpreter!")
Hello Python interpreter!

نشان »> نشان می‌دهد که شما در حال کار با ترمینال هستید، متن پررنگ‌شده همان کد شماست که باید آن را بنویسید و با فشردن دکمه‌ی ENTER اجرا کنید. بیشتر مثال‌های این کتاب برنامه‌های کوچک و جامعی هستند که آن‌ها را به جای ترمینال، به کمک ویرایشگر متنی خود اجرا خواهید کرد، زیرا بیشتر کدهای خود را در ویرایشگر متنی می‌نویسید. امّا گاهی مفاهیمِ پایه‌ای در قالبِ تعدادی قطعه‌کدنمایش داده می‌شوند که در یک نشست ترمینال پایتون اجرا می‌شوند تا مفاهیمِ خاص بهینه‌تر ارائه شوند. هر گاه مشابه خط ۱در یک لیستِ کد، سه علامت بزرگتری(«<) دیدید بدانید که کدها و خروجی‌ آن در نشست ترمینال اجرا شده‌اند. به زودی کدنویسی را در مفسّر پایتون نصب‌شده بر سیستم شما امتحان می‌کنیم. همچنین از یک ویرایشگر متنی برای ساختن یک برنامه ساده به نام Hello World! بهره خواهیم گرفت. نوشتن چنین برنامه‌ای به یک اصل برای یادگیری برنامه‌نویسی تبدیل شده است. سنّتی قدیمی در دنیای برنامه‌نویسی وجود دارد که می‌گوید اگر در اوّلین برنامه در زبان برنامه‌نویسی جدید، پیامِ Hello World! را روی صفحه چاپ کنید، برای شما خوش‌یمن خواهد بود. چنین برنامه‌ی ساده‌ای هدفی بسیار جدی را دنبال می‌کند: اگر این برنامه بر روی سیستم شما به درستی اجرا شود، هر برنامه‌ی پایتون دیگری که بنویسید نیز به همان ترتیب و به درستی اجرا خواهد شد.

درباره‌ی ویرایشگر Sublime Text

Sublime Text ویرایشگر متنی ساده‌ای است که می‌تواند روی تمام سیستم عامل‌های امروزی نصب شود. Sublime Text این امکان را فراهم می‌آورد که تقریباً‌ تمام برنامه‌های خود را به جای ترمینال، مستقیماً از طریق خودِ ویرایشگر اجرا کنید. کد شما در نشستِ ترمینالی اجرا می‌شود که درون پنجره‌ی Sublime Text جاسازی‌شده و دیدنِ خروجی را آسان می‌کند.

Sublime Text ویرایشگری مناسب برای تازه‌کارهاست، با این حال بسیاری از برنامه‌نویسان حرفه‌ای نیز از آن استفاده می‌کنند. اگر همزمان با یادگیری پایتون به کار با این ویرایشگر عادت کنید، می‌توانید هنگامی به سمت پروژه‌های بزرگ‌تر و پیچیده‌تر می‌روید به استفاده از آن ادامه دهید.

Sublime Text سیاست اعطای مجوز بسیار آزادانه‌ای دارد: شما می‌توانید از ویرایشگر تا زمانی که بخواهید به رایگان استفاده کنید، با این حال توسعه‌دهندگان آن از شما می‌خواهند درصورتی‌که محصول را پسندیده‌اید و می‌خواهید که استفاده از آن همچنان ممکن باشد، مجوز استفاده از آن را بخرید.

پیوست ب اطلاعاتی در مورد دیگر ویرایشگرها در اختیار می‌گذارد. اگر کنجکاو به استفاده از گزینه‌های دیگر هستید، همین‌جا می‌توانید به این پیوست مراجعه کرده و نگاهی به آن بیاندازید. اگر می‌خواهید برنامه‌نویسی را به سرعت آغاز کنید می‌توانید از Sublime Text برای شروع استفاده کنید و به تدریج و با کسب تجربه‌ی برنامه‌نویسی ویرایشگرهای دیگر را نیز مد نظر قرار دهید. در این فصل به نصب Sublime Text روی سیستم عامل شما می‌پردازیم.

1.1.2 - پایتون بر روی سیستم عامل های مختلف

پایتون زبان برنامه‌نویسی چندسکویی است به این معنا که بر روی تمام سیستم عامل‌های اصلی نصب می‌شود. همه‌ی برنامه‌های پایتونی که می‌نویسید روی هر رایانه‌ی امروزی که پایتون داشته باشد، اجرا می‌شود. با این حال روش‌های نصب و راه‌اندازی پایتون روی سیستم‌عامل‌های مختلف کمی متفاوت است.

در این بخش می‌آموزید که چگونه پایتون را روی سیستم خود نصب کنید. ابتدا بررسی می‌کنید که آیا نسخه‌ی متاخری از پایتون روی سیستم شما نصب شده یا نه. اگر چنین نباشد آن را و سپس Sublime Text را نصب می‌کنیم. این دو گام تنها مراحل متفاوت در سیستم عامل‌های مختلفند.

در بخش‌هایی که در ادامه می‌آیند شما برنامه Hello World! را اجرا و هر چیزی را که به درستی کار نکرد اصلاح می‌کنید. این فرآیندِ نصب در هر سیستم عامل بررسی خواهد شد تا بتوانید محیط برنامه‌نویسی پایتونِ مناسبی برای مبتدیان داشته باشید.

پایتون در ویندوز

پایتون معمولاً به صورت پیش‌فرض همراه با سیستم عامل ویندوز نصب نمی‌شود، پس احتمالاً باید آن را نصب کنید و پس از آن به نصب Sublime Text بپردازید.

نصب کردن پایتون

ابتدا بررسی کنید که آیا پایتون بر روی سیستم شما نصب شده یا نه. با وارد کردن عبارت command در منوی استارت یا نگه‌داشتن دکمه Shift و همزمان کلیک‌راست کردن روی دسکتاپ و انتخاب Open command window here یک پنجره‌ی فرمان باز کنید. در پنجره ترمینال عبارت python را با حروف کوچک وارد کنید. اگر در پاسخْ اعلانِ پایتون را (با علامت »>) دریافت کردید، پایتون بر روی سیستم شما نصب شده است. اگر پیامی مبنی بر ناشناخته بودن فرمان python دریافت کردید، به این معنی است که پایتون نصب نشده است.

در آن صورت، یا در صورتی که نسخه پایتون فعلی شما قدیمی‌تر از ۳.۶ است، باید نصب‌کننده‌ی پایتون را برای ویندوز دریافت کنید. به آدرس https://python.org/ بروید و روی پیوند Downloads بایستید. در آن‌جا باید دکمه‌ای برای نصب آخرین نسخه‌ی پایتون ببینید. بر روی آن کلیک کنید تا دریافت نسخه‌ی درستِ نصب‌کننده برای سیستم شما به طور خودکار آغاز شود. پس از دریافت فایل آن را اجرا کنید. حتماً گزینه‌ی Add Python to PATH را انتخاب کنید زیرا تنظیم صحیح سیستم شما را ساده‌تر می‌کند. شکل ۱-۱ انتخاب این گزینه را نمایش می‌دهد.

اجرای پایتون در یک نشست ترمینال

یک پنجره‌ی فرمان باز کنید و عبارت python را با حروف کوچک وارد کنید. باید اعلان پایتون (»>) را مشاهده نمایید. این اعلان نشان می‌دهد ویندوز آخرین نسخه‌ی پایتون را که هم‌اکنون نصب کردید، یافته است.

C:\> python
Python 3.7.2 (v3.7.2:9a3ffc0492, Dec 23 2018, 23:09:28) [MSC v.1916 64 bit
(AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

نکته اگر چنین خروجی‌ای یا چیزی شبیه به آن را نمی‌بینید، دستورالعمل مفصل‌تر نصب را در پیوست آ ببینید. خط زیر را در نشست پایتون خود وارد کنید و مطمئن شوید که خروجی Hello Python interpreter را می‌بینید:

>>> print("Hello Python interpreter!")
Hello Python interpreter!
>>>

هر زمان که خواستید یک قطعه‌کد پایتون را اجرا کنید، یک پنجره‌ی فرمان و یک نشست ترمینال پایتون باز کنید. برای بستن این نشست دکمه‌های CTRL+Z و سپس ENTER را فشار داده و یا فرمان ()exit را وارد نمایید.

نصب کردن Sublime Text

می‌توانید نصب‌کننده‌ی Sublime Text را از https://sublimetext.com دریافت کنید. روی پیوند download کلیک کنید و به دنبال نصب‌‌کننده‌ی ویندوز بگردید. بعد از دریافت آن را اجرا کنید و تمام گزینه‌ی پیش‌فرض‌ پیشنهادی را بپذیرید.

پایتون بر روی macOS

پایتون به صورت پیش‌فرض بر روی بسیاری از سیستم‌های macOS نصب شده امّا به احتمال زیاد نسخه‌ی آن ازرده‌خارج است و برای یادگیری شما مناسب نیست. در این بخش آخرین نسخه‌ی پایتون و پس از آن Sublime Text را نصب خواهید کرد و از تنظیم شدن صحیح آن مطمئن خواهید شد.

بررسی نصب شدن پایتون ۳

با رفتن به Applications -> Utilities -> Terminal یک پنجره‌ی ترمینال باز کنید. برای این کار همچنین می‌توانید دکمه‌های و فاصله را فشار داده، عبارت terminal را وارد کرده و ENTER را بزنید. برای فهمیدنِ نسخه‌ی پایتونی که روی سیستم شما نصب شده عبارت python را با p کوچک وارد کنید. این کار یک مفسّر پایتون در ترمینال شما باز می‌کند که می‌توانید از طریق آن دستورهای پایتون را اجرا کنید. اکنون باید خروجی‌ای شامل نسخه‌ی پایتون نصب‌شده بر روی سیستم شما و یک اعلان با علامت »> ببینید. حالا می‌توانید مانند زیر وارد کردن دستورهای پایتون را شروع کنید:

$ python
Python 2.7.15 (default, Aug 17 2018, 22:39:05)
[GCC 4.2.1 Compatible Apple LLVM 9.1.0 (clang-902.0.39.2)] on darwin
Type "help", "copyright", "credits", or "license" for more information.
>>>

این خروجی نشان می‌دهد که در حال حاضر نسخه‌ی پیش‌فرض نصب‌شده بر روی سیستم ۲.۷.۱۵ است. پس از این که این خروجی را دیدید، با فشردن Ctrl+D یا وارد کردن ()exit از اعلان پایتون خارج شوید و به اعلان ترمینال برگردید.

برای بررسی این که آیا پایتون ۳ نصب شده است، فرمان python3 را وارد کنید. احتمالاً به خطا برخواهید خورد که به معنای وجود نداشتن پایتون ۳ در سیستم شما است. اگر در خروجی پیامی مشاهده کردید که بیانگر نصب بودن نسخه‌ی ۳.۶ یا جدیدتر پایتون بود، می‌توانید این بخش را رها کنید و به بخش «اجرای برنامه در نشست ترمینال» در صفحه‌ی *** بروید. اگر پایتون ۳ به صورت پیش‌فرض بر روی سیستم نصب نشده بود باید آن را به صورت دستی نصب کنید. توجه داشته باشید که در سراسر این کتاب هر جا دستور python را دیدید باید به جای آن از python3 استفاده کنید تا مطمئن شوید که از پایتون ۳ استفاده می‌کنید، نه نسخه‌ی ۲ آن. این دو نسخه آن‌قدر تفاوت دارند که باعث شوند شما در اجرای کدهای این کتاب به کمک پایتون ۲ دچار مشکل شوید.

اگر نسخه‌ای قدیمی‌تر از ۳.۶ مشاهده کردید دستورالعمل بخش بعد را برای نصب آخرین نسخه پی بگیرید.

نصب کردن آخرین نسخه پایتون

می‌توانید نصب‌کننده‌ی پایتون را برای سیستم خود در https://python.org بیابید. روی پیوند Download بایستید. باید دکمه‌ای را برای دانلود آخرین نسخه‌ی پایتون ببینید. روی آن کلیک کنید تا دریافت آخرین نسخه‌ی صحیح پایتون به طور خودکار آغاز شود. پس از دریافت فایل نصب‌کننده آن را اجرا کنید.

پس از پایان یافتن نصب فرمان زیر را در ترمینال وارد کنید:

$ python3 --version
Python 3.7.2

باید خروجی‌ای مشابه این ببینید که نشان می‌دهد شما آماده‌ی کار کردن با پایتون هستید. هر جا فرمان python دیدید به جای آن python3 بنویسید.

اجرا کردن پایتون در یک نشست ترمینال

اکنون می‌توانید قطعه‌کدهای پایتون را با باز کردن یک ترمینال و وارد کردن python3 اجرا کنید. خط زیر را در یک نشست ترمینال وارد کنید:

>>> print("Hello Python interpreter!")
Hello Python interpreter!
>>>

پیام شما باید مستقیماً در پنجره‌ی فعلی ترمینال چاپ شود. به خاطر داشته باشید که می‌توانید مفسّر پایتون را با فشار دادن Ctrl+D یا وارد کردن فرمان exit() ببندید.

نصب کردن Sublime Text

برای نصب ویرایشگر Sublime Text باید فایل نصب‌کننده‌ی آن را از https://sublimetext.com/ بگیرید. روی پیوند Download کلیک کنید و نصب‌کننده‌ای برای macOS پیدا کنید. پس از گرفتن، آن را باز کنید و آیکون آن را کشیده و داخل پوشه Applications قرار دهید.

پایتون در لینوکس

سیستم‌های لینوکسی برای برنامه‌نویسی طراحی شده‌اند و به همین دلیل پایتون بر روی بسیاری از رایانه‌های لینوکسی نصب شده است. کسانی که لینوکس را نوشته و نگه‌داری می‌کنند انتظار دارند که شما روزی برنامه‌نویسی را از یک‌جا شروع کنید و شما را به این کار تشویق می‌کنند. به همین دلیل تنظیمات و موارد مورد نیاز برای نصب و شروع برنامه‌نویسی بسیار اندک‌اند.

بررسی نسخه‌ی پایتون

پنجره‌ی ترمینالی را با اجرا کردن برنامه Terminal روی سیستم خود باز کنید. (در اوبونتو می‌توانید دکمه‌های CTRL-ALT-T را فشار دهید). برای دریافتنِ نسخه‌ی نصب‌شده‌ی پایتون، python3 را با p کوچک وارد کنید. درصورتی‌که پایتون نصب شده باشد این فرمان مفسّرِ آن را اجرا می‌کند. باید خروجی‌ای مانند زیر را ببینید که شامل نسخه‌ی نصب‌شده‌ی پایتون و اعلان »> است. این اعلان نقطه شروع ورود فرمان‌های پایتون است:

$ python3
Python 3.7.2 (default, Dec 27 2018, 04:01:51)
[GCC 7.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

این خروجی نشان می‌دهد که در حال حاضر نسخه‌ی ۳.۷.۲ پایتون به عنوان نسخه پیش‌فرض روی سیستم شما نصب شده است. هرگاه این خروجی را دیدید، با فشردن Ctrl+D یا وارد کردن exit() از اعلان پایتون به اعلان ترمینال برگردید. هر جای این کتاب که دستور python دیدید به جای آن python3 وارد کنید.

برای اجرای کدهای این کتاب به نسخه‌ی ۳.۶ یا جدیدتر پایتون نیاز دارید. اگر نسخه‌ای که روی سیستم شما نصب شده قدیمی‌تر از ۳.۶ است با مراجعه به پیوست آ آخرین نسخه را نصب کنید.

اجرا کردن پایتون در یک نشست ترمینال

برای اجرا کردن قطعه‌کدهای پایتون می‌توانید مانندِ آ‌ن‌چه هنگام بررسی نسخه‌ی نصب‌شده انجام دادید، یک ترمینال باز کنید و فرمان python3 را وارد کنید. این کار را مجدداً انجام دهید و خط زیر را در نشست ترمینال وارد کنید:

>>> print("Hello Python interpreter!")
Hello Python interpreter!
>>>

پیام خروجی باید مستقیماً در پنجره‌ی فعلی ترمینال چاپ شود. به خاطر داشته باشید که می‌توانید مفسّر پایتون را با فشردن Ctrl+D یا وارد کردن فرمان ()exit ببندید.

نصب کردن Sublime Text

در لینوکس می‌توانید به کمک Ubuntu Software Center این نرم‌افزار را نصب کنید. روی آیکون Ubuntu Software کلیک کنید و Sublime Text را جستجو کنید. با کلیک روی آن، آن را نصب و اجرا کنید.

1.1.3 - اجرای یک برنامه‌ی Hello World

با نصب شدن نسخه‌ی مناسب پایتون و Sublime Text، تقریباً آماده‌اید که اوّلین برنامه‌ی پایتونی را در یک ویرایشگر متنی بنویسید و اجرا کنید. امّا پیش از پرداختن به این کار باید مطمئن شوید که در سیستم شما Sublime Text به درستی برای استفاده از نسخه‌ی درست پایتون تنظیم شده یا نه. پس از آن برنامه‌ی Hello World! را نوشته و اجرا می‌کنید.

تنظیم کردن Sublime Text برای استفاده از نسخه‌ی صحیح پایتون

اگر در سیستم شما فرمان python پایتون ۳ را فرامی‌خواند نیاز به هیچ تنظیمی ندارید و می‌توانید به بخش بعد مراجعه کنید. اما اگر از فرمان python3 استفاده می‌کنید باید Sublime Text را برای اجرای برنامه‌های خود با استفاده از نسخه‌ی درست پایتون، تنظیم کنید.

روی آیکون Sublime Text کلیک کنید یا به کمک نوار جستجوی سیستم خود آن را پیدا و اجرا کنید. به Tools→ Build System → New Build System بروید تا یک فایل تنظیمات جدید برای شما گشوده شود. هر آنچه را می‌بینید پاک کرده و این‌ها را به جای آن وارد کنید:

1
2
3

{
  "cmd": ["python3", "-u", "$file"]
}

این کد Sublime Text را وامی‌دارد تا هنگام اجرای برنامه‌های پایتون از فرمان python3 استفاده کند. در پوشه‌ی پیش‌فرضی که Sublime Text برای ذخیره کردن می‌گشاید، فایل را با عنوان Python3.sublime-build ذخیره کنید.

اجرای hello_world.py

پیش از نوشتن اولین برنامه‌ی خود پوشه‌ای به نام python_work برای پروژه‌های خود بسازید. بهترین کار این است که برای نام‌گذاری فایل‌ها و پوشه‌های خود از حروف کوچک و زیر‌خط استفاده کنید زیرا قراردادهای نامگذاری پایتون چنین پیشنهاد می‌کنند.

Sublime Text را باز کنید.از File -> Save As، یک فایل پایتون خالی به نام hello_world.py در پوشه‌ی python_work ذخیره کنید. پسوند .py به Sublime Text می‌گوید که کد شما به زبان پایتون نوشته شده و باید آن را چگونه اجرا و متن آن را به روشی کارآمد هایلایت کند.

پس از ذخیره کردن فایل خود خط زیر را در ویرایشگر متنی وارد کنید:

1

print(“Hello Python world!”)

اگر فرمان python روی سیستم شما کار کند، می‌توانید برنامه‌ی خود را با انتخاب Tools->Build در منوی برنامه یا فشردن CTRL+B ـــ (+B روی macOS) اجرا کنید. اگر مانند بخش قبل به ناچار تنظیمات پیش‌فرض برنامه را تغییر داده‌اید، گزینه‌ی Python3 را از Tools->Build System انتخاب کنید. پس از آن می‌توانید برنامه‌های خود را با فشردن CTRL+B (ــــ+B) یا از طریق Tools->Build اجرا کنید.

یک صفحه‌ی ترمینال در قسمت پایینی Sublime Text نمایان می‌شود و خروجی زیر را نمایش می‌دهد:

1
2

Hello Python world!
[Finished in 0.1s]

اگر چنین خروجی‌ای را ندیدید احتمالاً اشتباهی در برنامه‌ی شما وجود دارد. حروفی را که وارد کرده‌اید یک به یک چک کنید. آیا اشتباهاً print را با حروف بزرگ ننوشته‌اید؟ آیا یکی یا هر دوی پرانتزها یا علامت‌های نقل قول دوتایی را فراموش نکرده‌اید؟ زبان‌های برنامه‌نویسی دستور زبان بسیار مخصوصی دارند و اگر آن را رعایت نکنید به خطا برخواهید خورد. اگر نتوانستید برنامه را اجرا کنید توصیه‌های بخش بعد را ببینید.

1.1.4 - اشکال‌زدایی

اگر نمی‌توانید برنامه hello_world.py را اجرا کنید، اینجا چند راه چاره برای آزمودن وجود دارد که در عین حال راهکارهای عمومی خوبی برای حل هر مشکلِ برنامه‌نویسی است:

• اگر در برنامه‌ای خطای مشخّصی وجود داشته باشد، پایتون یک trace-back که نوعی گزارش خطاست، نمایش می‌دهد. پایتون فایل را می‌گردد و سعی می‌کند که خطا را تشخیص دهد. Trace-back را بررسی کنید؛ ممکن است سرنخی به دست دهد که چه مشکلی مانع اجرا برنامه شده است.
• از رایانه‌ی خود دور شوید، نفسی تازه کنید و دوباره تلاش کنید. به یاد داشته باشید که دستور زبان در برنامه‌نویسی بسیار مهم است، پس حتی جا انداختن یک دونقطه، یک علامت نقل قولِ جابه‌جا یا پرانتزهای نابه‌جا می‌توانند جلوی اجرای برنامه را بگیرند. بخش‌های مرتبط این فصل از کتاب را دوباره بخواهید، کد خود را بررسی کنید و سعی کنید مشکل را بیابید.
• از نو آغاز کنید. احتمالاً نیازی نیست که هیچ نرم‌افزاری را پاک کنید امّا ممکن است پاک کردن فایل hello_world.py و ساختن مجدد آن از اول، فایده داشته باشد.
• از کس دیگری بخواهید که گام‌های ذکرشده در کتاب را در رایانه‌ی شما یا خود بپیماید و به دقت آن‌چه را انجام می‌دهد زیر نظر بگیرید. شاید شما یک گام کوچک را جا انداخته‌اید و کس دیگری آن را پیدا کند.
• شخص دیگری را که پایتون می‌داند پیدا کنید و از او بخواهید که شما را راه بیندازد. اگر پرس و جو کنید احتمالاً کسی را خواهید یافت که نحوه‌ی کار با پایتون را می‌داند.
• دستورالعمل‌های راه‌اندازی این فصل در وب‌سایت همراه این کتاب در نشانی https://nostarch.com/pythoncrashcourse23/ نیز یافت می‌شود. نسخه‌ی آنلاین این دستورالعمل‌ها ممکن است برای شما کارآمدتر باشد زیرا می‌توانید به کمک آن و به سادگی کد را کپی کنید.
• دنبال کمک آنلاین بگردید. در پیوست پ تعدادی از این منابع مانند انجمن‌ها یا تالارهای گفتگوی آنلاین معرّفی شده‌اند که می‌توانید در آن‌ها از کسانی که قبلاً با مشکل شما سر و کار داشته‌اند کمک بخواهید.

هرگز نگران این نباشید که ممکن است مزاحم برنامه‌نویسان خبره شوید. هر برنامه‌نویسی تجربه‌ی گیر کردن در مساله‌ای را دارد و بیشتر برنامه‌نویسان از کمک کردن به شما برای برپایی سیستم خود خوشحال می‌شوند. مادامی‌که به روشنی بیان کنید که چه کاری می‌خواهید بکنید، چه تلاش‌هایی کرده‌اید و چه نتایجی گرفته‌اید، بخت خوبی خواهید داشت تا کسی را برای یاری گرفتن بیابید. چنانکه در مقدّمه گفتیم، جامعه‌ی پایتون فضایی دوستانه دارد و از تازه‌کارها استقبال می‌کند.

پایتون روی رایانه‌های امروزی به خوبی اجرا می‌شود. مشکلات اولیه در راه‌اندازی ممکن است خسته‌کننده به نظر بیایند ولی می‌ارزد که از آن‌ها سردربیاورید. زمانی که hello_world.py را اجرا کردید، می‌توانید آموختن پایتون را آغاز کنید و برنامه‌نویسی شما جذاب‌تر و لذت‌بخش‌تر خواهد شد.

1.1.5 - اجرا کردن برنامه‌های پایتون از ترمینال

بیشتر برنامه‌هایی را که در ویرایشگر متنی می‌نویسید مستقیماً از همان‌جا اجرا خواهید کرد. با این حال گاهی اجرای برنامه‌ها از ترمینال سودمند خواهد بود. برای مثال ممکن است شما بخواهید برنامه‌ای را که قبلاً نوشته شده بدون باز کردن در ویرایشگر متنی اجرا کنید.

اگر بدانید چگونه به پوشه‌ای که برنامه در آن قرار دارد دسترسی پیدا کنید، می‌توانید آن را در هر سیستمی که پایتون بر روی آن نصب شده اجرا کنید. برای امتحان، مطمئن شوید که فایل hello_world.py را در پوشه‌ی python_work در میز کار خود ذخیره کرده‌اید.

در ویندوز

در یک پنجره‌ی فرمان می‌توانید از دستور ترمینالی cd (سرواژه‌ی change directory) برای گشت و گذار در فایل‌سیستم خود استفاده کنید. فرمان dir تمام فایل‌هایی را که در پوشه فعلی وجود دارد نمایش می‌دهد.

یک پنجره‌ی ترمینال باز کنید و دستورهای زیر را برای اجرای hello_world.py وارد کنید:

1
2
3
4
5

C:\> cd Desktop\python_work
C:\Desktop\python_work> dir
hello_world.py
C:\Desktop\python_work> python hello_world.py
Hello Python world

در خط ۱از دستور cd برای رفتن به پوشه‌ی python_work که خود در پوشه‌ی Desktop قرار دارد استفاده می‌کنید. بعد از فرمان dir برای اطمینان یافتن از وجود فایل hello_world.py در این پوشه استفاده می‌کنید.(خط ۲) در ادامه با به‌کارگیری فرمان python hello_world.py فایل را اجرا می‌کنید.(خط ۴)

بیشتر برنامه‌های شما مستقیماً از ویرایشگر متنی به خوبی اجرا می‌شوند. امّا همزمان با پیچیده‌تر شدن کار، گاهی به اجرای برنامه از یک ترمینال نیاز پیدا می‌کنید.

در macOS و لینوکس

اجرای یک برنامه پایتون روی لینوکس و macOS یکسان است. می‌توانید از دستور ترمینالی cd برای گشتن در فایل‌سیستم خود در یک پنجره‌ی فرمان استفاده کنید. فرمان ls تمام فایل‌های غیرپنهان را که در پوشه فعلی وجود دارد نمایش می‌دهد.

یک پنجره‌ی ترمینال باز کنید و فرمان‌های زیر را برای اجرای hello_world.py وارد کنید:

1
2
3
4
5

~$ cd Desktop/python_work/
~/Desktop/python_work$ ls
hello_world.py
~/Desktop/python_work$ python hello_world.py
Hello Python world!

در خط ۱ از دستور cd برای رفتن به پوشه‌ی python_work که خود در پوشه‌ی Desktop قرار دارد استفاده می‌کنید. سپس از فرمان ls برای اطمینان یافتن از وجود فایل hello_world.py در این پوشه استفاده می‌کنید.(خط ۲) در ادامه با به‌کارگیری فرمان python hello_world.py فایل را اجرا می‌کنید.(خط ۴)

بسیار ساده است. شما از دستور python (یا python3) برای اجرای برنامه‌های پایتون خود استفاده می‌کنید.

1.1.6 - خودآزمایی

تمرین‌های این فصل به خودی خود قابل درکند. با شروع فصل ۲، چالش‌هایی که رفع می‌کنید بر پایه‌ی چیزهایی است که آموخته‌اید.

python.org

صفحه‌ی اصلی سایت پایتون را بگردید و موضوعاتی را به نظرتان جالب می‌آید بیابید. هر چه با پایتون بیشتر آشنا شوید بخش‌های مختلف این سایت بیشتر به کار شما خواهند آمد.

Hello World Typos

فایل hello_world.py را که هم‌اینک ساخته‌اید باز کنید. جایی در خط برنامه یک غلط املایی ایجاد کنید و برنامه را دوباره اجرا کنید. آیا می‌توانید غلطی املاییِ مشکل‌زا را اصلاح کنید؟ آیا پیام خطا برای شما قابل درک است؟ می‌توانید غلطی املایی درست کنید که خطایی ایجاد نکند؟ فکر می‌کنید چرا این غلط برنامه را دچار خطا نکرد؟

Infinite Skills

اگر مهارتهای بی‌پایان برنامه‌نویسی داشتید چه برنامه‌ای می‌ساختید؟ شما می‌خواهید برنامه‌نویسی را بیاموزید. اگر یک هدف پایانی در ذهن داشته باشید برای مهارتهای جدیدی که می‌آموزید کاربردی آنی خواهید داشت. الان زمان خوبی است که از چیزهایی که می‌خواید بسازید پیش‌نویسی بنویسید. داشتن یک دفترچه‌ی «ایده‌ها» عادت خوبی است تا برای شروع هر پروژه‌ی جدیدی به آن مراجعه کنید. چند دقیقه وقت بگذارید و سه برنامه‌ای را که می‌خواید بسازید شرح دهید.

1.1.7 - خلاصه

در این فصل در مجموع کمی درباره‌ی پایتون آموختید و اگر آن را روی سیستم خود نداشتید، نصبش کردید. همچنین یک ویرایشگر متنی برای کدنویسی راحت‌تر پایتون نصب کردید. قطعه‌کدهای پایتون را در یک نشست ترمینال و اولین برنامه‌ی خود hello_world.py را اجرا کردید. همچنین کمی در مورد نحوه‌ی اشکال‌زدایی آموختید.

در فصل بعد در مورد انواع مختلف داده‌ای خواهید آموخت که می‌توانید در برنامه‌های پایتون با آن‌ها کار کنید و از متغیّرها استفاده خواهید کرد.

1.2 - متغیّرها و انواع ساده‌ی داده‌ها

در این فصل در مورد انواع مختلفی از داده‌ها خواهید آموخت که می‌توانید با آن‌ها در برنامه‌های پایتون کار کنید. همچنین چگونگی استفاده از متغیّرها را برای نمایش داده در برنامه‌های خود یاد می‌گیرید.

1.2.1 - هنگام اجرای hello_world.py در واقع چه اتّفاقی می‌افتد؟

بیاید به آن‌چه پایتون هنگام اجرای hello_world.py انجام می‌دهد نگاهی دقیق‌تر بیاندازیم. برخلاف تصوّر ما پایتون حتی هنگام اجرا کردن یک برنامه‌ی ساده هم کارهای قابل توجّهی انجام می‌دهد:

1

print("Hello Python world!")

اجرای این کد چنین خروجی‌ای تولید می‌کند:

1

Hello Python world!

هنگامی که فایل hello_world.py را اجرا می‌کنید، پسوند .py مشخّص می‌کند که این فایل یک برنامه‌ی پایتون است. پس ویرایشگر متنی این فایل را از طریق مفسّر پایتون اجرا می‌کند. این مفسّر برنامه را می‌خواند و مشخّص می‌کند که هر واژه در برنامه چه معنی‌ای می‌دهد. برای مثال هنگامی که مفسّر به واژه‌ی print با دو پرانتزِ پس از آن می‌رسد، هر آن‌چه‌که داخل پرانتزها قرار دارد روی صفحه چاپ می‌کند.

همچنان که به نوشتن برنامه ادامه می‌دهید ویرایشگر شما بخش‌های مختلف برنامه را به روش‌های مختلف هایلایت و رنگ‌آمیزی می‌کند. برای مثال تشخیص می‌دهد که print() نام یک تابع است و آن را با یک رنگ نمایش می‌دهد. همچنین تشخیص می‌دهد که “Hello Python world!” کد پایتون نیست و آن را با رنگِ دیگری نمایش می‌دهد. این ویژگی برجسته‌سازی یا هایلایت نحوی نامیده می‌شود و برای شروعِ برنامه‌نویسی بسیار سودمند خواهد بود.

1.2.2 - متغیّرها

حال بیایید از یک متغیّر در hello_world.py استفاده کنیم. یک خط به ابتدای فایل خود بیفزایید و خط دوم را این‌گونه تغییر دهید:

1
2

message = "Hello Python world!"
print(message)

برنامه را اجرا کنید تا ببینید چه رخ می‌دهد. باید خروجی‌ای مشابه قبل ببینید:

1

Hello Python world!

یک متغیّر به نام message اضافه کرده‌ایم. هر متغیّر با یک مقدار در ارتباط است که اطّلاعات مرتبط با آن متغیّر را در بر دارد. در این مورد مقدارْ همان متنِ “Hello Python world!” است.

اضافه کردن یک متغیّر کارِ مفسّر پایتون را کمی سخت‌تر می‌کند. هنگامی که مفسّر خط اوّل را پردازش می‌کند متغیّر message را به متن “Hello Python world!” ارتباط می‌دهد و زمانی که به خطّ دوم رسید مقداری را که به message اختصاص یافته چاپ می‌کند.

حال با تغییر دادن hello_world.py برای چاپ پیام دیگری، این برنامه را تغییر می‌دهیم. یک خطّ خالی به فایل خود اضافه کنید و این دو خطّ جدید را اضافه کنید:

1
2
3
4

message = "Hello Python world!"
print(message)
message = "Hello Python Crash Course world!"
print(message)

اکنون با اجرای hello_world.py دو خطّ زیر را در خروجی می‌بینید:

1
2

Hello Python world!
Hello Python Crash Course world!

در برنامه‌ی خود می‌توانید مقدار یک متغیّر را هر زمانی تغییر دهید و پایتون همیشه مقدار فعلی و جدید آن را در نظر خواهد گرفت.

نام‌گذاری و به‌کار‌گیری مغیّرها

هنگام استفاده از متغیّرها در پایتون باید تعداد اندکی قانون و راهنمایی را رعایت کنید. تخطّی از برخی از این قانون‌ها موجب بروز خطا خواهند شد. راهنمایی‌ها به شما کمک می‌کند تا کدی بنویسید که راحت‌تر قابل خواندن و فهمیدن باشد. قوانین زیر را در رابطه با متغیّرها حتماً به خاطر داشته باشید:

• نام متغیّرها تنها می‌تواند شامل حروف، اعداد و زیر‌خط باشند. نام‌ها می‌توانند با حرف یا زیر‌خط و نه با عدد آغاز شوند. برای مثال می‌توانید یک متغیّر را message_1 بنامید امّا نام‌گذاری 1_message ممکن نیست.

• گذاشتن فاصله در نام متغیّرها مجاز نیست امّا برای فاصله‌گذاری بین چند واژه در نام متغیّرها می‌توانید از زیر‌خط استفاده کنید. برای مثال greeting_message مجاز است امّا greeting message موجب خطا می‌شود.

• از به‌کارگیری کلیدواژگان و نام توابع پایتون به عنوان نام متغیّر پرهیز کنید. به بیان دیگر از واژگانی که پایتون برای اهداف خاص برنامه‌نویسی در نظر گرفته، مانند print، برای نام‌گذاری استفاده نکنید. (ن.ک «کلیدواژگان و توابع داخلی پایتون» ص ***)

• نام متغیّرها بهتر است کوتاه امّا گویا باشند. برای مثال name از n و student_name از s_n و name_length از length_of_persons_name بهتر است.

• هنگام استفاده از حرف کوچک l (اِل) و حرف بزرگ O دقّت کنید چون ممکن است با اعداد 1 و 0 اشتباه گرفته شوند.

ممکن است یادگیریِ روشِ ایجاد نام‌های مناسب برای متغیّرها کمی به تمرین نیاز داشته باشد، به ویژه زمانی که برنامه‌های شما جذّاب‌تر و پیچیده‌تر می‌شوند. هر چه برنامه‌های بیشتری بنویسید و کدهای دیگران را بیشتر بخوانید در یافتن نام‌های معنادار پیشرفت حاصل خواهید کرد.

پرهیز از نام‌گذاری اشتباه متغیّرها

هر برنامه‌نویسی اشتباه می‌کند و بیشتر آن‌ها هر روزه مرتکب اشتباه می‌شوند. هرچند برنامه‌نویسان خوب هم ممکن است خطا کنند امّا در عین حال می‌دانند چگونه به درستی آن را رفع کنند. اجازه دهید به خطایی که احتمالاً به زودی مرتکب می‌شوید و روش برطرف کردن آن نگاهی بیندازیم.

در اینجا عمداً برنامه‌ای می‌نویسیم که خطا ایجاد کند. در کد زیر واژه‌ی mesage که پررنگ نشان داده‌شده غلط املایی دارد:

1
2

message = "Hello Python Crash Course reader!"
print(mesage)

هنگامی که در برنامه‌ای خطا رخ می‌دهد مفسّر پایتون تمام تلاش خود را می‌کند تا محل وقوع آن را پیدا کند. زمانی که برنامه به درستی اجرا نمی‌شود مفسّر یک traceback ارائه می‌کند. هنگامی که مفسّر کد شما را اجرا می‌کند و در جایی به مشکل می‌خورد، Traceback پیشینه‌ای از مشکل و محلّ وقوع آن را ذخیره می‌کند. اینجا نمونه‌ای از traceback می‌بینیم که پس از اجرای برنامه با نامِ غلطِ متغیّر ایجاد می‌شود:

1
2
3
4

Traceback (most recent call last):
   File "hello_world.py", line 2, in <module>
print(mesage)
NameError: name 'mesage' is not defined

خروجی خط ۲ وقوع خطایی را در خطِّ دومِ فایلِ hello_world.py گزارش می‌دهد. مفسّرْ خطِ ۳ را برای کمک به یافتن سریع‌تر خطا و خط ۴ را برای بیان نوع خطایی که پیدا کرده تولید می‌کند. در این مورد مفسّر به خطای name error برخورده و اعلام می‌کند که متغیّر mesage که قرار است چاپ شود، قبلاً جایی تعریف نشده است. پایتون نمی‌تواند نامی را که به غلط ارائه شده تشخیص دهد. خطای نام‌گذاری معمولاً به این معنی است که یا مقدار متغیّر را پیش از به‌کارگیری آن تعیین نکرده‌ایم یا در وارد کردن نام متغیّر مرتکب اشتباه املایی شده‌ایم.

می‌دانیم که در این کد و در خطِ دوم حرف s را در نام متغیّر message جاانداخته‌ایم. مفسّر پایتون کد شما را از لحاظ املایی بررسی نمی‌کند امّا مطمئن می‌شود که متغیّرها همواره به درستی نوشته شده‌اند. برای مثال ببینید اگر واژه‌ی message را یک جای دیگر برنامه هم اشتباه بنویسیم چه رخ می‌دهد:

1
2

mesage = "Hello Python Crash Course reader!"
print(mesage)

اینجا برنامه به درستی اجرا می‌شود!

1

Hello Python Crash Course reader!

زبان‌های برنامه‌نویسی گرچه سخت‌گیرند امّا به درست‌ یا غلط نوشتن واژگان اهمّیّتی نمی‌دهند. در نتیجه نیازی نیست که املا و دستور زبان انگلیسی را هنگام نام‌گذاری متغیّرها و نوشتن کد در نظر بگیرید.

بسیاری از خطاهای برنامه‌نویسی غلط‌های املایی ساده و یک‌کاراکتری در خطّی از برنامه هستند. اگر زمان زیادی را صرف پیدا کردن چنین خطاهایی می‌کنید بدانید که با بسیاری دیگر همدردید. بسیاری از برنامه‌نویسان مجرّب و مستعد ساعت‌ها وقت صرف شکار چنین خطاهای کوچکی می‌کنند. سخت نگیرید و از آن‌ها بگذرید و بدانید که چنین خطاهایی در دوران برنامه‌نویسی شما بسیار رخ خواهد داد.

متغیّرها برچسب هستند

گاهی متغیّرها را مانند جعبه‌ای در نظر می‌گیرند که مقادیر را در آن‌ها ذخیره می‌کنید. دفعات اوّلی که از متغیّرها استفاده می‌کنید چنین طرز نگاهی سودمند است امّا این روشی دقیق برای بیان نحوه‌ی نمایش داخلی متغیّرها در پایتون نیست. بهتر است به متغیّرها به چشم برچسب‌هایی نگاه کنید که به مقادیر مختلف می‌زنید. همچنین می‌توانید بگویید که متغیّرها به مقدار مشخّصی اشاره می‌کنند.

این تمایز احتمالاً در برنامه‌های آغازین شما خیلی مهم نیست امّا بهتر است آن را زودتر فرابگیرید. ممکن است جایی به رفتار غیرمنتظره‌ی یک متغیّر بربخورید و درک صحیح و دقیق چگونگی کارکرد متغیّرها به تشخیص آنچه در برنامه رخ می‌دهد کمک می‌کند.

خودآزمایی

برای هر تمرین یک برنامه‌ی جداگانه بنویسید. هر برنامه را با نامی ذخیره کنید که مطابق قواعد استاندارد پایتون است، از حروف کوچک و زیرخط استفاده کنید. برای مثال simple_message.py یا simple_messages.py.

Simple Message

پیامی به یک متغیّر نسبت دهید و سپس آن را چاپ کنید.

Simple Messages

پیامی به یک متغیّر نسبت دهید و آن را چاپ کنید. سپس مقدار متغیّر را به پیام جدیدی تغییر دهید و پیام جدید را چاپ کنید.

1.2.3 - رشته‌ها

از آن‌جایی‌که بیشتر برنامه‌ها انواعی از داده را تعریف و جمع‌آوری می‌کنند و سپس روی آن‌ها عملیّاتی انجام می‌دهند، دسته‌‌بندی انواع مختلف داده سودمند است. اوّلین نوع داده‌ای که بررسی می‌کنیم رشته‌ها هستند. رشته‌ها در نگاه اوّل ساده به نظر می‌آیند امّا می‌توانید آن‌ها را به روش‌های مختلف به کارگیرید.

رشته دنباله‌ای از حروف یا کاراکترها است. در پایتون هر آن‌چه داخل علامت نقل قول باشد رشته در نظر گرفته می‌شود و می‌توانید مانند زیر علامت نقل قول تکی یا دوتایی را دور رشته قرار دهید:

1
2

"This is a string."
'This is also a string.'

این آزادی عمل در به‌کارگیری علامت‌های نقل قول کمک می‌کند تا به راحتی از علامت‌های نقل قول و آپستروفی در رشته‌های خود استفاده کنید:

1
2
3

'I told my friend, "Python is my favorite language!"'
"The language 'Python' is named after Monty Python, not the snake."
"One of Python's strengths is its diverse and supportive community."

اکنون چند روش استفاده از رشته‌ها را بررسی می‌کنیم.

تغییر بزرگ و کوچکی حروف در یک رشته به کمک متدها

یکی از ساده‌ترین کارهای انجام با با رشته‌ها تغییر دادن وضعیت بزرگ و کوچکی حروف در کلمات آن است. به کد زیر نگاه کنید و سعی کنید آن‌چه را که رخ می‌دهد شرح دهید:

1
2

name = "ada lovelace"
print(name.title())

فایل را با نام name.py ذخیره و آن را اجرا کنید. باید چنین خروجی‌ای را ببینید:

1

Ada Lovelace

در این مثال متغیّر name به رشته‌ای با حروف آغازین کوچک “ada lovelace” اشاره می‌کند. هنگام فراخوانی print، متدِ title() پس از متغیّر آمده است. متد عملی است که پایتون می‌تواند روی قطعه‌ای از داده انجام دهد. نشانه‌ی نقطه (.) پس از name در name.title() به پایتون می‌گوید که متد title() را روی متغیر name اعمال کند. پس از هر متد یک جفت پرانتز می‌آید زیرا متدها گاهی به اطّلاعات بیشتری برای انجام کار خود نیاز دارند. چنین اطّلاعاتی داخل این پرانتزها قرار داده می‌شوند. تابع title() به هیچ اطّلاعات اضافه‌ای نیاز ندارد در نتیجه پرانتزها خالی مانده‌اند.

متد title() هر کلمه را به حالت عنوان درمی‌آورد که در آن هر واژه با حروف بزرگ آغاز می‌شود. زمانی که به نام به عنوان نوعی اطّلاعات نگاه می‌کنیم، کاربرد چنین متدی آشکار می‌شود. برای مثال ممکن است از برنامه‌ی خود بخواهید تمام مقادیر ورودی مانند Ada, ADA و ada را یک نام در نظر بگیرد و همه‌ی آن‌ها را به شکل Ada نمایش دهد.

تعدادی متد سودمند دیگر هم برای تغییر وضعیّت بزرگی و کوچکی حروف وجود دارد. مثلاً می‌توانید تمام حروف یک رشته را به حروف بزرگ یا کوچک تبدیل کنید:

1
2
3

name = "Ada Lovelace"
print(name.upper())
print(name.lower())

خروجی زیر مشاهده خواهد شد:

1
2

ADA LOVELACE
ada lovelace

متد lower() به ویژه هنگام ذخیره‌سازی اطّلاعات سودمند است. در بسیاری از موارد شما نمی‌خواهید به حروف بزرگ و کوچکی که کاربر وارد کرده اعتماد کنید، پس پیش از ذخیره کردن تمام حروف اطّلاعات ورودی را به حروف کوچک تبدیل می‌کنید. پس از آن هر زمان که خواستید اطّلاعات را نمایش دهید از حالتی استفاده می‌کنید که بیشتری معنا را برای هر رشته دارد.

به‌کارگیری متغیّرها در رشته‌ها

مواردی پیش می‌آید که می‌خواهید از مقدار یک متغیّر در داخل یک رشته استفاده کنید. برای مثال دو متغیّر دارید که یکی نام کوچک و دیگر نام خانوادگی را نمایش می‌دهند و می‌خواهید این دو مقدار را با هم ترکیب کنید تا نام و نام خانوادگی یک نفر را بیان کنید:

1
2
3
4

first_name = "ada"
last_name = "lovelace"
full_name = f"{first_name} {last_name}"
print(full_name)

برای وارد کردن مقدار یک متغیّر داخل یک رشته، حرف f را مانند ۳ درست پیش از علامت نقل قول آغازین قرار دهید. دور نام یا نام‌های هر متغیّری که داخل رشته وارد می‌شود یک آکُلاد قرار دهید. پایتون هنگام نمایش رشته هر متغیّر را با مقدار آن جایگزین می‌کند.

به این رشته‌ها f-string می‌گویند. f سرواژه‌ی format است، زیرا پایتون این رشته‌ها را با جایگزینیِ نامِ متغیّرهای داخلِ هر آکُلاد با مقدارِ آن، قالب‌بندی می‌کند. خروجی کد قبلی به شکل زیر است:

1

ada lovelace

با f-stringها کارهای زیادی می‌توانید انجام دهید.مثلاً می‌توانید با اطَلاعاتِ یک متغیّر پیام‌های کاملی بسازید، مانند زیر:

1
2
3
4

first_name = "ada"
last_name = "lovelace"
full_name = f"{first_name} {last_name}"
print(f"Hello, {full_name.title()}!")

در پیامی که برای تبریک گفتن به شخص ساخته می‌شود نام کامل او آورده می‌شود ۴. متد title() حروف اوّل نام کامل را بزرگ می‌کند. این کد پیامی ساده امّا با قالبی زیبا تولید می‌کند:

1

Hello, Ada Lovelace!

به جز این می‌توانید از f-stringها برای تولید یک پیام و انتساب کلّ آن به یک متغیّر استفاده کنید:

1
2
3
4
5

first_name = "ada"
last_name = "lovelace"
full_name = f"{first_name} {last_name}"
message = f"Hello, {full_name.title()}!"
print(message)

همانند کد قبلی این کد هم پیام Hello, Ada Lovelace! را نمایش می‌دهد امّا این بار با قرار دادن پیام در یک متغیّر خط ۱ فراخوانی تابع نهاییprint() را بسیار ساده‌تر کردیم. خط ۲

1

full_name = "{} {}".format(first_name, last_name)

افزودن فضای خالی به رشته‌ها به کمک تب و خطوط جدید

در برنامه‌نویسی به هر حرف چاپ‌نشدنی مانند علامت‌های فاصله، تب و پایانِ خط فضای خالی گفته می‌شود. می‌توانید به کمک این فضاهای خالی به خروجی خود شکل دهید تا خواندنِ آن برای کاربر ساده‌تر باشد.

برای اضافه کردن تب به متن خود از ترکیب حروف \t مانند آن‌چه در خط ۱ نمایش داده شده استفاده کنید:

1
2
3
4

>>> print("Python")
Python
>>> print("\tPython")
Python

برای افزودن خط جدید به رشته‌ی خود از ترکیب حروف \n استفاده کنید:

1
2
3
4
5

>>> print("Languages:\nPython\nC\nJavaScript")
Languages:
Python
C
JavaScript

همچنین می‌توانید تب‌ها و خط‌های جدید را در یک رشته ترکیب کنید. رشته‌ی “\n\t” به پایتون می‌گوید که به خطّ جدید برو و خطّ بعدی را با یک تب شروع کن.

مثال زیر نشان می‌دهد که چگونه می‌توانید با یک رشته‌ی یک‌خطّی خروجی‌ای در چهار خط تولید کنید:

1
2
3
4
5

>>> print("Languages:\n\tPython\n\tC\n\tJavaScript")
Languages:
Python
C
JavaScript

در دو فصل آینده هنگامی که می‌خواهید با چند خط کد خطوط زیادی در خروجی تولید کنید، تب‌ها و خط‌های جدید بسیار کاربردی خواهند بود.

حذف کردن فاصله‌های خالی

در برنامه‌های شما وجود فاصله‌ی اضافی در یک رشته می‌تواند گیج‌کننده باشد. برای برنامه‌نویسان دو رشته‌ی ‘python’ و ‘python ’ تقریباً یکی هستند. امّا برای یک برنامه‌ی رایانه‌ای این‌ها دو رشته‌ی متفاوت‌اند. پایتون فاصله‌ی اضافی را در ‘python ’ تشخیص داده و تمایز آن را در نظر می‌گیرد مگر آن‌که شما جور دیگری بخواهید.

اهمّیّت فاصله‌های خالی آن‌جا معلوم می‌شود که گاهی می‌خواهید دو رشته را برای بررسی یکی بودن مقایسه ‌کنید. یک مورد مهم، برای مثال، مقایسه‌ی نام کاربری کاربران هنگام ورود آن‌ها به یک وب‌سایت است. فاصله‌ی اضافی در موارد خیلی ساده‌تر هم ممکن است گیج‌کننده باشد. خوشبختانه پایتون حذف کردن فاصله‌ی خالی را از داده‌هایی که کاربران وارد می‌کنند ساده کرده است.

پایتون می‌تواند فاصله‌های خالی را در سمتِ چپ یا راستِ یک رشته تشخیص دهد. برای اطمینان یافتن از عدم وجود فاصله‌ی خالی در سمت راست یک رشته از متد rstrip() استفاده می‌کنیم:

1
2
3
4
5
6
7

>>> favorite_language = 'python '
>>> favorite_language
'python '
>>> favorite_language.rstrip()
'python'
>>> favorite_language
'python '

در پایان رشته‌ای که در خط ۱ به عنوان مقدار به favorite_language نسبت داده‌ایم یک فاصله‌ی خالی اضافی وجود دارد. وقتی در خط ۲ از پایتون می‌خواهید که این مقدار را در نشست ترمینال نمایش دهد، فاصله را در انتهای آن می‌بینید. هنگامی که در خط ۴ متد rstrip() روی متغیّر favorite_language عمل می‌کند، فاصله‌ی اضافی حذف می‌شود. با این حال این حذف شدن موقّتی است. اگر بار دیگر مقدار متغیّر favorite_language را نمایش دهید، خواهید دید که مقدار رشته همانند قبل است و فاصله‌ی اضافی همچنان وجود دارد. ۶

برای حذف دائمی فاصله از رشته باید مقدار رشته‌ی اصلاح‌شده را دوباره به نام همان متغیّر نسبت دهید:

1
2
3
4

>>> favorite_language = 'python '
>>> favorite_language = favorite_language.rstrip()
>>> favorite_language
'python'

همانطور که در خط ۲ نشان داده شده است، برای حذف فاصله‌ی اضافی از رشته، آن را از سمت راست رشته حذف می‌کنید و مقدار جدید را به متغیّر اولیّه نسبت می‌دهید. تغییر مقدار یک متغیّر در برنامه‌نویسی بسیار متداول است. این‌گونه است که مقدار یک متغیّر می‌تواند حین اجرای برنامه یا در پاسخ به ورودیِ کاربر تغییر کند.

همچنین می‌توانید با متد lstrip() فاصله‌های خالی یک رشته را از سمت چپ یا با متد strip() فاصله‌ها را از هر دو طرف حذف کنید:

1
2
3
4
5
6
7

>>> favorite_language = ' python '
>>> favorite_language.rstrip()
' python'
>>> favorite_language.lstrip()
'python '
>>> favorite_language.strip()
'python'

در خط ۱ از متغیّری شروع می‌کنیم که در ابتدا و انتهای آن فاصله وجود دارد. سپس در ۲ فاصله‌ی اضافه را سمت راست، در ۴ از سمت چپ و در۶ از هر دو طرف پاک می‌کنیم. تجربه‌ی کار با این متدها شما را نحوه‌ی دست‌کاری کردن رشته‌ها آشنا می‌کند. در دنیای واقعی از این متدها معمولاً برای تمیز کردن اطّلاعات ورودی کاربر پیش از ذخیره کردن آن‌ها استفاده می‌شود.

پرهیز از خطاهای نحوی هنگام کار با رشته‌ها

خطای نحوی از جمله ایراداتی است که معمولاً با آن برخورد می‌کنید. خطای نحوی هنگامی رخ می‌دهد که پایتون بخشی از برنامه‌ی شما را به عنوان کد معتبر پایتون تشخیص ندهد. برای مثال اگر از آپستروفی داخل علامت نقل تکّی استفاده کنید به خطا خواهید خورد. این اتّفاق به این دلیل می‌افتد که پایتون هر آن‌چه بین اوّلین علامت نقل قول و آپستروفی می‌بیند به عنوان یک رشته تعبیر می‌کند و پس از آن سعی می‌کند بقیه‌ی متن را به عنوان پایتون کد تفسیر کند و به مشکل می‌خورد.

اینجا نحوه‌ی صحیح استفاده از علائم نقل قول تکّی و دوتایی را می‌بینیم. برنامه را به نام apostrophe.py ذخیره و آن را اجرا کنید:

1
2

message = "One of Python's strengths is its diverse community."
print(message)

در اینجا آپستروفی بین یک جفت علامت نقل قول دوتایی ظاهرا شده و مفسّر پایتون بدون هیچ مشکلی آن را می‌خواند:

1

One of Python's strengths is its diverse community.

با این حال اگر از علامت نقل قول تکی استفاده کنید پایتون نمی‌تواند تشخیص دهد که رشته کجا پایان می‌یابد:

1
2

message = 'One of Python's strengths is its diverse community.'
print(message)

چنین خروجی‌ای را خواهید دید:

1
2
3
4

File "apostrophe.py", line 1
message = 'One of Python's strengths is its diverse community.' 
                        ^ 
      SyntaxError: invalid syntax

چنانچه در خروجی می‌بینید خطا در ۲ درست بعد از علامت نقل قول تکّی دوم رخ داده است. این خطای نحوی نشان می‌دهد که مفسّر بخشی از کد شما را کد معتبر پایتون نمی‌داند. خطاها ممکن است منشاهای مختلفی داشته باشند و موارد متداولِ آن‌ها هنگام برخوردن معرّفی خواهد شد. هنگامی که مشغول یادگیری برنامه‌نویسی پایتون هستید به خطاهای نحوی برخواهید خورد. خطاهای نحوی ناویژه‌ترین و نامشخّص‌ترین انواع خطا هستند در نتیجه تشخیص و اصلاح آن‌ها ممکن است سخت و خسته‌کننده باشد. اگر به خطای سمجی برخوردید توصیه‌های پیوست پ را ببینید.

خودآزمایی

هر کدام از این تمرین‌ها را در فایلی جداگانه با نامی مانند name_cases.py ذخیره کنید. اگر گیر کردید، کمی تامل کنید یا توصیه‌های پیوست پ را ببینید.

پیام شخصی

متغیّری برای نمایش نام یک شخص تعریف و پیامی خطاب به او چاپ کنید. پیام باید ساده باشد، مثل: “Hello Eric! would you like to learn some Python today?”

بزرگ و کوچک کردن حروف نام

متغیّری برای نمایش نام یک شخص در نظر بگیرید سپس نام او را با حروف بزرگ، کوچک و به صورت عنوان چاپ کنید.

نقل قول مشهور

نقل قولی از شخصی مشهور بیابید که مورد احترامتان باشد. نقل و قول و نام گوینده‌ی آن را چاپ کنید. پیام شما باید شامل علامت نقل قول و چیزی شبیه به این باشد: Albert Einstein once said, “A person who never made a mistake never tried anything new.”

نقل قول معروف ۲

تمرین ۲-۵ را تکرار کنید امّا این بار نام شخص معروف را با یک متغیّر نمایش دهید. سپس پیام خود را تولید کنید، آن را در یک متغیّر جدید به نام message ذخیره کنید و آن را چاپ کنید.

زدودن فاصله از نام‌ها

متغیّری برای نمایش نام یک فرد در نظر بگیرید و تعدادی فاصله‌ی خالی به ابتدا و انتهای آن اضافه کنید. از کاراکترهای ترکیبی\t و \n حداقل یک بار استفاده کنید.

یک بار نام را با حروف اضافه‌ی سر و ته آن چاپ کنید. سپس نام را با اعمال کردن توابع lstrip()، rstrip() و strip() چاپ کنید.

1.2.4 - عددها

اعداد در برنامه‌نویسی کاربردهای فراوانی دارند، از جمله برای نمایش امتیاز در بازی‌ها، بیان داده‌ها هنگام بصری‌سازی، ذخیره‌سازی اطّلاعات در نرم‌افزارهای وب و … . بسته به روشی که عدد مورد استفاده قرار می‌گیرد پایتون با آن برخوردی متفاوت دارد. ابتدا به نحوه‌ی مدیریت اعداد صحیح در پایتون می‌پردازیم زیرا ساده‌ترین نوع برای کار کردن هستند.

اعداد صحیح

در پایتون می‌توانید اعداد صحیح را جمع (+)، تفریق (-)، ضرب (*) یا تقسیم (/) کنید.

1
2
3
4
5
6
7
8

>>> 2 + 3
5
>>> 3 - 2
1
>>> 2 * 3
6
>>> 3 / 2
1.5

پایتون در نشست ترمینال به سادگی نتیجه‌ی عملیّات را نشان می‌دهد. برای به توان رساندن از دو علامت ضرب (**) استفاده می‌کنیم:

1
2
3
4
5
6

>>> 3 ** 2
9
>>> 3 ** 3
27
>>> 10 ** 6
1000000

پایتون ترتیب عملیّات را هم رعایت می‌کند پس می‌توانید چند عملیّات را در یک عبارت بگنجانید. همچنین می‌توانید از پرانتز برای تعیین تقدّم عملیّات استفاده کنید تا پایتون عبارت را با ترتیبی که شما می‌خواهید ارزیابی کند.

1
2
3
4

>>> 2 + 3*4
14
>>> (2 + 3) * 4
20

در پایتون فاصله‌گذاری تاثیری بر نحوه‌ی ارزیابی عبارت ندارد و تنها هنگام خواندن کد کمک می‌کند تا عبارت‌هایی را که اولویّت بیشتری دارد سریع‌تر پیدا کنید.

اعداد اعشاری

پایتون هر عدد ممیزدار را به عنوان ممیز شناور (float) می‌شناسد. این اصطلاح در بسیاری از زبان‌های برنامه‌نویسی به کار می‌رود زیرا به این حقیقت که ممیز می‌تواند در هر جای عدد ظاهر شود (=شناور باشد) دلالت دارد. هر زبان برنامه‌نویسی باید برای مدیریت صحیح اعداد اعشاری به دقّت طرّاحی شود تا صرف نظر از محل قرارگیری ممیّز رفتار آن عدد درست باشد.

در بیشتر موارد بدون نگرانی از عملکرد اعداد اعشاری می‌توانید از آن‌ها استفاده کنید. اعداد مورد نظر خود را به راحتی وارد کنید. پایتون به احتمال فراوان همانگونه که انتظار دارید رفتار خواهد کرد:

1
2
3
4
5
6
7
8

>>> 0.1 + 0.1
0.2
>>> 0.2 + 0.2
0.4
>>> 2 * 0.1
0.2
>>> 2 * 0.2
0.4

امّا متوجّه باشید که گاهی در پاسخ خود ارقامی با تعداد نامشخّص در بخش اعشاری خواهید دید:

1
2
3
4
5

>>> 0.2 + 0.1
0.30000000000000004
>>> 3 * 0.1
0.30000000000000004

این اتفاّق در تمام زبان‌های برنامه‌نویسی می‌افتد و نگرانی چندانی در پی ندارد. پایتون برای یافتن راهی جهت نمایش هر چه دقیق‌تر نتیجه تلاش می‌کند امّا این راه ممکن است به سادگی یافت نشود زیرا چگونگی نمایش داخلی اعداد در رایانه‌ها بر آن تاثیر می‌گذارد. فعلاً کافی‌ست که اعشار اضافی را در نظر نگیرید. هنگامی که در پروژه‌های بخش دوم کتاب به مدیریّت این بخش‌های اعشاری اضافی نیاز داشتیم، این کار را خواهید آموخت.

اعداد صحیح و اعشاری

هنگام تقسیمِ دو عدد صحیح و بخش‌پذیر که حاصل آن نیز عددی صحیح است، به عددی اعشاری برخواهید خورد:

1
2

>>> 4/2
2.0

همچنین اگر در هر عملیّاتی یک عدد صحیح و اعشاری را ترکیب کنید، حاصل اعشاری خواهد بود:

1
2
3
4
5
6

>>> 1 + 2.0
3.0
>>> 2 * 3.0
6.0
>>> 3.0 ** 2
9.0

پیش‌فرض پایتون در هر عملیّات عددی عدد اعشاری است، حتّی اگر خروجی عملیّات عددی صحیح باشد.

زیرخط در اعداد

هنگام نوشتن اعداد بزرگ می‌توانید به کمک زیرخط رقم‌های آن را دسته‌بندی کنید تا این اعداد خواناتر شوند:

1

>>> universe_age = 14_000_000_000

هنگام چاپ اعدادی که با زیرخط تعریف شده‌اند پایتون تنها رقم‌ها را نمایش می‌دهد:

1
2

>>> print(universe_age)
14000000000

پایتون هنگام ذخیره کردن این مقادیر زیرخط را نادیده می‌گیرد. حتّی اگر ارقام را در دسته‌های سه‌تایی قرار ندهید، باز هم مقدار تغییر نمی‌کند. برای پایتون 1000 با 1_000 یا 10_00 تفاوتی ندارد. این ویژگی در اعداد صحیح و اعشاری قابل استفاده است امّا تنها در پایتون ۳.۶ و بعد از آن در دسترس است.

انتساب چندگانه

می‌توانید بیشتر از یک متغیّر را تنها در یک خط مقداردهی کنید. این کار برنامه‌ها را کوتاه‌تر و خواندن آن‌ها را ساده‌تر می‌کند. هنگام مقداردهی اولیّه‌ی مجموعه‌ای از اعداد از این روش به مراتب استفاده خواهید کرد.

برای مثال اینجا سه متغیّر x، y و z را با صفر مقدارهای اولیّه می‌کنیم:

1

>>> x, y, z = 0, 0, 0

باید نام متغیّرها و همچنین مقدار آن‌ها را با کاما از یکدیگر جدا کنید. پایتون هر مقدار را به متغیّر متناظرش منسوب خواهد کرد. تا زمانی که تعداد مقادیر با تعداد متغیّرها برابر باشد، پایتون آن‌ها را به درستی با هم جور می‌کند.

ثابت‌ها

ثابت به متغیّری گفته می‌شود که مقدار آن در طول عمر یک برنامه تغییر نمی‌کند. پایتون نوع ثابت داخلی و پیش‌ساخته ندارد امّا برنامه‌نویسان برای متغیّرهایی که ثابت در نظر گرفته می‌شوند و مقدار آن‌ها هرگز تغییر نمی‌کند، از نام‌گذاری با حروف بزرگ استفاده می‌کنند:

1

MAX_CONNECTIONS = 5000

اگر می‌خواهید در برنامه‌ی خود با متغیّری مثل یک ثابت برخورد کنید نام آن را با تماماً با حروف بزرگ بنویسید.

خودآزمایی

عدد هشت

چهار عملیّات جمع، تفریق، ضرب و تقسیم بنویسید که حاصل همه‌ی آن‌ها عدد ۸ شود. مطمئن شوید که عملیّات را داخل print() قرار می‌دهید تا نتیجه‌ی آن را ببینید. باید چهار خط مانند زیر بنویسید:

1

print(5+3)

خروجی چهار خط را به سادگی نمایش می‌دهد که در هر کدام عدد ۸ نمایش داده شده است.

عدد موردعلاقه

متغیّری برای نمایش عدد مورد علاقه‌ی خود تعریف کنید. سپس با استفاده از این متغیّر پیامی تولید و چاپ کنید که عدد مورد علاقه‌ی شما را فاش می‌کند.

1.2.5 - توضیحات

افزودن توضیح (یا کامنت) به برنامه در بسیاری از زبان‌های برنامه‌نویسی بسیار سودمند است. تا کنون هر چه در برنامه‌های خود نوشته‌اید کد پایتون بوده است. هر چه برنامه بزرگ‌تر و پیچیده‌تر می‌شود، باید توضیحاتی به آن اضافه کنید تا رویکرد کلّی شما را برای حل مساله‌ای که در حال حل آن هستید، بیان کند. توضیح در برنامه‌های شما چنین کاربردی دارد و می‌توانید توضیحاتی به زبان انگلیسی به برنامه‌ی خود اضافه کنید.

چگونه یک توضیح بنویسیم؟

علامت هَش (#) در پایتون نمایان‌گر یک توضیح است. مفسّر پایتون هر آن‌چه را پس از این علامت بیاید نادیده می‌گیرد. برای مثال:

1
2

# Say hello to everyone.
print("Hello Python people!")

پایتون از خط اوّل می‌گذرد و دومی را اجرا می‌کند:

1

Hello Python people!

چه‌جور توضیحی باید به برنامه اضافه کنید؟

دلیل اصلی اضافه کردن توضیحات به برنامه این است که مقصود آن توضیح داده و بگویید که چگونه آن را به کار انداخته‌اید‌. هنگامی که شما در جریانِ انجام یک پروژه هستید می‌دانید که اجزای مختلف چگونه با هم جفت شده‌اند. امّا هنگامی که پس از گذشت مدت زمانی به پروژه برمی‌گردید به احتمال زیاد برخی از جزئیات را فراموش کرده‌اید. هرچند همیشه می‌توانید کد خود را بررسی کنید و بفهمید که قسمت‌های مختلف آن چگونه کار می‌کرده‌اند، امّا با نوشتن توضیحات مناسب و خلاصه کردن رویکرد کلّی خود به زبان ساده، در زمان صرفه‌جویی می‌کنید.

اگر می‌خواهید به برنامه‌نویسی حرفه‌ای تبدیل شوید و یا با برنامه‌نویسان دیگر همکاری کنید باید توضیحات معنادار بنویسید. امروزه بیشتر نرم‌افزارها را یا گروهی از برنامه‌نویسان در یک شرکت یا گروهی از مردم در قالب یک پروژه‌ی متن‌باز به صورت مشارکتی می‌نویسند. برنامه‌نویسان باتجربه انتظار دیدن توضیحات در کد دارند پس بهتر است از همین الان نوشتن توضیحات گویا در برنامه‌های خود را آغاز کنید. نوشتن توضیحات واضح و شفّاف در کد یکی از سودمندترین عادت‌هایی است که به عنوان یک برنامه‌نویس جدید می‌توانید پیدا کنید.

پیش از تصمیم‌گیری برای نوشتن یک توضیح به این فکر کنید که آیا برای رسیدن به جواب رویکردهای مختلفی را در نظر گرفته‌اید یا نه. اگر این چنین است توضیحی درباره‌ی راه‌حل خود بنویسید. این که بعداً چند توضیح اضافی را پاک کنید بسیار ساده‌تر از اضافه کردن توضیح به کدی است که به خوبی شرح داده نشده است. از الان به بعد از توضیحات در مثال‌ها استفاده خواهد شد تا بخش‌های مختلف کد توضیح داده شود.

خودآزمایی

اضافه کردن توضیح

از بین برنامه‌هایی که نوشته‌اید دو تا را انتخاب کنید و به هر کدام حداقل یک توضیح اضافه کنید. اگر به دلیل سادگی برنامه‌ها توضیحی برای افزودن نمی‌یابید صرفاً اسم و تاریخ نوشتن کد را بالای برنامه اضافه کنید. سپس یک جمله در مورد هدف برنامه اضافه کنید.

1.2.6 - ذنِ پایتون

برنامه‌نویسان باتجربه‌ی پایتون همواره شما را به پرهیز از پیچیدگی و در پی گرفتن سادگی، هر جا که ممکن باشد، تشویق می‌کنند. فلسفه‌ی جامعه‌ی پایتون در “The Zen of Python” اثر Tom Peters شرح داده شده است. با وارد کردن import this در مفسّر پایتون خود می‌توانید این مجموعه‌ی خلاصه‌ از اصول نوشتن کد پایتون خوب را پیدا کنید. کل Zen of Python را اینجا نمایش نداده‌ایم امّا برای کمک به درک اهمّیّت آن به عنوان برنامه‌نویس تازه‌کار پایتون چند خط از آن را می‌آوریم.

1
2
3

>>> import this
The Zen of Python, by Tim Peters
Beautiful is better than ugly.

برنامه‌نویسان پایتون این نکته را پذیرفته‌اند که کد می‌تواند زیبا و ظریف باشد. افراد با برنامه‌نویسی مسائل را حل می‌کنند. برنامه‌نویسان همواره راه‌حل‌های بهینه، خوش‌ساخت و حتّی زیبا را ستوده‌اند. همان‌طور که پایتون را فرامی‌گیرید و از آن برای نوشتن برنامه‌های بیشتری استفاده می‌کنید، ممکن است روزی کسی روی شانه‌های شما بایستد و بگوید: «عجب کد زیبایی!»

1

Simple is better than complex.

اگر بین یک راه‌حل ساده و یک راه‌حل پیچیده مخیّر بودید و هر دو کار می‌کرد، ساده را انتخاب کنید. نگهداری از کد شما راحت‌تر و استفاده از آن برای ایجاد برنامه‌های دیگر ساده‌تر خواهد بود.

1

Complex is better than complicated.

زندگی واقعی سخت و درهم‌ریخته است و ممکن است راه‌حلی ساده برای یک مساله دست‌نیافتنی باشد. در چنین حالتی ساده‌ترین راه‌حلی را به کار بگیرید که جواب می‌دهد.

1

Readability counts.

حتّی اگر کد شما پیچیده است تلاش کنید آن را خوانا نگه دارید. زمانی که روی پروژه‌ای با برنامه‌های پیچیده کار می‌کنید بر روی نوشتن توضیحات پرمعنی تمرکز کنید.

1

There should be one-- and preferably only one --obvious way to do it.

اگر از دو برنامه‌نویس پایتون بخوانید که مساله‌ای مشابه را حل کنند، نتیجه‌ای که می‌گیرند باید تا حدود زیادی به یکدیگر بخورد. این به معنی تهی بودن برنامه‌نویسی از ابتکار و خلّاقیّت نیست. درست برعکس! امّا برنامه‌نویسی بیشتر استفاده از رویکردهای ساده و مشترک برای رسیدن به شرایطی ساده در یک پروژه ی بزرگتر است. پیچ و مهره‌ی برنامه‌های شما باید برای دیگر برنامه‌نویسان پایتون قابل فهم و استفاده باشد.

1

Now is better than never.

می‌توانید باقی عمر خود را به آموختن ریزه‌کاری‌های پایتون و در حالت کلی برنامه‌نویسی بپردازید امّا با این وضع هرگز هیچ پروژه‌ای را به پایان نخواهید رساند. تلاش نکنید که عالی‌ترین کد را بنویسید، بلکه کدی بنویسید که کار کند و سپس تصمیم بگیرید که آیا این کد نیاز به بهبود دارد یا باید آن را رها کرد و به چیز جدیدی پرداخت.

همچنان که به فصل بعدی می‌روید و پرداختن به موضوعات پیچیده‌تر را شروع می کنید این فلسفه‌ی سادگی و شفافیّت را در ذهن داشته باشید.

برنامه‌نویسان مجرّب کد شما را خواهند پسندید، با کمال میل به شما بازخورد خواهند داد و در پروژه‌های جذّاب با شما همکاری خواهند کرد.

خودآزمایی

ذن پایتون

import this را در یک ترمینال پایتون وارد کنید و باقی اصول را مرور کنید.

1.2.7 - خلاصه

در این فصل کار کردن با متغیّرها را آموختید. آموختید که چگونه نام بامعنا برای متغیّرها برگزینید و هنگام برخوردن به خطاهای نحوی و نام‌‌گذاری چه‌ کنید. یاد گرفتید که رشته‌ها چه هستند و چگونه آن‌ها را با حروف کوچک، بزرگ و در حالت عنوان نمایش دهید. به‌کارگیری فاصله را برای مرتب کردن خروجی‌ها و طرز حذف کردن فاصله‌های اضافی را از قسمت‌های مختلف یک رشته آغاز کردید. کار کردن با اعداد صحیح و اعشاری را شروع کردید و کمی با داده‌های عددی کار کردید. همچنین نوشتن توضیحات گویا را برای افزایش خوانایی کد خود آموختید. در پایان در مورد فلسفه‌ی ساده‌ نگه‌داشتن کد تا جای ممکن، هر جا که میسّر داشت، مطالعه کردید.

در فصل ۳ ذخیره کردن مجموعه‌ای از اطّلاعات را در ساختمان داده‌ای به نام لیست خواهید آموخت و کار کردن با لیست و تغییر دادن اطّلاعات داخل آن را یاد خواهید گرفت.

1.3 - معرّفی لیست‌ها

در این فصل و فصل بعد ابتدا خواهید آموخت که لیست‌ها چه هستند و سپس کار کردن با اعضای آن‌ها را آغاز می‌کنید. لیست‌ها امکان ذخیره‌سازی مجموعه‌ای از اطّلاعات (چه به تعداد کم چه میلیون‌ها عدد) را در یک مکان فراهم می‌آورند. لیست‌ها یکی از قدرتمندترین ویژگی‌های پایتون هستند که در اختیار برنامه‌نویسان تازه‌کار قرار گرفته و بسیاری از مفاهیم مهم برنامه‌نویسی را به یکدیگر پیوند می‌دهند.

1.3.1 - لیست چیست؟

لیست مجموعه‌ای از عناصر با ترتیبی مشخّص است. می‌توانید لیستی شامل حروف الفبا، اعداد ۰ تا ۹ یا نام تمام افراد خانواده‌ی خود درست کنید. شما می‌توانید هرچه بخواهید درون یک لیست قرار دهید و عناصر داخل لیست الزاماً ارتباطی با یکدیگر ندارند. از آنجایی‌که هر لیست معمولاً بیش از یک عضو دارد بهتر است آن را به صورت جمع نام‌گذاری کنید، مانند letters، digits یا names.

در پایتون از کروشه ( [] ) برای نمایش یک لیست استفاده می‌شود و اعضای داخل آن با کمک کاما از یکدیگر جدا می‌شوند. اینجا مثالی از یک لیست شامل نام چند نوع دوچرخه آورده می‌شود:

1
2

bicycles = ['trek', 'cannondale', 'redline', 'specialized']
print(bicycles)

اگر از پایتون بخواهید که این لیست را چاپ کند، آن را به روش خاص خود، با کروشه، نمایش می‌دهد:

1

['trek', 'cannondale', 'redline', 'specialized']

از آن‌جایی‌که این خروجی برای نمایش به کاربران مطلوب نیست، روش دسترسی به تک تک اعضای لیست را در ادامه می‌بینیم.

دسترسی به اعضای لیست

لیست‌ها مجموعه‌های مرتّب هستند پس با تعیین جایگاه، یا شاخص عنصرِ مورد نظر برای پایتون، دسترسی به اعضای آن‌ها ممکن است. برای دسترسی به یک عضو لیست، نام آن و پس از آن شاخص عضو در داخل کروشه را بنویسید.

برای مثال اوّلین نوع دوچرخه را از لیستِ bicycles بیرون می‌کشیم:

1
2

bicycles = ['trek', 'cannondale', 'redline', 'specialized']
print(bicycles[0])

روش کار در 2 نمایان است. زمانی که یک عنصر لیست را درخواست می‌کنیم، پایتون آن را بدون کروشه نمایش می‌دهد:

1

trek

این نتیجه‌ای است که انتظار دارید کاربران ببینند– خروجی تمیز و مرتّب.

همچنین می‌توانید متدهای مخصوص رشته‌ها در فصل ۲ را روی هر عضو لیست اعمال کنید. برای مثال می‌توان به کمک متد title() به عضو ’trek’ شکل بهتری داد:

1
2

bicycles = ['trek', 'cannondale', 'redline', 'specialized']
print(bicycles[0].title())

این مثال خروجی‌ای همانند مثال قبل تولید می‌کند، با این تفاوت که حرف اول آن را بزرگ می‌کند.

شماره‌گذاری شاخص‌ از ۰ شروع می‌شود نه ۱

پایتون اولین عضو یک لیست را در مکان صفرم در نظر می‌گیرد نه یکم. این مساله در بسیاری از زبان‌های برنامه‌نویسی صادق است و دلیل آن به روش پیاده‌سازی عملکرد لیست‌ها در سطوح پایین‌تر برنامه‌نویسی برمی‌گردد. اگر به نتایج نامعقولی می‌رسید بررسی کنید که آیا مرتکب خطای ساده‌ی یکی‌جابه‌جا شده‌اید یا نه.

دومین عضو لیست شاخص ۱ دارد. با استفاده از این روش شمارش می‌توانید هر عضوِ لیست را با کم کردن عدد ۱ از جایگاه واقعی آن در لیست پیدا کنید. برای مثال برای دسترسی به عضو چهارم لیست، شاخص ۳ را فراخوانی کنید.

مثال زیر نام دوچرخه‌ها را با شاخص‌های ۱ و ۳ درخواست می‌کند:

1
2
3

bicycles = ['trek', 'cannondale', 'redline', 'specialized']
print(bicycles[1])
print(bicycles[3])

این کد دوچرخه‌های دوم و چهارم را برمی‌گرداند:

1
2

cannondale
specialized

پایتون روش خاصی برای دسترسی به آخرین عضو لیست دارد. با فراخواندن عنصر ۱-ام، پایتون آخرین عضو لیست را برمی‌گرداند:

1
2

bicycles = ['trek', 'cannondale', 'redline', 'specialized']
print(bicycles[-1])

این کد مقدار ‘specialized’ را برمی‌گرداند. این روش بسیار سودمند است زیرا در بسیاری از موارد شما بدون اطّلاع از تعداد عضوهای لیست می‌خواهید به آخرین عضو دسترسی پیدا کنید. این قاعده را می‌توان به دیگر شاخص‌های منفی نیز گسترش داد: شاخص ۲- عضو دو تا مانده به آخر و ۳- سه تا مانده به آخر را برمی‌گرداند و … .

به‌کارگیری مقادیر اعضای یک لیست

می‌توانید از اعضای یک لیست به صورت جداگانه درست همانند هر متغیّر دیگری استفاده کنید. برای مثال به کمک f-string می‌توانید پیامی بر اساس یکی از عضو‌های لیست ساخت.

اکنون با بیرون کشیدن نام اوّلین دوچرخه و به کمک مقدار آن پیامی تولید می‌کنیم:

1
2
3

bicycles = ['trek', 'cannondale', 'redline', 'specialized']
message = f"My first bicycle was a {bicycles[0].title()}."
print(message)

در خط 2 جمله‌ای به کمک مقدار bicycles[0] ساخته و آن را به متغیّر message نسبت دادیم. خروجی کد جمله‌ای ساده در مورد اوّلین دوچرخه‌ی لیست است:

1

My first bicycle was a Trek.

خودآزمایی

برای کسب تجربه‌ی کار کردن مستقیم با لیست‌های پایتون برنامه‌های کوتاه زیر را بنویسید. بهتر است برای مرتب نگه‌داشتن تمرین‌های هر فصل پوشه‌ای جداگانه برای هر یک بسازید .

نام‌ها

نام چند تن از دوستان خود را در لیستی به نام names ذخیره کنید. نام هر کدام از افراد را یک به یک با فراخواندن هر عضو لیست چاپ کنید.

تبریک

تمرین ۳-۱ را تکرار کنید امّا این دفعه به جای چاپ کردن اسم‌ها به تنهایی، پیامی خطاب به آن‌ها بنویسید. متن هر پیام باید یکسان باشد امّا پیام باید برای هر کس شخصی‌شده باشد.

لیست شخصی

روش حمل و نقل مطلوب خود (موتورسیکلت، ماشین یا …) را در نظر بگیرید، لیستی شامل چند نمونه از آن‌ها درست کنید و عبارت‌هایی در مورد اعضای این لیست چاپ کنید، مثلاً “I would like to own a Honda motorcycle”.

1.3.2 - تغییر دادن، افزودن و حذف کردن عضوها

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

تغییر دادن اعضای لیست

دستور تغییر دادن یک عضو شبیه به دستور دسترسی به عضوهای لیست است. برای تغییر یک عضو باید نام لیست را به همراه شاخص عضوی که می‌خواهید تغییر دهید بنویسید و سپس مقدار جدید را به آن نسبت دهید.

برای مثال فرض کنید لیستی از انواع موتورسیکلت داریم می‌خواهیم اوّلین عضو آن که ‘honda’ است تغییر دهیم. چگونه می‌توانیم این کار را انجام دهیم؟

1
2
3
4

motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles)
motorcycles[0] = 'ducati'
print(motorcycles)

کد خط 1 لیست اولیّه و ‘honda’ را به عنوان اوّلین عضو آن تعریف می‌کند. خط 3 مقدار اوّلین عضو را به ‘ducati’ تغییر می‌دهد. خروجی تغییر اوّلین عضو و دست‌نخورده‌مانده ماندن باقی اعضا را نشان می‌دهد:

1
2

['honda', 'yamaha', 'suzuki']
['ducati', 'yamaha', 'suzuki']

نه فقط اوّلین عضو بلکه تمام اعضای یک لیست را می‌توان تغییر داد.

افزودن عضو به لیست

ممکن است به دلایل مختلف بخواهید عضو جدیدی به یک لیست بیفزایید. برای مثال شاید بخواهید یک موجود بیگانه‌ی جدید را به یک بازی، داده‌ای جدید را برای بصری‌سازی یا عضو ثبت‌نام‌شده‌ی جدیدی را به یک وبسایت اضافه کنید. پایتون چندین روش برای افزودن داده‌ی جدید به لیست‌های موجود فراهم آورده است.

الحاق کردن اعضا به انتهای یک لیست

ساده‌ترین روش برای افزودن یک عضو الحاق کردن آن به لیست است. با این کار عضو به انتهای لیست اضافه می‌شود. با استفاده از لیستی که در مثال قبل ساختیم، یک عضو جدید به نام ‘ducati’ به انتهای آن اضافه می‌کنیم:

1
2
3
4

motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles)
motorcycles.append('ducati')
print(motorcycles)

متد append() در خط 3 ‘ducati’ را بدون اثر گذاشتن بر دیگر اعضا، به لیست اضافه می‌کند:

1
2

['honda', 'yamaha', 'suzuki']
['honda', 'yamaha', 'suzuki', 'ducati']

متد append() ساختن لیست‌ها به روش پویا را ساده می‌کند. برای مثال می‌توانید یک لیست خالی ایجاد کنید و سپس اعضا را یک به یک به آن بیفزایید. اکنون عضوهای ‘honda’، ‘yamaha’ و ‘suzuki’ را به یک لیست خالی اضافه می‌کنیم:

1
2
3
4
5

motorcycles = []
motorcycles.append('honda')
motorcycles.append('yamaha')
motorcycles.append('suzuki')
print(motorcycles)

نتیجه‌ عیناً مشابه لیست‌های مثال‌های قبلی است:

1

['honda', 'yamaha', 'suzuki']

ساختن لیست به این روش بسیار متداول است زیرا معمولاً تا پیش از اجرای برنامه نمی‌دانید که کاربران چه داده‌ای را می‌خواهند ذخیره کنند. برای این که اختیار را به دست کاربران بسپرید ابتدا یک لیست خالی تعریف کنید و سپس مقادیری را که وارد می‌کنند به آن اضافه کنید.

افزودن عضوها داخل لیست

می‌توانید به کمک متد insert() عضو جدیدی را به هر مکانی از لیست اضافه کنید. این کار با مشخّص کردن شاخص و مقدار عنصر جدید انجام می‌شود:

1
2
3

motorcycles = ['honda', 'yamaha', 'suzuki']
motorcycles.insert(0, 'ducati')
print(motorcycles)

در این مثال کد خط 2 مقدار ‘ducati’ را به ابتدای لیست اضافه می‌کند. متد insert() در مکان صفرم فضایی خالی ایجاد می‌کند و مقدار ‘ducati’ را در آن ذخیره می‌کند. این عمل مکان تمام مقادیر دیگر را یکی به راست منتقل می‌کند:

1

['ducati', 'honda', 'yamaha', 'suzuki']

حذف کردن عضوی از لیست

گاهی می‌خواهید که یک عضو یا اعضایی را از یک لیست حذف کنید. برای مثال زمانی که بازیکن یک موجود بیگانه را مورد هدف قرار داده و نابود می‌کند، احتمالاً می‌خواهید نام آن موجود را از لیست موجودات فعّال حذف کنید. یا هنگامی که کاربری تصمیم می‌گیرد عضویّت خود را در برنامه‌ی وبی که ساخته‌اید حذف کند، می‌خواهید آن کاربر را از لیست کاربران فعّال حذف کنید. شما می‌توانید یک عضو را بر اساس جایگاه یا بر اساس مقدار آن حذف کنید.

حذف کردن یک عضو به کمک عبارت del

اگر مکان عضوی را که می‌خواهید حذف کنید از پیش می‌دانید، می‌توانید از عبارت del استفاده کنید.

1
2
3
4

motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles)
del motorcycles[0]
print(motorcycles)

کد خط 3 از del برای حذف کردن اوّلین عنصر، ‘honda’، از لیست موتورسیکلت‌ها استفاده می‌کند:

1
2

['honda', 'yamaha', 'suzuki']
['yamaha', 'suzuki']

به کمک del می‌توانید هر عضو لیست را در هر مکانی پاک کنید به شرطی که شاخص آن را بدانید. برای مثال اینجا دومین عضو لیست، ‘yahama’، را حذف می‌کنیم:

1
2
3
4

motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles)
del motorcycles[1]
print(motorcycles)

دومین موتورسیکلت از لیست حذف می‌شود:

1
2

['honda', 'yamaha', 'suzuki']
['honda', 'suzuki']

در هر دو مثال، پس از به کارگیری del و حذف شدن عضو، دیگر به مقدار آن دسترسی نخواهید داشت.

حذف کردن یک عنصر به کمک متد pop()

گاهی اوقات پس از حذف کردن یک عضو از لیست به مقدار آن نیاز دارید. مثلاً شاید برای نمایش انفجار روی صفحه‌ی بازی، موقعیّت x و y موجود بیگانه‌ای را که از بین رفته نیاز داشته باشید. یا در برنامه‌ی وب ممکن است بخواهید نام کاربر حذف‌شده را از لیست کاربران فعّال کم کرده و به لیست کاربران غیرفعّال اضافه کنید.

متد pop() آخرین عضو یک لیست را حذف می‌کند امّا اجازه می‌دهد با مقدار حذف شده پس از حذف کار کنید. عبارت pop حاصل نگاه کردن به لیست به عنوان یک پشته و برداشتن بالاترین عضو آن است. در این همانندسازیْ بالای پشته همان انتهای لیست است.

حال آخرین حذف لیست موتورسیکلت‌ها را برمی‌داریم:

1
2
3
4
5

motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles)
popped_motorcycle = motorcycles.pop()
print(motorcycles)
print(popped_motorcycle)

در خط 1 لیست motorcycles را تعریف می‌کنیم. در خط 3 مقداری را از انتهای لیست برداشته و در متغیّری به نام popped_motorcycle ذخیره می‌کنیم. در 4 لیست را چاپ می‌کنیم تا ببینیم که این عضو از آن حذف شده است یا نه. در 5 با چاپ مقدار برداشته شده اطمینان حاصل می‌کنیم که همچنان به مقدار آن دسترسی داریم.

خروجی نشان می‌دهد که مقدار ‘suzuki’ از انتهای لیست حذف شده و در متغیّری به نام popped_variable ذخیره شده است:

1
2
3

['honda', 'yamaha', 'suzuki']
['honda', 'yamaha']
suzuki

متد pop() کی سودمند است؟ فرض کنید که موتورسیکلت‌ها به ترتیبِ تاریخِ خریده شدن در لیست ذخیره شده‌اند. در این مورد می‌توانید از متد pop() جمله‌ای در مورد آخرین موتورسیکلتی که خریده‌ایم چاپ کنیم:

1
2
3

motorcycles = ['honda', 'yamaha', 'suzuki']
last_owned = motorcycles.pop()
print(f"The last motorcycle I owned was a {last_owned.title()}.")

خروج جمله‌ای ساده درباره‌ی آخرین موتورسیکلتی‌ست که صاحب شده‌ایم:

1

The last motorcycle I owned was a Suzuki.

خارج کردن عضو از هرجای لیست

می‌توانید با قرار دادن شاخص عضو در داخلِ پرانتزهای pop()، از این متد برای خارج کردن هر عضوی از هرجای لیست استفاده کنید.

1
2
3

motorcycles = ['honda', 'yamaha', 'suzuki']
first_owned = motorcycles.pop(0)
print(f"The first motorcycle I owned was a {first_owned.title()}.")

ابتدا در 2 موتور سیکلت اول را از لیست برمی‌داریم و سپس پیامی در مورد آن در 3 چاپ می‌کنیم. خروجی درباره‌ی اوّلین موتورسیکلتی که داشته‌ام جمله‌ای ساده چاپ می‌کند:

1

The first motorcycle I owned was a Honda.

به خاطر داشته باشید که هر بار از pop() برای عضوی استفاده می‌کنید، آن را برای همیشه از لیست حذف می‌کنید.

اگر در بین به‌کارگیری del و pop() مردّد هستید راه ساده‌ای برای تصمیم‌گیری وجود دارد: هرگاه دیگر به هیچ‌عنوان به یک عضو احتیاج نداشتید و خواستید آن را حذف کنید از del استفاده کنید امّا اگر خواستید از مقدار آن پس از حذف شدن بهره بگیرید متد pop() را به کاربگیرید.

حذف کردن یک عضو بر اساس مقدار

گاهی مکان عضوی را که می‌خواهید حذف کنید نمی‌دانید. اگر می‌خواهید تنها با دانستن مقدار یک عضو آن را از حذف کنید می‌توانید از متد remove() استفاده کنید.

برای مثال فرض کنید می‌خواهیم مقدار ‘ducati’ را از لیست موتورسیکلت‌ها حذف کنیم:

1
2
3
4

motorcycles = ['honda', 'yamaha', 'suzuki', 'ducati']
print(motorcycles)
motorcycles.remove('ducati')
print(motorcycles)

خط 3 از پایتون می‌خواهد تا عضوی را با مقدار ‘ducati’ یافته و آن را حذف کند:

1
2

['honda', 'yamaha', 'suzuki', 'ducati']
['honda', 'yamaha', 'suzuki']

از متد remove() برای کار کردن با مقدارهای حذف‌شده نیز می‌توانید استفاده کنید. اکنون مقدار ‘ducati’ را حذف و جمله‌ای درباره‌ی علّت حذف شدن آن چاپ کنیم:

1
2
3
4
5
6

motorcycles = ['honda', 'yamaha', 'suzuki', 'ducati']
print(motorcycles)
too_expensive = 'ducati'
motorcycles.remove(too_expensive)
print(motorcycles)
print(f"\nA {too_expensive.title()} is too expensive for me.")

پس از تعریف لیست در 1، مقدار ‘ducati’ را در 3 به متغیّری به نام too_expensive منسوب کردیم. سپس در خط 4 از پایتون خواستیم که این مقدار را به کمک این متغیّر از لیست حذف کند. در خط 6 مقدار ‘ducati’ از لیست حذف شده امّا مقدار آن به کمک متغیّر too_expensive در دسترس است و می‌توانیم به کمک آن پیامی در مورد دلیل حذف شدن ‘ducati’ از لیست چاپ کنیم:

1
2
3

['honda', 'yamaha', 'suzuki', 'ducati']
['honda', 'yamaha', 'suzuki']
A Ducati is too expensive for me.

خودآزمایی

تمرین‌های زیر نسبت به فصل ۲ کمی پیچیده‌ترند امّا به شما این فرصت را می‌دهند تا از لیست‌ها به تمام روش‌هایی که توضیح داده شد استفاده کنید.

لیست مهمان

اگر بخواهید کسی را، خواه زنده یا مرده، برای شام دعوت کنید، چه کسی را انتخاب می‌کنید؟ لیستی شامل نام سه نفر از چنین افرادی درست کنید و به کمک آن خطاب به هر یک دعوت‌نامه‌ای چاپ کنید.

تغییر دادن لیست مهمانان

همین الان متوجه شدید که یکی از مهمان‌ها نمی‌تواند برای شام بیاید، در نتیجه به ارسال دعوت‌نامه‌های جدید نیاز پیدا کردید. باید کس دیگری را برای مهمانی پیدا کنید.

• از برنامه تمرین ۳-۴ شروع کنید.یک تابع print() اضافه کنید و در پایان برنامه نام شخصی را که نمی‌تواند به مهمانی بیاید چاپ کنید.
• لیست را تغییر دهید و نام کسی را که دعوت را نپذیرفته با نام مهمان جدید جایگزین کنید.
• دسته‌ی دوم دعوت‌نامه را برای هر یک از افرادی که هنوز در لیست هستند چاپ کنید.

مهمان‌های بیشتر

میز شام جدیدی پیدا کرده‌اید و اکنون جا برای مهمان‌های بیشتری باز شده است. سه فرد جدید برای دعوت کردن بیابید.

• از برنامه تمرین ۳-۴ یا ۳-۵ شروع کنید. یک تابع print() به انتهای برنامه بیفزایید و به همه اطّلاع دهید که میز شام بزرگتری پیدا کردید.
• با استفاده از insert() یک مهمان جدید به ابتدای لیست بیفزایید.
• به کمک insert() مهمانی جدید به میانه‌ی لیست اضافه کنید.
• از append() بهره بگیرید و مهمان جدید دیگری را به انتهای لیست اضافه کنید.
• یک دعوت‌نامه جدید برای هر یک از افراد حاضر در لیستِ خود چاپ کنید.

کوچک کردن لیست مهمان

مطّلع شده‌اید که میز شام جدید به موقع نمی‌رسد و تنها برای دو مهمان جا دارید.

• از برنامه ۳-۶ شروع کنید خط جدیدی به آن اضافه و پیامی چاپ کنید که تنها می‌توانید دو مهمان دعوت کنید.
• برای حذف کردن مهمان‌ها، چند بار از pop() استفاده کنید تا تنها دو مهمان در لیست باقی بماند. هر بار که نامی را از لیست حذف می‌کنید پیامی خطاب به آن فرد چاپ کنید و از او به دلیل مشکل پیش آمده عذر بخواهید.
• پیامی خطاب به دو مهمان باقی‌مانده در لیست چاپ کنید و به آن‌ها اطّلاع دهید که همچنان دعوت هستند.
• با استفاده از del دو نام باقیمانده را هم از لیست حذف کنید تا به یک لیست خالی برسید. لیست خود را چاپ کنید تا مطمئن شوید که در پایان برنامه‌ی خود یک لیست خالی باقیمانده است.

1.3.3 - سازماندهی یک لیست

گاهی لیست‌های شما با ترتیبی غیر قابل پیش‌بینی ساخته می‌شوند زیرا نمی‌توانید همواره ترتیبی را که کاربران بر اساسِ آن داده‌ها را وارد می‌کنند کنترل کنید. شما معمولاً می‌خواهید داده‌ها را با ترتیبی مشخّص نمایش دهید هرچند در بسیاری از شرایط عملاً مجبور به این کار هستید. گاهی می‌خواهید ترتیب اصلی داده‌ها را حفظ کنید و گاهی آن را تغییر می‌دهید. پایتون بسته به شرایط چند روش مختلف برای سازمان دادن به لیست‌ها ارائه می‌کند.

مرتّب کردن دائمی یک لیست به کمک sort()

متد sort() پایتون مرتّب کردن لیست‌ها را نسبتاً ساده می‌کند. فرض کنید لیستی از خودروها داریم و می‌خواهیم ترتیب لیست را تغییر بدهیم تا آن‌ها را به ترتیب حروف الفبا ذخیره کنیم. برای این که کار راحت‌تر باشد فرض کنید تمام مقادیر لیست با حروف کوچک نوشته شده‌اند.

1
2
3

cars = ['bmw', 'audi', 'toyota', 'subaru']
cars.sort()
print(cars)

متد sort() که در 2 نمایش داده شده ترتیب لیست را به صورت دائمی عوض می‌کند. خودروها اکنون دیگر به ترتیب الفبایی هستند و نمی‌توانیم آن‌ها را به ترتیب اولیّه برگردانیم:

1

['audi', 'bmw', 'subaru', 'toyota']

برای مرتّب کردن به ترتیب عکس (از حروف بزرگ به کوچک) می‌توانید نشانوند reverse=True را به متد sort() بدهید. این مثال لیست خودروها را به ترتیب الفبایی معکوس مرتّب می‌کند:

1
2
3

cars = ['bmw', 'audi', 'toyota', 'subaru']
cars.sort(reverse=True)
print(cars)

ترتیب لیست مجدداً به طور دائمی تغییر یافته است:

1

['toyota', 'subaru', 'bmw', 'audi']

مرتّب کردن موقّت یک لیست به کمک تابع sorted()

برای حفظ کردن ترتیب اصلی لیست یا تنها نمایش دادن آن با ترتیبی مشخّص، می‌توانید از تابع sorted() استفاده کنید. این تابع کمک می‌کند که لیست را با ترتیبی خاص صرفاً نمایش دهید امّا بر ترتیب اصلی آن تاثیری نمی‌گذارد.

حال این تابع را بر روی لیست خودروها اعمال می‌کنیم:

1
2
3
4
5
6
7

cars = ['bmw', 'audi', 'toyota', 'subaru']
print("Here is the original list:")
print(cars)
print("\nHere is the sorted list:")
print(sorted(cars))
print("\nHere is the original list again:")
print(cars)

ابتدا در2 لیست را با ترتیب اصلی و سپس در 4 به ترتیب حروف الفبا چاپ می‌کنیم. پس از نمایش لیست مرتّب، در ۳ نشان می‌دهیم که ترتیب اصلی لیست دست‌نخورده باقی مانده است.(6)

1
2
3
4
5
6
7
8

Here is the original list:
['bmw', 'audi', 'toyota', 'subaru']

Here is the sorted list:
['audi', 'bmw', 'subaru', 'toyota']

Here is the original list again:
['bmw', 'audi', 'toyota', 'subaru']

دقّت کنید که در 5 و پس از به‌کارگیری تابع sorted() لیست همچنان به ترتیب اصلی خود باقیمانده است. تابع sorted() نیز نشان‌وند reverse=True را برای مرتّب کردن معکوس الفبایی می‌پذیرد.

چاپ کردن لیست با ترتیب معکوس

برای عکس کردن ترتیب اصلی یک لیست می‌توانید از متد reverse() استفاده کنید. اگر از ابتدا لیست خودروها را به ترتیب زمانِ خریدن مرتّب کرده باشیم، می‌توانیم به سادگی لیست را به ترتیبِ زمانیِ معکوس بازآرایی کنیم:

1
2
3
4

cars = ['bmw', 'audi', 'toyota', 'subaru']
print(cars)
cars.reverse()
print(cars)

توجّه داشته باشید که reverse() اعضا را به ترتیب عکسِ حروفِ الفبا مرتّب نمی‌کند بلکه تنها به سادگی ترتیب آن‌ها را عکس می‌کند:

1
2

['bmw', 'audi', 'toyota', 'subaru']
['subaru', 'toyota', 'audi', 'bmw']

متد reverse() ترتیب لیست را به طور دائم عوض می‌کند امّا می‌توانید با اعمال دوباره‌ی آن، لیست را به ترتیب اصلی آن برگردانید.

یافتن طول یک لیست

طول یک لیست را می‌توان به سرعت به کمک تابع len() یافت. لیستِ این مثال چهار عضو دارد پس طول آن ۴ است:

1
2
3

>>> cars = ['bmw', 'audi', 'toyota', 'subaru']
>>> len(cars)
4

استفاده از len() هنگامی سودمند است که بخواهید تعیین کنید در بازی چند موجود بیگانه برای کشتن باقیمانده است، تعداد داده‌هایی که برای بصری‌سازی با مدیریت شوند کدام است یا تعداد کاربران ثبت نام کرده در وبسایت چندتاست.

خودآزمایی

تماشای جهان

به پنج نقطه از جهان فکر کنید که دوست دارید آن‌ها از نزدیک ببینید.

• این مکان‌ها را در لیستی ذخیره کنید. مطمئن شوید که ترتیب ذخیره الفبایی نباشد.
• لیست را با ترتیب اصلی چاپ کنید. نگران چاپ کردن تمیز و منظم نباشید و لیست را به صورت یک لیست خام پایتون چاپ کنید.
• از sorted() برای چاپ لیست به ترتیب الفبایی و بدون دست خوردن آن استفاده کنید.
• نشان دهید که لیست شما همچنان با ترتیب اصلی ذخیره شده است.
• از sorted() برای مرتّب‌سازی الفبایی معکوس بدون دست زدن به ترتیب لیست اصلی استفاده کنید.
• نشان دهید که لیست شما همچنان با ترتیب اصلی ذخیره شده است.
• از reverse() برای معکوس کردن ترتیب اعضای لیست استفاده کنید. آن را چاپ کنید تا نشان دهید که ترتیب عوض شده است.
• دوباره از reverse() برای معکوس کردن لیست استفاده کنید. نشان دهید که لیست به ترتیب اصلی خود برگشته است.
• از sort() برای مرتب کردن لیست به ترتیب الفبا استفاده کنید.آن را چاپ کنید تا نشان دهید ترتیب عوض شده است.
• از sort() برای مرتب کردن لیست به ترتیب الفبایی معکوس استفاده کنید. آن را چاپ کنید تا نشان دهید ترتیب عوض شده است.

مهمان‌های شام

با کار بر روی یکی از تمرین‌های ۳-۴ تا ۳-۷ در صفحه‌ی ***، به کمک len() پیامی چاپ کنید که تعداد افراد دعوت‌شده را نمایش دهد.

تمام تابع‌ها

به چیزی که بتوان آن را در لیستی ذخیره کرد فکر کنید. برای مثال فهرست کوه‌ها، رودخانه‌ها، کشورها، زبان‌ها یا هر چیزی که دوست دارید. برنامه‌ای بنویسید که لیستی شامل این موارد ایجاد کند و تمام توابعی را که در این فصل آموخته‌اید یک بار روی آن اعمال کنید.

1.3.4 - پرهیز از خطای شاخص هنگام کار کردن با لیست‌ها

هنگامی که برای اولین بار با لیست‌ها کار می‌کنید عموماً به نوعی خطا برمی‌خورید. فرض کنید لیستی شامل سه عضو داریم و عضو چهارم آن را فرامی‌خوانیم:

1
2

motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles[3])

این مثال به خطای شاخص منجر می‌شود:

1
2
3
4

Traceback (most recent call last):
File "motorcycles.py", line 2, in <module>
print(motorcycles[3])
IndexError: list index out of range

پایتون برای یافتن عنصری با شاخص ۳ تلاش می‌کند امّا پس از جستجو عضوی با این شماره پیدا نمی‌کند. به دلیل ماهیت یکی‌جابه‌جای شماره‌گذاری در لیست‌ها این خطا متداول است. همه فکر می‌کنند که شماره‌ی سومین عضو ۳ است زیر شمارش را از ۱ شروع می‌کنند. امّا پایتون شاخص سومین عضو را ۲ می‌پندارد زیرا شمارش را از ۰ شروع می‌کند.

خطای شاخص به این معنی است که پایتون نمی‌تواند عضوی با شاخصی که معلوم کرده‌اید پیدا کند. اگر در برنامه‌تان به این خطا برخوردید شاخص را یکی جابه‌جا کنید. برنامه را مجدداً اجرا کنید و ببینید آیا نتایج درست است یا نه.

به خاطر داشته باشید که همیشه می‌توانید با به‌کارگیری شاخص ۱- به آخرین عضو لیست دسترسی پیدا کنید. این مورد همیشه کار می‌کند حتّی اگر طول لیست شما از آخرین باری که به آن دسترسی داشته‌اید تغییر کرده باشد:

1
2

motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles[-1])

شاخص ۱- همیشه آخرین عضو لیست را برمی‌گرداند که در این مورد مقدار ‘suzuki’ است:

1

suzuki

تنها زمانی این رویکرد به خطا می‌خورد که آخرین عضو یک لیست تهی را درخواست کنید:

1
2

motorcycles = []
print(motorcycles[-1])

motorcycles هیچ عضوی ندارد پس پایتون خطای شاخص دیگری برمی‌گرداند:

1
2
3
4

Traceback (most recent call last):
File "motorcyles.py", line 3, in <module>
print(motorcycles[-1])
IndexError: list index out of range

1.3.5 - خلاصه

در این فصل آموختید که لیست‌ها چه هستند و با تک تک اعضای آن‌ها چگونه می‌توان کار کرد. یاد گرفتید که چگونه لیست را تعریف و عناصری به آن اضافه یا از آن حذف کنید. مرتّب کردن دائمی و موقّت لیست‌ها را جهت نمایش آموختید. همچنین نحوه‌ی یافتن طول یک لیست و چگونگی پرهیز از خطاهای شاخص را هنگام کار با لیست‌ها فراگرفتید.

در فصل ۴ خواهید آموخت که با اعضای یک لیست چگونه بهینه‌تر کار کنید. تنها با چند خط و با حلقه زدن و بررسی تک تک اعضای لیست، می‌توانید بهینه‌تر عمل کنید؛ حتّی اگر لیست شما شامل هزاران یا میلیون‌ها عضو باشد.

1.4 - کار کردن با لیست‌ها

در فصل سوم آموختید که چگونه یک لیست ساده درست کنید و با تک تک اعضای آن کار کنید. در این فصل می‌آموزید که چگونه فارغ از طول یک لیست، تنها با چند خط کد در کلِ آن حلقه بزنید. حلقه زدن این امکان را فراهم می‌آورد که عمل یا مجموعه‌ای از عملیّاتِ یکسان را روی هر عضو یک لیست اعمال کنید. در نتیجه می‌توانید با لیست‌هایی با هر طول، حتّی آن‌ها که شامل هزاران یا میلیون‌ها عضوند، به طور موثر کار کنید.

1.4.1 - حلقه زدن در کل یک لیست

بیشتر اوقات می‌خواهید با رجوع به تک‌تکِ اعضای یک لیست، کاری مشابه را روی هر کدام انجام دهید. برای مثال در یک بازی ممکن است بخواهید که هر عنصر را روی صفحه به یک اندازه تکان دهید یا بر روی اعضای یک لیست عددی محاسبه‌ی آماریِ یکسانی انجام دهید. یا بخواهید سرخطّ‌های لیستی از مقاله‌ها را روی وب‌سایتی نمایش دهید. هر گاه بخواهید عملی یکسان را بر روی تمام اعضای یک لیست انجام دهید می‌توانید از حلقه‌ی for پایتون بهره بگیرید.

فرض کنید که لیستی از اسامی تعدادی شعبده‌باز در اختیار داریم و می‌خواهیم اسم‌ تمامِ آن‌ها را چاپ کنیم. این کار را می‌توان با بازیابیِ جداگانه‌ی هر عضوِ لیست انجام داد ولی این رویکرد چند مشکل ایجاد می‌کند. یکی این که ممکن است در لیست‌های طولانی تکراری به نظر برسد. جز این، ما مجبوریم با هر بار تغییر یافتنِ طول لیست کد خود را تغییر دهیم. حلقه‌ی for هر دو مشکل را با سپردن مدیریت این کار به صورت داخلی به پایتون برطرف می‌کند.

اکنون از حلقه‌ی for برای چاپ کردن تک‌تک نام‌ها در لیست شعبده‌بازها استفاده می‌کنیم:

1
2
3

magicians = ['alice', 'david', 'carolina']
for magician in magicians:
    print(magician)

در خط ۱ همانند کاری که در فصل سوم کردیم، از تعریف یک لیست شروع می‌کنیم. در خط ۲ یک حلقه‌ی for تعریف می‌کنیم. این خط از پایتون می‌خواهد تا یک نام را از لیست magicians بیرون کشیده و آن را به متغیّر magician نسبت دهد. در خط ۳ به پایتون می‌گوییم که نامی را که هم‌اکنون به magician نسبت داده چاپ کند. پایتون سپس خط‌های ۲ و ۳ را برای تمام نام‌های داخل لیست تکرار می‌کند. شاید خواندن این کد به این صورت برای شما سودمند باشد: «برای هر شعبده‌باز در لیست شعبده‌بازها، نام شعبده‌باز را چاپ کن.» در خروجی به سادگی چاپ شدن هر نام موجود در لیست را خواهیم دید:

1
2
3

alice
david
carolina

نگاهی نزدیک‌تر به حلقه‌زدن

مفهوم حلقه زدن بسیار مهم است زیرا یکی از معمول‌ترین راه‌ها برای خودکارسازی وظایف تکراری با رایانه است. به عنوان یک مثال در حلقه‌ی ساده‌ای که در magicians.py به کار بردیم، پایتون ابتدا اوّلین خط حلقه را می‌خواند:

1

for magician in magicians:

این خط به پایتون می‌گوید که اوّلین مقدار را از لیست magicians بیرون بکشد و آن را به متغیّر magician نسبت بدهد. اوّلین مقدار ‘alice’ است. پایتون سپس خط بعدی را می‌خواند:

1

print(magician)

پایتون مقدار فعلی magician را که همچنان ‘alice’ است چاپ می‌کند. از آن‌جایی که لیست مقادیر دیگری را نیز دربرمی‌گیرد، پایتون به اوّلین خط حلقه بازمی‌گردد:

1

for magician in magicians:

پایتون نام بعدی را از لیست می‌خواند و مقدار آن را به متغیّر magician منسوب می‌کند و سپس همان خط را اجرا می‌کند:

1

print(magician)

پایتون بار دیگر مقدار magician را چاپ می‌کند که الان ‘david’ است و بار دیگر کل حلقه را تا فرارسیدنِ آخرین مقدارِ درون لیست، ‘carolina’، تکرار می‌کند. چون مقدار دیگری در لیست وجود ندارد پایتون به خط بعد از حلقه می‌رود. در این مورد چون بعد از حلقه‌ی for چیزی وجود ندارد برنامه به سادگی پایان می‌یابد.

هنگامی که برای نخستین بار از حلقه‌ها استفاده می‌کنید به خاطر داشته باشید که مجموعه‌ای از گام‌ها و مراحل برای تک‌تک اعضای لیست یک‌بار تکرار می‌شود و تعداد اعضای لیست مهم نیست. اگر یک میلیون مورد در لیست شما باشد پایتون تمام این مراحل را یک میلیون بار تکرار می‌کند، که معمولاً سریع هم انجام می‌گیرد.

همچنین بدانید که هنگام نوشتن حلقه‌های for، برای متغیّر موقّت حلقه که هر مقدارِ درون لیست به آن منسوب می‌شود، می‌توانید هر اسم دلخواهی را انتخاب کنید. با این حال انتخاب کردن نامی معنادار که بیانگر یک عضو لیست باشد سودمند است. برای مثال راه مناسب برای نوشتن یک حلقه‌ی for برای لیست گربه‌ها، سگ‌ها و یک لیست عمومی از اقلام در اینجا می‌آید:

1
2
3

for cat in cats:
for dog in dogs:
for item in list_of_items:

این قراردادها در نامگذاری به شما کمک می‌کند تا اتّفاقاتی را که در داخل حلقه‌ی for برای هر عضو آن می‌افتد دنبال کنید. به‌کارگیری اسم‌های مفرد و جمع کمک می‌کند که بفهمید یک بخش کد روی یک عضو لیست کار می‌کند یا تمام آن.

1.4.2 - کارهای بیشتر در یک حلقه‌ی for

در داخل یک حلقه for می‌توانید هر کاری که بخواهید با تک‌تک عضوها انجام دهید. بر اساس مثال قبلی کاری می‌کنیم که پیامی خطاب به هر شعبده‌باز صادر شود و به او گفته شود که شعبده‌ی خوبی اجرا کرده است:

1
2
3

magicians = ['alice', 'david', 'carolina']
for magician in magicians:
    print(f"{magician.title()}, that was a great trick!")

تنها تفاوت این کد در خط ۱ است که در آن پیامی خطاب به هر شعبده‌باز چاپ کردیم که با نام او آغاز می‌شود. در اوّلین گام حلقه مقدار magician برابر با ‘alice’ است پس پایتون اوّلین پیام را برای او چاپ می‌کند. دومین پیام با ‘David’ و سومین مورد با ‘Carolina’ آغاز خواهد شد.

خروجی پیامی شخصی‌شده را برای هر شعبده‌بازِ داخلِ لیست نشان می‌دهد:

1
2
3

Alice, that was a great trick!
David, that was a great trick!
Carolina, that was a great trick!

همچنین می‌توانید هر تعداد خط کد که خواستید در حلقه‌ی for بنویسید. هر خط تورفته که بعد از خط for magician in magicians آمده، داخل حلقه تلقی شده و بر روی هر مقدارِ داخلِ لیست یک بار اجرا می‌شود. در نتیجه می‌توانید هر آن‌چه می‌خواهید با هر کدام از اعضای لیست انجام دهید.

اکنون خط دومی را به پیام خود اضافه می‌کنیم تا به هر شعبده‌باز بگوییم که منتظر شعبده‌ی بعدی او هستیم:

1
2
3
4

magicians = ['alice', 'david', 'carolina']
for magician in magicians:
    print(f"{magician.title()}, that was a great trick!")
    print(f"I can't wait to see your next trick, {magician.title()}.\n")

از آن‌جایی که هر دو دستور print() را با تورفتگی نوشته‌ایم، هر دو خط برای هر شعبده‌باز داخل لیست یک بار اجرا می‌شود. خط جدید (\n) در دومین دستور print() در خط ۲، پس از هر بار اجرای حلقه یک خط خالی اضافه می‌کند. این کار مجموعه‌ای از پیام‌ها را ایجاد می‌کند که با نظم برای هر عضو لیست گروه‌بندی شده‌اند:

1
2
3
4
5
6
7
8

Alice, that was a great trick!
I can't wait to see your next trick, Alice.

David, that was a great trick!
I can't wait to see your next trick, David.

Carolina, that was a great trick!
I can't wait to see your next trick, Carolina.

به حلقه‌های for خود هر تعداد خط که بخواهید می‌توانید اضافه کنید. در عمل هنگام استفاده از حلقه‌ی for عملیّات متفاوت و متعدّدی را با اعضای لیست انجام می‌دهید.

انجام دادن کاری پس از حلقه‌ی for

درست پس از به پایان رسیدن یک حلقه‌ی for چه اتفاقی می‌افتد؟ معمولاً می‌خواهید که خروجی به دست آمده را خلاصه کنید یا به کار دیگری بپردازید که برنامه باید انجام دهد.

خط‌های کدی که بدون تورفتگی و پس از حلقه‌ی for نوشته می‌شوند تنها یک بار و بدون تکرار اجرا می‌شوند. بیایید یک پیام تشکر کلّی برای تمام شعبده‌بازان بنویسیم و از آن‌ها برای اجرای عالی‌شان تشکر کنیم. برای قرار دادن این پیام پس از پیام‌های جداگانه‌ای که چاپ کرده‌ایم، آن را بدون تورفتگی پس از حلقه‌ی for می‌نویسیم:

1
2
3
4
5

magicians = ['alice', 'david', 'carolina']
for magician in magicians:
    print(f"{magician.title()}, that was a great trick!")
    print(f"I can't wait to see your next trick, {magician.title()}.\n")
print("Thank you, everyone. That was a great magic show!")

چنانکه قبلاً دیدید دو دستور print() نخست، خطاب به هر شعبده‌باز چاپ می‌شود. امّا چون خط ۳ تورفته نیست، تنها یک بار چاپ می‌شود:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

Alice, that was a great trick!
I can't wait to see your next trick, Alice.

David, that was a great trick!
I can't wait to see your next trick, David.

Carolina, that was a great trick!
I can't wait to see your next trick, Carolina.

Thank you, everyone. That was a great magic show!

هنگام پردازش اطّلاعات با یک حلقه‌ی for درمی‌یابید که روش خوبی برای خلاصه کردنِ عملیّاتی است که روی کلِّ مجموعه‌ی داده‌ها انجام می‌گیرد. برای مثال فرض کنید از یک حلقه‌ی for برای آماده‌سازی اوّلیّه‌ی یک بازی استفاده می‌کنید به نحوی که با پردازش لیستی از شخصیت‌ها، آن را یکی یکی روی صفحه نمایش می‌دهید. ممکن است پس از حلقه کدی اضافه کنید که پس از نمایشِ تمامِ شخصیت‌های بازی دکمه‌ی Play Now را نشان دهد.

1.4.3 - کارهای بیشتر در یک حلقه‌ی for

پایتون از تورفتگی برای تعیین ارتباط یک خط یا گروهی از خط‌ها با دیگر قسمت‌های برنامه استفاده می‌کند. در مثال‌های گذشته خط‌هایی که برای هر شعبده‌باز پیامی جداگانه چاپ کرد جزئی از حلقه‌ی for بودند زیرا آن‌ها را با تورفتگی نوشته بودیم. به‌کاررفتنِ تورفتگی در پایتون خواندنِ کد را بسیار ساده می‌کند و اساساً پایتون از فاصله‌ی خالی استفاده می‌کند تا شما را به نوشتن کدهای مرتّب با ساختار بصری واضح وادار کند. در برنامه‌های طولانی‌تر پایتون به قطعه‌های تورفته‌ی کد با سطح‌های تورفتگی‌های متفاوت برخواهید خورد. این سطوح تورفتگی به شما کمک می‌کند تا احساسی کلّی نسبت به سازمان و ساختار کلّی برنامه پیدا کنید.

هنگامی که شروع به نوشتن کدهای دارای تورفتگی می‌کنید باید مراقب تعداد اندک امّا متداولی خطای تورفتگی باشید. برای نمونه افراد گاهی خط‌هایی را که نیاز به تورفتگی ندارند، با تورفتگی می‌نویسند یا فراموش می‌کنند که خط‌های نیازمندِ تورفتگی را این‌چنین بنویسند. دیدن چند نمونه از این خطاها به شما کمک می‌کند که در آینده از آن‌ها پرهیز کنید و اگر در برنامه‌هایتان چنین مواردی رخ داد آن‌ها را برطرف کنید.

اکنون برخی از معمول‌ترین خطاهای تورفتگی را بررسی می‌کنیم.

فراموش کردن تورفتگی

همیشه خط بعد از حلقه‌ی for را تورفته بنویسید. اگر فراموش کنید پایتون به شما تذکر می‌دهد:

1
2
3

magicians = ['alice', 'david', 'carolina']
for magician in magicians:
    print(magician)

فراخوانی print() در خط ۳ باید تورفته باشد امّا نیست. هنگامی که پایتون به دنبال خطی تورفته باشد امّا آن را نیابد، به شما می‌گوید که کدام خط چنین مشکلی دارد.

1
2
3
4

File "magicians.py", line 3
    print(magician)
                    ^
IndentationError: expected an indented block

این نوع از خطای تورفتگی را می‌توان با تصحیح خط یا خط‌هایی که بلافاصله بعد از عبارت for آمده‌اند برطرف کرد.

فراموش کردن تورفتگی خط‌های اضافی

گاهی حلقه‌ی شما بدون هیچ خطایی اجرا می‌شود امّا نتیجه‌ی مطلوب را نمی‌گیرید. این گاهی به این دلیل رخ می‌دهد که می‌خواهید چند وظیفه را در یک حلقه انجام دهید امّا فراموش کرده‌اید که برخی از خط‌ها را تورفته کنید.

برای مثال اگر فراموش کنید که دومین خط داخل حلقه را که به هر شعبده‌باز می‌گوید که ما منتظر حقه‌ی بعدی آن‌ها هستیم، با تورفتگی بنویسید، به چنین خطایی برخواهید خورد:

1
2
3
4

magicians = ['alice', 'david', 'carolina']
for magician in magicians:
    print(f"{magician.title()}, that was a great trick!")
print(f"I can't wait to see your next trick, {magician.title()}.")

فراخوانی print() در خط ۲ باید با تورفتگی همراه باشد، امّا چون پایتون حداقل یک خطِ تورفته‌ی درست بعد از حلقه‌ی for می‌بیند، خطایی اعلام نمی‌کند. در نتیجه print() اول که خط آن تورفته است برای هر کدام از نام‌ها یک بار اجرا می‌شود. دومین print() را بدون تورفتگی نوشتیم پس تنها یک بار بعد از پایان کار حلقه اجرا می‌شود. از آن‌جایی که آخرین مقداری که به magician نسبت داده شده ‘carolina’ است، او تنها کسی است که پیام ’looking forward to the next trick’ را دریافت می‌کند:

1
2
3
4

Alice, that was a great trick!
David, that was a great trick!
Carolina, that was a great trick!
I can't wait to see your next trick, Carolina.

این یک خطای منطقی است. دستورِ برنامه‌ی کدِ معتبرِ پایتون است امّا کد خروجی مطلوب را تولید نمی‌کند زیرا منطق آن مشکل دارد. اگر انتظار دارید که عمل مشخّصی روی تک‌تک اعضای لیست انجام شود امّا تنها یک بار این اتّفاق می‌افتد، باید یک یا چند خط برنامه را به سادگی تورفته کنید.

تورفتگی‌های بی‌مورد

اگر به طور تصادفی خطی را تورفته کنید بدون این که نیاز باشد پایتون در مورد آن به شما اطّلاع خواهد داد:

1
2

message = "Hello Python world!"
    print(message)

دستور print() در خط ۲ نیازی به تورفتگی ندارد چون بخشی از حلقه نیست؛ بنابراین پایتون این خطا را گزارش می‌کند:

1
2
3
4

File "hello_world.py", line 2
    print(message)
    ^
IndentationError: unexpected indent

برای پرهیز از خطاهای ناخواسته‌ی ناشی از تورفتگی، تنها زمانی این کار را انجام دهید که دلیل مشخّصی برای آن داشته باشید. در برنامه‌هایی که در مقطع فعلی می‌نویسید تنها خط‌هایی باید تورفته باشند که به عملیّاتِ تکراری روی هر عضو در یک حلقه‌ی for مربوط می‌شوند.

تورفتگی بی‌مورد پس از حلقه

اگر اتّفاقاً خطّی را که باید پس از پایان حلقه اجرا شود تورفته بنویسید، آن کد برای تمام اعضای لیست یک بار اجرا خواهد شد. گاهی این کار موجب می‌شود که پایتون خطایی گزارش کند امّا گاهی به خطای منطقی منجر می‌شود.

برای مثال اجازه دهید ببینیم با تورفته کردن خطی که حاوی پیام تشکر به همه‌ی شعبده‌بازها بود، چه اتّفاقی می‌افتد:

1
2
3
4
5

magicians = ['alice', 'david', 'carolina']
for magician in magicians:
    print(f"{magician.title()}, that was a great trick!")
    print(f"I can't wait to see your next trick, {magician.title()}.\n")
    print("Thank you everyone, that was a great magic show!")

چون که خط ۴ تورفته است، یک بار برای هر فرد داخل لیست چاپ می‌شود، چنانکه اینجا می‌بینید:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

Alice, that was a great trick!
I can't wait to see your next trick, Alice.

Thank you everyone, that was a great magic show!
David, that was a great trick!
I can't wait to see your next trick, David.

Thank you everyone, that was a great magic show!
Carolina, that was a great trick!
I can't wait to see your next trick, Carolina.

Thank you everyone, that was a great magic show!

این هم یک خطای منطقی دیگر است مشابه با آن‌چه در «فراموش کردن تورفتگی خط‌های اضافی» دیدید. از آن‌جایی که پایتون نمی‌داند شما می‌خواهید در برنامه‌ی خود چه کاری انجام دهید، هر کدی را که به لحاظ نحوی معتبر باشد، اجرا می‌کند. اگر عملی چندین بار تکرار می‌شود درحالی‌که تنها باید یک بار انجام می‌گرفت، احتمالاً باید کد مربوط آن را از تورفتگی خارج کنید.

فراموش کردن دونقطه

دونقطه‌ی پایان عبارت for به پایتون می‌گوید که خط بعدی را به عنوان آغاز حلقه در نظر بگیرد.

1
2
3

magicians = ['alice', 'david', 'carolina']
for magician in magicians
    print(magician)

اگر سهواً دونقطه را فراموش کنید، همانند خط ۲، به خطای نحوی برمی‌خورید چون پایتون نمی‌داند شما چه می‌خواهید بکنید. اگرچه رفع کردن این خطا ساده است، امّا پیدا کردن آن همیشه آسان نیست. مدت‌زمانی که یک برنامه‌نویس صرف یافتن خطاهای تک‌کاراکتری مانند این می‌کند، شاید برای شما تعجّب‌آور باشد. چنین خطاهایی دیریاب هستند زیرا ما معمولاً تنها چیزی را می‌بینیم که انتظار دیدنش را داریم.

خودآزمایی

۴-۱- پیتزاها

به دستِ کم سه نوع پیتزای دلخواه خود فکر کنید. نام آن‌ها را در لیستی ذخیره کنید و سپس به کمک حلقه‌ی for نام هرکدام را چاپ کنید.

• حلقه را به نحوی تغییر دهید که به جای نام هر پیتزا جمله‌ای شامل نام آن چاپ شود. برای هر پیتزا باید جمله‌ای شبیه به «I like pepperoni pizza» در خروجی داشته باشید.
• خطی به پایان برنامه‌ی خود، خارج از حلقه‌ی for، اضافه کنید که بیان می‌کند شما چه‌قدر پیتزا دوست دارید. خروجی باید از سه یا چند خط در مورد انواع پیتزاهای مورد علاقه‌ی شما تشکیل شده باشد و سپس جمله‌ای مانند I really like pizza! اضافه شود.

۴-۲- حیوانات

حداقل سه حیوان مختلف با ویژگی‌های مشترک در نظر بگیرید. نام آن‌ها را در لیستی ذخیره کنید و به کمک یک حلقه‌ی for نام هر یک را چاپ کنید.

• برنامه را به نحوی تغییر دهید که جمله‌ای درباره‌ی هر حیوان چاپ کند، مثلاً A dog would make a great pet.
• خطّی به پایان برنامه اضافه کنید که ویژگی مشترک این حیوانات را بیان کند. مثلاً می‌توانید جمله‌ای مانند Any of these animals would make a great pet!.

1.4.4 - پرهیز از خطای تورفتگی

پایتون از تورفتگی برای تعیین ارتباط یک خط یا گروهی از خط‌ها با دیگر قسمت‌های برنامه استفاده می‌کند. در مثال‌های گذشته خط‌هایی که برای هر شعبده‌باز پیامی جداگانه چاپ می‌کرد جزئی از حلقه‌ی for بودند زیرا آن‌ها را با تورفتگی نوشته بودیم. به‌کاررفتنِ تورفتگی در پایتون خواندنِ کد را بسیار ساده می‌کند و اساساً پایتون از فاصله‌ی خالی استفاده می‌کند تا شما را به نوشتن کدهای مرتّب با ساختار بصری واضح وادار کند. در برنامه‌های طولانی‌تر پایتون به قطعه‌های تورفته‌ی کد با سطح‌های تورفتگی‌های متفاوت برخواهید خورد. این سطوح تورفتگی به شما کمک می‌کند تا احساسی کلّی نسبت به سازمان و ساختار کلّی برنامه پیدا کنید.

هنگامی که شروع به نوشتن کدهای دارای تورفتگی می‌کنید باید مراقب تعداد اندک امّا متداولی خطای تورفتگی باشید. برای نمونه افراد گاهی خط‌هایی را که نیاز به تورفتگی ندارند، با تورفتگی می‌نویسند یا فراموش می‌کنند که خط‌های نیازمندِ تورفتگی را این‌چنین بنویسند. دیدن چند نمونه از این خطاها به شما کمک می‌کند که در آینده از آن‌ها پرهیز کنید و اگر در برنامه‌هایتان چنین مواردی رخ داد آن‌ها را برطرف کنید.

اکنون برخی از معمول‌ترین خطاهای تورفتگی را بررسی می‌کنیم.

فراموش کردن تورفتگی

همیشه خط بعد از حلقه‌ی for را تورفته بنویسید. اگر فراموش کنید پایتون به شما تذکر می‌دهد:

1
2
3

magicians = ['alice', 'david', 'carolina']
for magician in magicians:
print(magician)

فراخوانی print() در 1 باید تورفته باشد امّا نیست. هنگامی که پایتون به دنبال خطی تورفته باشد امّا آن را نیابد، به شما می‌گوید که کدام خط چنین مشکلی دارد.

1
2
3
4

File "magicians.py", line 3
    print(magician)
    ^
IndentationError: expected an indented block

این نوع از خطای تورفتگی را می‌توان با تصحیح خط یا خط‌هایی که بلافاصله بعد از عبارت for آمده‌اند برطرف کرد.

فراموش کردن تورفتگی خط‌های اضافی

گاهی حلقه‌ی شما بدون هیچ خطایی اجرا می‌شود امّا نتیجه‌ی مطلوب را نمی‌گیرید. این گاهی به این دلیل رخ می‌دهد که می‌خواهید چند وظیفه را در یک حلقه انجام دهید امّا فراموش کرده‌اید که برخی از خط‌ها را تورفته کنید.

برای مثال اگر فراموش کنید که دومین خط داخل حلقه را که به هر شعبده‌باز می‌گوید که ما منتظر حقه‌ی بعدی آن‌ها هستیم، با تورفتگی بنویسید، به چنین خطایی برخواهید خورد:

1
2
3
4

magicians = ['alice', 'david', 'carolina']
for magician in magicians:
    print(f"{magician.title()}, that was a great trick!")
print(f"I can't wait to see your next trick, {magician.title()}.\n")

فراخوانی print() در 1 باید با تورفتگی همراه باشد، امّا چون پایتون حداقل یک خطِ تورفته‌ی درست بعد از حلقه‌ی for می‌بیند، خطایی اعلام نمی‌کند. در نتیجه print() اول که خط آن تورفته است برای هر کدام از نام‌ها یک بار اجرا می‌شود. دومین print() را بدون تورفتگی نوشتیم پس تنها یک بار بعد از پایان کار حلقه اجرا می‌شود. از آن‌جایی که آخرین مقداری که به magician نسبت داده شده ‘carolina’ است، او تنها کسی است که پیام ’looking forward to the next trick’ را دریافت می‌کند:

1
2
3
4

Alice, that was a great trick!
David, that was a great trick!
Carolina, that was a great trick!
I can't wait to see your next trick, Carolina.

این یک خطای منطقی است. دستورِ برنامه‌ی کدِ معتبرِ پایتون است امّا کد خروجی مطلوب را تولید نمی‌کند زیرا منطق آن مشکل دارد. اگر انتظار دارید که عمل مشخّصی بر روی تک‌تک اعضای لیست انجام شود امّا تنها یک بار این اتّفاق می‌افتد، باید یک یا چند خط برنامه را به سادگی تورفته کنید.

تورفتگی‌های بی‌مورد

اگر به طور تصادفی خطی را تورفته کنید بدون این که نیاز باشد پایتون در مورد آن به شما اطّلاع خواهد داد:

1
2

message = "Hello Python world!"
    print(message)

دستور print() در 1 نیازی به تورفتگی ندارد چون بخشی از حلقه نیست؛ بنابراین پایتون این خطا را گزارش می‌کند:

1
2
3
4

File "hello_world.py", line 2
    print(message)
    ^
IndentationError: unexpected indent

برای پرهیز از خطاهای ناخواسته‌ی ناشی از تورفتگی، تنها زمانی این کار را انجام دهید که دلیل مشخّصی برای آن داشته باشید. در برنامه‌هایی که در مقطع فعلی می‌نویسید تنها خط‌هایی باید تورفته باشند که به عملیّاتِ تکراری روی هر عضو در یک حلقه‌ی for مربوط می‌شوند.

تورفتگی بی‌مورد پس از حلقه

اگر اتّفاقاً خطّی را که باید پس از پایان حلقه اجرا شود تورفته بنویسید، آن کد برای تمام اعضای لیست یک بار اجرا خواهد شد. گاهی این کار موجب می‌شود که پایتون خطایی گزارش کند امّا گاهی به خطای منطقی منجر می‌شود.

برای مثال اجازه دهید ببینیم با تورفته کردن خطی که حاوی پیام تشکر به همه‌ی شعبده‌بازها بود، چه اتّفاقی می‌افتد:

1
2
3
4
5

magicians = ['alice', 'david', 'carolina']
for magician in magicians:
    print(f"{magician.title()}, that was a great trick!")
    print(f"I can't wait to see your next trick, {magician.title()}.\n")
    print("Thank you everyone, that was a great magic show!")

چون که خط 1 تورفته است، یک بار برای هر فرد داخل لیست چاپ می‌شود، چنانکه اینجا می‌بینید:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

Alice, that was a great trick!
I can't wait to see your next trick, Alice.

Thank you everyone, that was a great magic show!
David, that was a great trick!
I can't wait to see your next trick, David.

Thank you everyone, that was a great magic show!
Carolina, that was a great trick!
I can't wait to see your next trick, Carolina.

Thank you everyone, that was a great magic show!

این هم یک خطای منطقی دیگر است مشابه با آن‌چه در «فراموش کردن تورفتگی خط‌های اضافی» دیدید. از آن‌جایی که پایتون نمی‌داند شما می‌خواهید در برنامه‌ی خود چه کاری انجام دهید، هر کدی را که به لحاظ نحوی معتبر باشد، اجرا می‌کند. اگر عملی چندین بار تکرار می‌شود درحالی‌که تنها باید یک بار انجام می‌گرفت، احتمالاً باید کد مربوط آن را از تورفتگی خارج کنید.

فراموش کردن دونقطه

دونقطه‌ی پایان عبارت for به پایتون می‌گوید که خط بعدی را به عنوان آغاز حلقه در نظر بگیرد.

1
2
3

magicians = ['alice', 'david', 'carolina']
for magician in magicians
print(magician)

اگر سهواً دونقطه را فراموش کنید، همانند 1، به خطای نحوی برمی‌خورید چون پایتون نمی‌داند شما چه می‌خواهید بکنید. اگرچه رفع کردن این خطا ساده است، امّا پیدا کردن آن همیشه آسان نیست. مدت‌زمانی که یک برنامه‌نویس صرف یافتن خطاهای تک‌کاراکتری مانند این می‌کند، شاید برای شما تعجّب‌آور باشد. چنین خطاهایی دیریاب هستند زیرا ما معمولاً تنها چیزی را می‌بینیم که انتظار دیدنش را داریم.

1.4.5 - ساختن لیست‌های عددی

دلایل فراوانی برای ذخیره کردن مجموعه‌ای از اعداد وجود دارد. مثلاً شما نیاز دارید موقعیت‌های هر شخصیّت را در بازی ثبت کنید، همچنین شاید بخواهید بیشترین امتیاز بازیکن را هم ذخیره کنید. در بصری‌سازی داده تقریباً همیشه با مجموعه‌ای از اعداد، مانند دماها، فاصله‌ها، جمعیت‌ها، مقادیر طول و عرض جغرافیایی و دیگر انواع مجموعه‌های عددی سر و کار دارید.

لیست‌ها برای ذخیره کردن مجموعه‌های اعداد ایده‌آل‌اند و پایتون مجموعه‌ای از ابزارها را برای کار کردن بهینه با لیست‌های اعداد فراهم می‌آورد. زمانی که یاد گرفتید چگونه از این ابزارها به طور موثر استفاده کنید کد شما حتی برای لیست‌هایی شامل میلیون‌ها عضو نیز به خوبی کار خواهد کرد.

به‌کارگیری تابع range

دستور range() در پایتون ایجاد دنباله‌ای از اعداد را آسان می‌کند. برای مثال به کمک آن می‌توانید دنباله‌ای از اعداد را مانند زیر چاپ کنید:

1
2

for value in range(1, 5):
    print(value)

هر چند به نظر می‌رسد این کد باید اعداد ۱ تا ۵ را چاپ کند، امّا عدد ۵ را چاپ نمی‌کند:

1
2
3
4

1
2
3
4

در این مثال range() تنها اعداد ۱ تا ۴ را چاپ می‌کند. این یکی دیگر از نتایج رفتار یکی‌جا‌به‌جا است که در زبان‌های برنامه‌نویسی غالباً دیده می‌شود. تابع range() باعث می‌شود پایتون از اولین مقدار داده‌شده شروع به شمارش کند و با رسیدن به دومین عددی که تعیین کرده‌اید توقف کند. از آن‌جایی که این تابع قبل از رسیدن به دومین مقدار مشخّص‌شده توقف می‌کند خروجی هرگز شامل مقدار پایانی نخواهد بود که در این مثال عدد ۵ است.

برای چاپ کردن اعداد ۱ تا ۵ از range(1,6) استفاده می‌کنید:

1
2

for value in range(1, 6):
    print(value)

این بار خروجی از ۱ آغاز و به ۵ ختم می‌شود:

1
2
3
4
5

1
2
3
4
5

اگر هنگام استفاده از range() خروجی با آن‌چه انتظار دارید متفاوت است سعی کنید مقدار پایانی را یکی جابه‌جا کنید.

همچنین می‌توانید به تابع range() تنها یک نشان‌وند بدهید آن‌گاه این تابع دنباله‌ی اعداد را از صفر آغاز می‌کند. برای مثال range(6) اعداد ۰ تا ۵ را برمی‌گرداند.

استفاده از range() برای تولید لیستی از اعداد

اگر بخواهید لیستی از اعداد تولید کنید می‌توانید به کمک تابع list()، خروجیِ تابعِ range() را مستقیماً به لیست تبدیل کنید. زمانی که تابع range() را داخل list() قرار می‌دهید خروجی لیستی از اعداد خواهد بود.

در مثال بخش قبل به سادگی دنباله‌ای از اعداد را چاپ کردیم. می‌توانیم از list() برای تبدیل این مجموعه‌ی اعداد به لیست استفاده کنیم:

1
2

numbers = list(range(1, 6))
print(numbers)

و نتیجه به این شکل است:

1

[1, 2, 3, 4, 5]

همچنین می‌توانیم به کمک تابع range() از پایتون بخواهیم که برخی اعداد را در محدوده‌ی داده‌شده نادیده بگیرد. اگر ورودی سومی به range() بدهید، پایتون هنگام تولید اعداد آن مقدار را به عنوان طول گام در نظر می‌گیرد.

برای مثال اینجا نحوه‌ی تولید اعداد زوج بین ۱ تا ۱۰ را می‌بینیم:

1
2

even_numbers = list(range(2, 11, 2))
print(even_numbers)

در این مثال تابع range() از مقدار ۲ شروع می‌کند و سپس ۲ تا به آن اضافه می‌کند. این تابع تا زمان رسیدن یا گذشتن از مقدار پایانی، اینجا ۱۱، اضافه کردن ۲ را ادامه می‌دهد و این خروجی را تولید می‌کند:

1

[2, 4, 6, 8, 10]

به کمک تابع range() می‌توانید تقریباً هر نوع مجموعه‌ی عددی را تولید کنید. برای مثال فرض کنید که می‌خواهید لیست اوّلین ۱۰ عددِ مربّع را که توانِ دوی اعداد ۱ تا ۱۰ است تولید کنید. در پایتون دو علامت ستاره (**) بیانگر توان است. اینجا روشی نشان داده شده که شما هم احتمالاً برای قرار دادن ۱۰ عدد مربّع در یک لیست استفاده خواهید کرد:

1
2
3
4
5
6

squares = []
for value in range(1, 11):
    square = value ** 2
    squares.append(square)

print(squares)

در 1 از یک لیست تهی شروع می‌کنیم. در 2 به پایتون می‌گوییم که به کمک تابع range() در اعداد ۱ تا ۱۰ حلقه بزند. در 3 مقدار فعلی به توان ۲ رسیده و در متغیّر square ذخیره می‌شود. در 4، مقدار جدید square به لیست squares افزوده می‌شود. در نهایت با پایان یافتن حلقه لیست اعداد مربّع در 5 چاپ می‌شود:

1

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

برای مختصرتر نوشتن این کد می‌توانیم متغیّر موقّت square را حذف و مقادیر جدید را مستقیماً به لیست بیفزاییم:

1
2
3
4

squares = []
for value in range(1,11):
    squares.append(value**2)
print(squares)

کد در خط 1 همانند خط‌های 3 و 4 فایل squares.py کار می‌کند. هر کدام از مقدارها در حلقه به توان ۲ رسیده و بلافاصله به لیستِ اعدادِ مربّع افزوده می‌شود.

برای ساختن لیست‌هایی که پیچیده‌تر هستند می‌توانید از هر دو روش استفاده کنید. گاهی استفاده از متغیّر موقّت خوانایی برنامه را بیشتر و گاهی کد را بی‌دلیل طولانی می‌کند. ابتدا بر روی کدی تمرکز کنید که می‌توانید به روشنی آن را درک کنید و البته کاری را که می‌خواهید انجام می‌دهد. سپس همزمان با مرور کردن کد خود به دنبال رویکردهای بهینه‌تر بگردید.

محاسبات آماری ساده با لیستی از اعداد

تعدادی از دستورهای پایتون هنگام کار با لیست‌های عددی سودمندند. برای مثال به راحتی می‌توانید کمینه، بیشینه و مجموع یک لیست اعداد را به دست آورید:

1
2
3
4
5
6
7

>>> digits = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
>>> min(digits)
0
>>> max(digits)
9
>>> sum(digits)
45

تولید لیست به روش دربرداری

این رویکرد پیش از این برای تولیدِ لیستِ squares با سه یا چهار خط کد توضیح داده شد. روش دربرداری برای تولید لیست به شما امکان می‌دهد تا همین کار را تنها در یک خط انجام دهید. این روش حلقه‌ی for و ایجاد عناصر جدید را در یک خط ترکیب و هر عضو جدید را به طور خودکار اضافه می‌کند. ارائه کردن این روش به برنامه‌نویسانِ تازه‌کار معمولاً متداول نیست امّا اینجا آورده می‌شود چون شما به زودی و به محض آغازِ بررسیِ کدهای دیگران به آن برخواهید خورد.

مثال زیر ساختن لیستی مشابه با لیست اعداد مربّع را که پیش از این دیده‌اید نشان می‌دهد، امّا این بار با استفاده از روش دربرداری:

1
2

squares = [value**2 for value in range(1, 11)]
print(squares)

برای استفاده از این دستور، از یک نامِ گویا برای لیست، مثل squares، شروع کنید. حال یک کروشه باز کنید و برای مقادیری که می‌خواهید در لیست ذخیره کنید، عبارتی تعریف کنید. در این مثال این عبارت value**2 است که مقدارها را به توان ۲ می‌رساند. در ادامه یک حلقه‌ی for تعریف کنید تا اعدادِ ورودی به عبارتِ فوق را تولید کند. سرانجام کروشه را ببندید. حلقه‌ی for در این مثال for value in range(1,11) است که مقادیر ۱ تا ۱۰ را به عبارت value**2 می‌خوراند. توجّه کنید که در پایان حلقه‌ی for از دونقطه استفاده نشده است.

نتیجه مشابه همان لیستِ اعداد مربّعی است که پیش‌تر دیدید:

1

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

آشنایی با ساختن لیست با این روش کمی کار می‌برد امّا هنگامی که برای ساختن لیست‌های معمولی نیز آن‌ها را راحت یافتید درمی‌یابید که ارزش وقت گذاشتن را داشته است. هر گاه نوشتن سه یا چهار خط را برای ساختن لیست‌ها تکراری و خسته‌کننده دیدید به فکر ساختن لیست به این روش بیفتید.

خودآزمایی

شمردن تا ۲۰

از یک حلقه‌ی for برای شمردن از ۱ تا ۲۰، و خودِ ۲۰، استفاده کنید.

یک میلیون

لیستی از اعدادِ ۱ تا یک میلیون بسازید سپس به کمک حلقه‌ی for آن را چاپ کنید. (اگر نمایش خروجی طولانی شد آن را با فشردن Ctrl+C یا بستن پنجره‌ی خروجی متوقّف کنید.)

جمع کردن یک میلیون عدد

لیستی از اعداد ۱ تا یک میلیون بسازید سپس با کمک min() و max() مطمئن شوید که لیست واقعاً از ۱ شروع و به یک میلیون ختم می‌شود. سپس از sum() استفاده کنید تا دریابید پایتون چه‌قدر سریع می‌توان یک میلیون عدد را با هم جمع کند.

اعداد فرد

به کمک ورودی یا نشان‌وند سوم تابع range() لیستی از اعداد فرد بین ۱ تا ۲۰ درست کنید. سپس به کمک یک حلقه‌ی for آن را چاپ کنید.

مضارب ۳

لیستی از مضرب‌های ۳ بین ۳ و ۳۰ بسازید و با یک حلقه‌ی for اعداد داخل آن را چاپ کنید.

اعداد مکعّب

به عددی که به توان ۳ رسیده باشد مکعّب گویند. برای مثال مکعّب ۲ در پایتون با 3**2 نمایش داده می‌شود. لیستی از ۱۰ عدد مکعّب نخست (که مکعّب اعداد صحیح از ۱ تا ۱۰ است)، بسازید و با یک حلقه‌ی for این اعداد را نمایش دهید.

اعداد مکعّب به روش دربرداری

به کمکِ این روش لیستی از ۱۰ عدد مکعّب نخست تولید کنید.

1.4.6 - کار کردن با بخشی از یک لیست

در فصل ۳ روش دسترسی به تک تک اعضای یک لیست و در این فصل کار کردن با تمام اعضای آن را آموختید. در عین حال شما می‌توانید با گروه مشخّصی از اعضای یک لیست کار کنید که پایتون آن را برش می‌نامد.

ساختن برشی از لیست

برای برش دادن یک لیست شاخص آغازی و پایانی اعضای مورد نظر خود را مشخّص می‌کنید. همانند تابع range() پایتون پیش از رسیدن به آخرین عضوِ مشخّص شده توقّف می‌کند. برای بریدن سه عضو اوّل یک لیست باید شاخص‌های ۰ تا ۳ را درخواست کنید که اعضای ۰، ۱ و ۲ را برمی‌گرداند.

مثال زیر درباره‌ی لیستی از بازیکن‌های یک تیم است:

1
2

players = ['charles', 'martina', 'michael', 'florence', 'eli']
print(players[0:3])

کد در 1 برشی از لیست را چاپ می‌کند که شامل سه بازیکن اوّل است. در خروجی ساختار لیست حفظ شده و شامل سه بازیکن است:

1

['charles', 'martina', 'michael']

می‌توانید هر زیرمجموعه‌ای را از یک لیست تولید کنید. مثلاً اگر برشی از لیست را شامل اعضای دوم، سوم و چهارم بخواهید می‌توانید آن را از شاخص ۱ آغاز و به شاخص ۴ ختم کنید:

1
2

players = ['charles', 'martina', 'michael', 'florence', 'eli']
print(players[1:4])

این بار برش از ‘martina’ شروع و با ‘florence’ تمام می‌شود:

1

['martina', 'michael', 'florence']

اگر شاخص اوّل برش را حذف کنید، پایتون برش را به طور خودکار از آغاز لیست شروع می‌کند:

1
2

players = ['charles', 'martina', 'michael', 'florence', 'eli']
print(players[:4])

بدونِ شاخصِ آغازین، پایتون از اوّلِ لیست شروع می‌کند:

1

['charles', 'martina', 'michael', 'florence']

از همین ترکیب می‌توانید برای برش‌های انتهایی لیست استفاده کنید. برای نمونه اگر برشی شامل همه‌ی اعضا از شاخص سوم تا پایان لیست را بخواهید می‌توانید شاخص شروع را ۲ گذاشته و شاخص پایان را حذف کنید:

1
2

players = ['charles', 'martina', 'michael', 'florence', 'eli']
print(players[2:])

پایتون عضو سوم تا پایان را برمی‌گرداند:

1

['michael', 'florence', 'eli']

به این ترتیب می‌توانید صرف نظر از طول لیست، تمام اعضای بین یک شاخص خاص و پایان آن را در خروجی داشته باشید. به خاطر بیاورید که شاخص منفی می‌توانست عضوی را در فاصله‌ی مشخّصی از پایان لیست برگرداند. پس به کمک آن می‌توانید برش‌هایی از انتهای لیست تولید کنید. برای مثال اگر بخواهیم سه بازیکنِ آخرِ ترکیبِ تیم را برگردانیم از برش players[-3:] استفاده می‌کنیم:

1
2

players = ['charles', 'martina', 'michael', 'florence', 'eli']
print(players[-3:])

این مثال نام سه بازیکن آخر را چاپ می‌کند و با افزایش تعداد بازیکنانِ لیست هم بدون مشکل کار خواهد کرد.

حلقه زدن در یک برش

اگر بخواهید تنها در زیرمجموعه‌ای از اعضای یک لیست حلقه بزنید می‌توانید از یک برش در حلقه‌ی for استفاده کنید. در مثال زیر در سه بازیکن اوّل حلقه می‌زنیم و نام آن‌ها را به عنوان یک ترکیبِ تیم ساده چاپ می‌کنیم:

1
2
3
4

players = ['charles', 'martina', 'michael', 'florence', 'eli']
print("Here are the first three players on my team:")
for player in players[:3]:
    print(player.title())

پایتون در 1 به جای حلقه زدن در کل لیست، تنها در سه نام اول می‌چرخد:

1
2
3
4

Here are the first three players on my team:
Charles
Martina
Michael

برش‌ها در موارد خاصّی بسیار کاربردی‌اند. برای مثال زمانی که یک بازی می‌سازید، هر بار که بازیکن بازی را به پایان رساند می‌توانید امتیاز نهایی او را به لیستی بیفرایید. سپس با مرتّب کردن لیست به صورت نزولی و برداشتن برشی از سه امتیاز اول، می‌توانید سه امتیاز بالای بازیکن را به دست آورید. زمانی که با داده‌ها کار می‌کنید می‌توانید از برش‌ها برای پردازش داده‌ها در تکّه‌ها با اندازه‌ی مشخّص استفاده کنید. یا هنگام ساختن یک برنامه‌ی تحت وب از برش‌ها برای نمایش اطّلاعات در دسته‌ای از صفحات استفاده کنید به طور‌ی‌که در هر صفحه مقدار مشخّصی از اطّلاعات قرار گیرد.

کپی کردن یک لیست

بسیاری از اوقات شما می‌خواهید بر پایه‌ی یک لیست موجود، لیستی کاملاً جدید ایجاد کنید. بیایید چگونه کپی کردنِ یک لیست را بررسی و وضعیتی نمونه را امتحان کنیم که کپی کردن لیست در آن مفید است.

برای کپی کردن یک لیست می‌توانید با حذف کردن شاخص‌های ابتدایی و پایانی ([:]) برشی از آن را تهیه کنید که شامل تمام اعضای لیست اوّلّیه است. این کار به پایتون می‌گوید که برشی از لیست تهیه کند که از عضو اول شروع و به عضو آخر ختم می‌شود و باعث ایجاد یک کپی از کل لیست می‌شود.

برای مثال فرض کنید که لیستی از غذاهای مورد علاقه‌مان موجود است و می‌خواهیم لیستی جداگانه و مشابه برای یک دوست درست کنیم. دوستمان تمام غذاهای مورد علاقه‌ی ما را دوست دارد در نتیجه می‌توانیم لیست او را با کپی کردن لیست خود درست کنیم:

1
2
3
4
5
6

my_foods = ['pizza', 'falafel', 'carrot cake']
friend_foods = my_foods[:]
print("My favorite foods are:")
print(my_foods)
print("\nMy friend's favorite foods are:")
print(friend_foods)

در 1 لیستی از غذاهایی را که دوست داریم به نام my_foods درست کرده‌ایم. در 2 لیست جدیدی به نام friend_foods می‌سازیم. با درخواست برشی از my_foods بدون مشخّص کردن هیچ شاخصی و ذخیره کردن آن در friend_foods، یک کپی از my_foods ایجاد می‌کنیم. اگر هر دو لیست را چاپ کنیم می‌بینیم که هر دو دربرگیرنده‌ی غذاهای مشابهی هستند:

1
2
3
4

My favorite foods are:
['pizza', 'falafel', 'carrot cake']
My friend's favorite foods are:
['pizza', 'falafel', 'carrot cake']

برای این که ثابت کنیم واقعاً دو لیست جداگانه داریم یک غذای جدید به هر یک از لیست‌ها اضافه می‌کنیم تا نشان دهیم که هر لیست غذاهای مورد علاقه‌ی یک نفر را به صورت جداگانه نگه می‌دارد:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

my_foods = ['pizza', 'falafel', 'carrot cake']
friend_foods = my_foods[:]

my_foods.append('cannoli')
friend_foods.append('ice cream')

print("My favorite foods are:")
print(my_foods)

print("\nMy friend's favorite foods are:")
print(friend_foods)

در 1 همانند قبل، اعضای اوّلیّه‌ی داخل my_foods را در لیست جدید friend_foods کپی کردیم. در ادامه یک غذای جدید به هر لیست اضافه می‌کنیم: در 2 ‘cannoli’ را به my_foods و در 3 ‘ice cream’ را به friend_foods افزودیم. سپس هر دو لیست را چاپ می‌کنیم تا ببینیم هر کدام از این غذاها به لیست مناسب اضافه شده‌اند یا نه:

1
2
3
4
5

My favorite foods are:
['pizza', 'falafel', 'carrot cake', 'cannoli']

My friend's favorite foods are:
['pizza', 'falafel', 'carrot cake', 'ice cream']

خروجی نشان می‌دهد که ‘cannoli’ اکنون در لیست غذاهای مورد علاقه‌ی ما وجود دارد امّا ‘ice cream’ اینچنین نیست. در 5 می‌بینیم که ‘ice cream’ در لیست دوستمان هست امّا ‘cannoli’ نیست. اگر صرفاً و به سادگی متغیّر friend_foods را برابر با my_foods قرار می‌دادیم، منجر به ایجاد دو لیست جداگانه نمی‌شد. برای مثال اینجا می‌بینیم اگر لیستی را بدون استفاده از برش کپی کنیم چه اتّفاقی می‌افتد:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

my_foods = ['pizza', 'falafel', 'carrot cake']

# This doesn't work:
friend_foods = my_foods
my_foods.append('cannoli')
friend_foods.append('ice cream')

print("My favorite foods are:")
print(my_foods)

print("\nMy friend's favorite foods are:")
print(friend_foods)

در 1 به جای کپی کردن my_foods در friend_foods، صرفاً این دو متغیّر را برابر با یکدیگر قرار دادیم. این دستور به پایتون می‌گوید که متغیّر جدید friend_foods را به لیستی ارتباط دهد که خود قبلاً با my_foods مرتبط بوده است. بنابراین الان هر دو متغیّر به یک لیست مشابه اشاره می‌کنند. در نتیجه اگر ‘cannoli’ را به my_foods اضافه کنید این عضو در friend_foods نیز ظاهر خواهد شد. به طور مشابه اگر ‘ice cream’ را فقط به friend_foods اضافه کنید در هر دو لیست دیده خواهد شد.

خروجی نشان می‌دهد که هر دو لیست یکسان هستند و این چیزی نیست که ما می‌خواستیم:

1
2
3
4
5

My favorite foods are:
['pizza', 'falafel', 'carrot cake', 'cannoli', 'ice cream']

My friend's favorite foods are:
['pizza', 'falafel', 'carrot cake', 'cannoli', 'ice cream']

خودآزمایی

برش‌ها

به یکی از برنامه‌هایی که در این فصل نوشته‌اید چند خط اضافه کنید تا کارهای زیر را انجام دهد:

• پیام The first three items in the list are: و سپس به کمک یک برش سه عضو اوّل لیست برنامه را چاپ کند.
• پیام Three items from the middle of the list are: و سپس به کمک یک برش سه عضو میانی لیست برنامه را چاپ کند.
• پیام The last three items in the list are: و سپس به کمک یک برش سه عضو آخر لیست برنامه را چاپ کند.

پیتزاهای من، پیتزاهای تو

با شروع از برنامه‌ی تمرین ۴-۱ یک کپی از لیست پیتزاها ایجاد کنید و آن را friend_pizzas بنامید. سپس این کارها را انجام دهید:

• یک پیتزای جدید به لیست اصلی اضافه کنید. پیام My favorite pizzas are: و در ادامه به کمک یک حلقه‌ی for لیست اول را چاپ کنید. پیام My friend's pizzas are: و با یک حلقه‌ی for لیست دوم را چاپ کنید. مطمئن شوید که هر پیتزا در لیست مناسب ذخیره شده باشد.

حلقه‌های بیشتر

در تمام نسخه‌های foods.py برای صرفه‌جویی در فضا از به‌کارگیری حلقه‌ی for برای چاپ لیست پرهیز شده است. یکی از نسخه‌ها را انتخاب کنید و دو حلقه‌ی for برای چاپ کردن هر کدام از لیست‌ها به آن بیفزایید.

1.4.7 - چندتایی‌ها

لیست‌ها برای ذخیره‌سازی مجموعه‌ای از اعضا مناسب است که ممکن است در طول برنامه تغییر کنند. قابلیّت تغییر دادن لیست‌ها به ویژه زمانی مهم است که بخواهید با فهرستی از کاربران یک وب‌سایت یا شخصیت‌های یک بازی کار کنید. با این حال گاهی به ساختن لیستی نیاز دارید که نباید تغییر کند. چندتایی‌ها چنین امکانی به شما می‌دهند. پایتون به مقادیری که مقدارشان قابل تغییر نیست تغییرناپذیر می‌گوید و لیستِ تغییرناپذیرْ چندتایی نامیده می‌شود.

تعریف کردن یک چندتایی

چندتایی درست مشابه یک لیست است با این تفاوت که برای تعریف آن به جای کروشه از پرانتز استفاده می‌شود. پس از تعریف چندتایی می‌توانید درست همانند یک لیست، با استفاده از شاخصِ هر عضو به مقدار آن دسترسی داشته باشید.

برای مثال اگر مستطیلی داشته باشیم که اندازه‌ی آن همیشه باید ثابت باشد، برای اطمینان از تغییر نیافتن اندازه‌ها می‌توانیم ابعاد آن را در یک چندتایی قرار دهیم:

1
2
3

dimensions = (200, 50)
print(dimensions[0])
print(dimensions[1])

چندتایی dimensions را با استفاده از پرانتز به جای کروشه در 1 تعریف کرده‌ایم. در 2 به کمک همان روشی که برای دسترسی به اعضای لیست استفاده می‌کردیم، هر عضو چندتایی را جداگانه چاپ می‌کنیم:

1
2

200
50

حال ببینیم اگر سعی کنیم یکی از عناصر داخل چندتایی را تغییر دهیم چه اتّفاقی می‌افتد:

1
2

dimensions = (200, 50)
dimensions[0] = 250

کد در 1 سعی می‌کند مقدار اولّین بُعد را تغییر دهد امّا پایتون خطایی مربوط به نوع برمی‌گرداند. دلیل این مساله این است که سعی کرده‌ایم یک چندتایی را تغییر دهیم و این کار برای این نوع مجاز نیست، پایتون می‌گوید که نمی‌توانیم مقدار جدیدی به یکی از اعضای داخل چندتایی نسبت دهیم:

1
2
3
4

Traceback (most recent call last):
  File "dimensions.py", line 2, in <module>
    dimensions[0] = 250
TypeError: 'tuple' object does not support item assignment

این کار به نفع ماست چون انتظار داریم هر گاه خطی در برنامه تلاش کرد ابعاد مستطیل را عوض کند، پایتون اعلام خطا کند.

1

my_t = (3,)

حلقه زدن در تمام مقادیر یک چندتایی

درست همانند کاری که در لیست‌ها انجام می‌دادید، می‌توانید به کمک یک حلقه‌ی for در تمام اعضای یک چندتایی بچرخید:

1
2
3

dimensions = (200, 50)
for dimension in dimensions:
    print(dimension)

پایتون تمام اعضای چندتایی را برمی‌گرداند، درست مانند لیست‌ها:

1
2

200
50

رونویسی یک چندتایی

اگرچه نمی‌توانید محتویات یک چندتایی را تغییر دهید امّا می‌توانید به متغیّری که بیانگر یک چندتایی است، مقدار جدیدی نسبت دهید. بنابراین اگر به تغییر دادن ابعاد نیاز داشتیم می‌توانیم کل چندتایی را دوباره تعریف کنیم:

1
2
3
4
5
6
7
8
9

dimensions = (200, 50)
print("Original dimensions:")
for dimension in dimensions:
    print(dimension)

dimensions = (400, 100)
print("\nModified dimensions:")
for dimension in dimensions:
    print(dimension)

خط‌هایی که از 1 شروع می‌شوند چندتاییِ اوّلیّه را تعریف و آن را چاپ می‌کنند. در 2 یک چندتاییِ جدید به متغیّر dimensions نسبت می‌دهیم. در 3 ابعاد جدید را چاپ می‌کنیم. پایتون این بار خطایی اعلام نمی‌کند زیرا بازنشانی یک متغیّر مجاز است:

1
2
3
4
5
6
7

Original dimensions:
200
50

Modified dimensions:
400
100

چندتایی‌ها در مقایسه با لیست‌ها ساختمان‌های داده‌ی ساده‌ای هستند. هنگامی از آن‌ها استفاده کنید که مجموعه‌ی مقادیرِ موردِ نظرِ شما در طولِ عمرِ برنامه تغییر نمی‌کنند.

خودآزمایی

بوفه

یک رستورانِ بوفه‌ای تنها پنج غذای اصلی ارائه می‌کند. پنج غذای ساده را در نظر بگیرید و نام آن‌ها را در یک چندتایی ذخیره کنید.

• با یک حلقه‌ی for غذاهایی را که رستوران عرضه می‌کند چاپ کنید.
• سعی کنید یکی از مقادیر چندتایی را تغییر دهید و مطمئن شوید پایتون ایجاد تغییرات را رد می‌کند.
• رستوران فهرست غذاها را تغییر می‌دهد و دو غذا را جایگزین می‌کند. یک خط برای بازنویسی چندتایی اضافه کنید و سپس به کمک حلقه‌ی for تمام اعضای فهرستِ بازنگری‌شده را چاپ کنید.

1.4.8 - شکل‌دهی کدها

اکنون که کدهای طولانی‌تری می‌نویسید دانستن مواردی درباره‌ی نحوه‌ی شکل دادن به کدها ارزشمند است. زمانی صرف کنید تا کدهایتان را تا جای ممکن قابل خواندن کنید. نوشتن کدِ خوانا به شما کمک می‌کند تا کاری را که برنامه انجام می‌دهد ردیابی کنید و همچنین دیگران کد شما راحت‌تر بفهمند.

برنامه‌نویسان پایتون بر روی تعدادی از قراردادها و شیوه‌نامه‌ها توافق کرده‌اند تا مطمئن شوند که ساختارِ کدِ هر کس تقریباً به یک شکل است. به محض این که نوشتنِ کدِ تمیزِ پایتون را فراگرفتید، قادر خواهید بود که ساختار کلی برنامه‌ی پایتون هر کس را درک کنید، به شرطی که از یک راهنمای مشترک پیروی کنید. اگر امیدوارید که روزی به یک برنامه‌نویس حرفه‌ای تبدیل شوید، باید هر چه زودتر دنبال کردنِ این راهنماها را آغاز کنید تا تبدیل به عادت‌های خوبی شوند.

شیوه‌نامه

هرگاه کسی بخواهد تغییری در زبان پایتون ایجاد کند یک پیشنهادِ پیشرفتِ پایتون (PEP) می‌نویسد. یکی از قدیمی‌ترین PEPها PEP 8 است که به برنامه‌نویسان پایتون یاد می‌دهد به چه شیوه‌ای کد خود را شکل دهند. PEP 8 نسبتاً طولانی است ولی بیشتر آن مربوط به کدهایی است که از آن‌چه شما تا الان دیده‌اید پیچیده‌ترند.

شیوه‌نامه‌ی پایتون بر اساس این تفکر نوشته شده است که کد بیشتر از آنکه نوشته شود خوانده می‌شود. شما کد را یک بار می‌نویسید و سپس هنگام اشکال‌زدایی خواندن آن را شروع می‌کنید. هنگام افزودنِ یک ویژگیِ جدید به برنامه‌ی خود زمان بیشتری صرف خواندن کد می‌کنید. هنگامی که کد خود را با دیگر برنامه‌نویسان به اشتراک می‌گذارید آن‌ها نیز کد شما را خواهند خواند.

اگر بین نوشتن کدی که راحت‌تر نوشته شود و کدی که راحت‌تر خوانده شود حقّ انتخاب داشته باشید، برنامه‌نویسان پایتون تقریباً همیشه شما را به انتخاب گزینه‌ی دوم تشویق می‌کنند. راهنماهای زیر به شما کمک می‌کنند که از ابتدا کدی شفاف‌تر و واضح‌تر بنویسید.

تورفتگی

PEP 8 به شما توصیه می‌کند برای ایجاد تورفتگی از ۴ فاصله استفاده کنید. استفاده از ۴ فاصله خوانایی برنامه را افزایش می‌دهد و در عین حال امکان ایجاد تورفتگی‌های بیشتر را در هر خط ایجاد می‌کند.

در سندِ یک واژه‌پرداز معمولاً برای ایجاد تورفتگی به جای فاصله از تب استفاده می‌شود. این کار برای اسناد یک واژه‌پرداز مناسب است امّا هنگامی که تب و فاصله را با یکدیگر مخلوط کنید مفسّر پایتون گیج می‌شود. هر ویرایشگر متنی تنظیماتی در اختیار شما می‌گذارد تا بتوانید از دکمه‌ی TAB استفاده کنید امّا در نهایت آن تب‌ها را به تعدادی فاصله تبدیل کند. شما قطعاً می‌توانید از دکمه‌ی TAB استفاده کنید امّا مطمئن شوید که ویرایشگر شما حتماً در فایل شما به جای تب، فاصله درج می‌کند.

ترکیب کردن تب و فاصله در یک فایل ممکن است موجب خطاهایی شود که تشخیص آن بسیار مشکل است. اگر فکر می‌کنید در فایلی ترکیبی از این دو وجود دارد، در بیشتر ویرایشگرها امکان تبدیل تمام تب‌ها به فاصله وجود دارد.

طول خط

بسیاری از برنامه‌نویسان پایتون پیشنهاد می‌کنند که طول هر خط کمتر از ۸۰ حرف باشد. از لحاظ تاریخی این توصیه به این دلیل ایجاد شده که بیشتر رایانه‌ها تنها ۷۹ کاراکتر در هر خط ترمینال جا می‌دادند. در حال حاضر می‌توان حرف‌های بسیار بیشتری در یک خط نمایشگر جا داد امّا دلایل دیگری برای وفادار ماندن به استاندارد خط ۷۹حرفی وجود دارد. برنامه‌نویسان حرفه‌ای گاهی چند فایل را همزمان روی صفحه‌ی خود باز می‌کنند و طول استاندارد خط به آن‌ها اجازه می‌دهد که در دو یا سه فایلی که کنار هم هستند، تمام خط‌ها را ببینند. PEP 8 همچنین توصیه می‌کند طول هر خطِ توضیحی را حداکثر ۷۲ حرف بگیرید زیرا ابزارهایی که برای پروژه‌های بزرگتر به طور خودکار مستندات را تولید می‌کنند در ابتدای هر توضیح چند حرف دیگر اضافه می‌کنند.

راهنمایی‌های PEP 8 در مورد طول خط وحیِ مُنزَل نیست و برخی از گروه‌ها حد ۹۹حرفی را می‌پسندند. در زمان یادگیری لازم نیست خیلی نگران طول خط باشید امّا حواستان باشد که افرادی که به صورت مشارکتی کار می‌کنند معمولاً همیشه از راهنماهای PEP 8 پیروی می‌کنند. بیشترِ ویرایشگرها برای شما یک سرنخ بصری ایجاد می‌کنند که معمولاً یک خط عمودی روی صفحه است و این حدود را به شما نشان می‌دهند.

خط‌های خالی

برای گروه‌بندی بصری بخش‌های مختلف برنامه از خط‌های خالی استفاده کنید. بهتر است از این خط‌ها برای شکل‌دهی به فایل‌های خود استفاده کنید امّا زیاده‌روی نکنید. با دنبال کردن مثال‌های این کتاب به یک نسبت درست خواهید رسید. برای مثال اگر برای ایجاد لیستی چهار یا پنج خط کد نوشته‌اید و بعد از آن سه خط دیگر برای ایجاد لیست دیگری نوشته‌اید بهتر است بین این دو بخش یک خط خالی فاصله بیندازید. با این حال نباید بیش از یک خط خالی، مثلاً چهار یا پنج خط، فاصله ایجاد کنید.

خط‌های خالی شیوه‌ی اجرای برنامه‌ی شما را تغییر نمی‌دهند امّا بر خوانایی برنامه تاثیر می‌گذارند. مفسّر پایتون از تورفتگی افقی برای تشخیص معنای برنامه‌ی شما استفاده می‌کند امّا به فاصله‌گذاری عمودی اهمّیّتی نمی‌دهد.

دیگر شیوه‌نامه‌ها

PEP 8 توصیه‌های متعدّد دیگر هم برای شکل‌دهی دارد امّا بیشتر آن‌ها در برنامه‌هایی کاربرد دارند که پیچیده‌تر از برنامه‌های فعلی شما هستند. همزمان با آموختن ساختارهای پیچیده‌تر پایتون بخش‌های مربوط در راهنماهای PEP 8 را با شما به اشتراک خواهم گذاشت.

خودآزمایی

PEP 8

به شیوه‌نامه‌ی اصلی PEP 8 در آدرس https://python.org/dev/peps/pep-0008/ نگاهی بیندازید. از بیشترِ آن استفاده نخواهید کرد امّا شاید مرور آن جالب باشد.

مرور کد

سه نمونه از برنامه‌هایی را که در این فصل نوشته‌اید انتخاب کنید و آن‌ها را برای تطبیق با PEP 8تغییر دهید:

• از چهار فاصله برای هر سطح تورفتگی استفاده کنید. ویرایشگر متنی خود را تنظیم کنید تا با هر بار فشردن دکمه‌ی TAB چهار فاصله وارد کند. (برای مشاهده‌ی دستورالعمل انجام این کار پیوست ب را ببینید.)
• کمتر از ۸۰ حرف در هر خط استفاده کنید و ویرایشگر خود را برای نمایش یک راهنمای عمودی در موقعیّت ۸۰امین حرف تنظیم کنید.
• در برنامه‌های خود بیش از اندازه از خط خالی استفاده نکنید.

1.4.9 - خلاصه

در این فصل آموختید که چگونه با اعضای یک لیست به طور موثر کار کنید. آموختید که چگونه با یک حلقه‌ی for با اعضای داخل یک لیست کار کنید، پایتون چگونه از تورفتگی برای ساختار دادن به برنامه استفاده می‌کند و چگونه از برخی خطاهای تورفتگی پرهیز کنیم. یاد گرفتید که چگونه لیست‌های عددی تولید کنید و با چند عملیّات ساده آشنا شدید که می‌توان بر روی آن‌ها اعمال کرد. آموختید که چگونه برای کار کردن با زیرمجموعه‌ای از لیست، آن را برش دهیم و چگونه به این روش یک لیست را کپی کنیم. درباره‌ی چندتایی‌ها آموختید که درجه‌ای از محافظت برای مقادیری که نباید تغییر کنند ایجاد می‌کنند. همچنین آموختید برای ساده‌تر کردن خواندن یک کد، چگونه به کدی که به تدریج پیچیده‌تر می‌شود شکل بدهیم.

در فصل پنجم می‌آموزید که چه‌طور به کمک عبارت‌های if به شرایط مختلف واکنش مناسب نشان دهید. یاد می‌گیرید که چگونه مجموعه‌ای نسبتاً پیچیده‌ای از آزمون‌های شرطی را به هم پیوند دهید تا دقیقاً به وضعیّت یا اطّلاعاتی که می‌خواهید پاسخ مناسب دهید. همچنین می‌آموزید که از عبارت‌های if هنگام حلقه زدن در یک لیست استفاده کنید تا بر روی برخی از اعضای مشخّص آن کار خاصّی انجام دهید.

1.5 - گزاره‌های شرطی

1.5.1 - یک مثال ساده

برنامه‌نویسی گاهی مستلزم آزمودن مجموعه‌ای از شرط‌ها و تصمیم‌گیری در مورد عملی است که باید بر اساس آن شرط‌ها اتّخاذ شود. گزاره‌های if در پایتون این امکان را فراهم می‌آورند که حالتِ فعلی برنامه را بررسی کنیم و به آن پاسخی متناسب دهیم.

در این فصل نوشتن آزمون‌های شرطی را برای بررسی هر نوع شرط می‌آموزید. نوشتن گزاره‌های ساده‌ی if و همچنین ساختن دنباله‌ای پیچیده از گزاره‌های if را فراخواهید گرفت تا تشخیص دهید که شرایطی که به طور دقیق تعیین کرده‌اید چه‌زمانی برآورده می‌شوند. سپس همین مفهوم را به لیست‌ها تعمیم می‌دهید و قادر خواهید بود حلقه‌ی for‌ای بنویسید که بیشتر اعضای یک لیست را به یک روش و تعداد مشخّص دیگری را به روشی دیگر مدیریّت کند.

یک مثال ساده

مثال کوتاهی که در ادامه می‌آید نشان می‌دهد که آزمون‌های if چگونه به شما امکان می‌دهند که به شرایط خاصّی به درستی پاسخ دهید. تصوّر کنید که لیستی از خودروها دارید و می‌خواهید اسامی آن‌ها را چاپ کنید. نام خودروها بیشتر نام خاص هستند پس باید آن‌ها را در حالت عنوان (با حروف اوّل بزرگ) چاپ کرد. با این حال مقدار ‘bmw’ باید تماماً با حروف بزرگ چاپ شوند. کد زیر در لیست خودروها حلقه می‌زند و به دنبال مقدار ‘bmw’ می‌گردد. هر گاه به این مقدار رسید آن را به جای حالت عنوان، با حروف بزرگ چاپ می‌کند:

1
2
3
4
5
6
7

cars = ['audi', 'bmw', 'subaru', 'toyota']

for car in cars:
    if car == 'bmw':
        print(car.upper())
    else:
        print(car.title())

حلقه‌ی این مثال در 1 ابتدا بررسی می‌کند که آیا نام فعلی ‘car’ی ‘bmw’ است یا نه؟ اگر چنین باشد این نام را با حروف بزرگ چاپ می‌کند. اگر مقدار car چیزی جز این بود، آن را در حالت عنوان چاپ می‌کند:

1
2
3
4

Audi
BMW
Subaru
Toyota

این مثال برخی از مفاهیمی را که شما در این فصل می‌آموزید، در هم آمیخته است. اکنون به انواع آزمون‌هایی نگاه می‌اندازیم که می‌توانید از آن‌ها برای آزمودنِ شرط‌ها در برنامه‌ی خود استفاده کنید.

1.5.2 - آزمون‌های شرطی

قلب هر گزاره‌ی if عبارتی است که با True و False (درست و نادرست) بودن سنجیده می‌شود و آن را آزمون شرطی می‌نامیم. پایتون از مقدارهای True و False برای تصمیم‌گیری در مورد اجرا شدن کد داخل گزاره‌ی if استفاده می‌کند. اگر یک آزمون شرطی True (درست) ارزیابی شود، پایتون کدی را که بعد از گزاره‌ی if آمده اجرا می‌کند. اگر آزمون False (نادرست) باشد پایتون کدی را که در ادامه‌ی گزاره‌ی if آمده نادیده می‌انگارد.

بررسیِ تساوی

بیشتر آزمون‌های شرطی مقدارِ کنونیِ یک متغیّر را با یک مقدار مشخّصِ موردِ نظر مقایسه می‌کنند. ساده‌ترین آزمون شرطیْ تساویِ مقدارِ یک متغیّر را با یک مقدار دلخواه بررسی می‌کند:

1
2
3

>>> car = 'bmw'
>>> car == 'bmw'
True

خط ۱ مقدار car را به کمک یک علامت تساوی برابر با ‘bmw’ قرار می‌دهد، چنانکه پیش از این در موارد بسیاری آن را دیده‌اید. خط ۲ به کمک دو علامت تساوی (==) بررسی می‌کند آیا مقدار car برابر با ‘bmw’ است یا نه؟ عملگر برابری در صورت یکی بودن مقادیرِ دو طرف خود، True و در غیر این صورت False برمی‌گرداند. مقادیرِ این مثال به هم می‌خورند پس پایتون True برمی‌گرداند.

اگر مقدار car چیزی جز ‘bmw’ باشد، این آزمون False برمی‌گرداند:

1
2
3

>>> car = 'audi'
>>> car == 'bmw'
False

علامت تساوی تکّی در واقع یک حکم است، می‌توانید کد ۱ را به این صورت بخوانید: «مقدار car را برابر با ‘audi’ قرار بده.» از طرف دیگر علامت تساوی دوتایی، مانند ۲، پرسشی مطرح می‌کند: «آیا مقدار car برابر با ‘bmw’ است؟» بیشترِ زبان‌های برنامه‌نویسی از علامت‌های تساوی به همین شکل استفاده می‌کنند.

نادیده گرفتن بزرگ و کوچکی حروف هنگام بررسی تساوی

آزمودن تساوی در پایتون به بزرگی و کوچکی حروف حسّاس است. برای مثال دو کلمه با حروف یکسان امّا بزرگ و کوچکیِ متفاوت، یکسان تلقّی نمی‌شوند:

1
2
3

>>> car = 'Audi'
>>> car == 'audi'
False

اگر بزرگی و کوچکی حروف مهم باشد این روش مفید است. امّا اگر این مسأله اهمّیّتی نداشته باشد و به جای آن می‌خواهید تنها مقدار یک متغیّر را بررسی کنید، می‌توانید مقدار آن را پیش از مقایسه به حروف کوچک تبدیل کنید:

1
2
3

>>> car = 'Audi'
>>> car.lower() == 'audi'
True

این آزمون باید صرف از شکل ‘Audi’ هم True برگرداند زیرا اکنون دیگر به بزرگ و کوچکی حروف حسّاس نیست. تابع lower() مقدار اوّلیّه‌ی ذخیره‌شده در car را تغییر نمی‌دهد، پس می‌توانید این گونه مقایسه‌ها را بدون ایجاد تغییر در مقدار متغیّر انجام دهید:

1
2
3
4
5

>>> car = 'Audi'
>>> car.lower() == 'audi'
True
>>> car
'Audi'

وب‌سایت‌ها قوانین مشخّصی مانند این را بر داده‌هایِ ورودیِ کاربران اعمال می‌کنند. برای مثال سایتی ممکن است از یک آزمون شرطی مانند این استفاده کند تا مطمئن شود کاربر یک نام کاربری واقعاً یکتا دارد، نه صرفاً نام کاربری کس دیگری با تغییری در بزرگی و کوچکی حروف. زمانی که کسی نام کاربری جدیدی را ثبت می‌کند مقدار آن به حروف کوچک تبدیل می‌شود و سپس با تمام نام‌های کاربری موجودِ تبدیل‌شده به حروف کوچک، مقایسه می‌شود. طی چنین آزمونی اگر هر ترکیبی از ‘john’ قبلاً ثبت شده باشد، نام کاربری‌ای مانند ‘John’ رد خواهد شد.

بررسی نابرابری

اگر بخواهید نابرابری دو مقدار را بررسی کنید، می‌توانید از ترکیب یک علامت تعجّب و علامت تساوی (!=) استفاده کنید. علامت تعجّب، مانند بسیاری از زبان‌های برنامه‌نویسی دیگر، بیانگر «نیست» است.

اکنون از یک عبارت if دیگر برای بررسی کاربرد عملگر نابرابری استفاده می‌کنیم. مواد درخواستی برای روی پیتزا را در متغیّری ذخیره می‌کنیم و اگر ماهی کولی سفارش نداده باشد، پیامی خطاب به او صادر می‌کنیم:

1
2
3
4

requested_topping = 'mushrooms'

if requested_topping != 'anchovies':
    print("Hold the anchovies!")

خطّ ۱ مقدار requested_topping را با مقدار ‘anchovies’ مقایسه می‌کند. اگر دو مقدار برابر نباشند پایتون True برمی‌گرداند درنتیجه کدی که در ادامه‌ی گزاره‌ی if آمده اجرا می‌کند. اگر دو مقدار برابر باشند پایتون False برمی‌گرداند و آن خط را اجرا نخواهد کرد.

چون مقدار requested_topping برابر ‘anchovies’ نیست، تابع print() اجرا می‌شود:

1

Hold the anchovies!

بیشترِ عبارت‌های شرطی‌ای که می‌نویسید برابری را بررسی می‌کنند امّا گاهی آزمودن نابرابری را موثّرتر خواهید یافت.

مقایسه‌های عددی

آزمودن مقدارهای عددی بسیار سرراست است. برای مثال کد زیر بررسی می‌کند که آیا شخص ۱۸ ساله است یا نه:

1
2
3

>>> age = 18
>>> age == 18
True

همچنین می‌توانید نابرابری دو عدد را بررسی کنید. مثلاً در کد زیر، در صورتی‌که پاسخ وارد شده درست نباشد، پیامی چاپ می‌شود:

1
2
3
4

answer = 17

if answer != 42:
    print("That is not the correct answer. Please try again!")

آزمون شرطی ۱ قبول می‌شود زیرا مقدار answer (۱۷) برابر با ۴۲ نیست و به همین دلیل کد تورفته اجرا می‌شود:

1

That is not the correct answer. Please try again!

می‌توانید مقایسه‌های ریاضی مختلف دیگری را هم در عبارت‌های شرطی خود بگنجانید، مانند کمتری، کمتری یا برابری، بزرگتری، بزرگتری و برابری:

1
2
3
4
5
6
7
8
9

>>> age = 19
>>> age < 21
True
>>> age <= 21
True
>>> age > 21
False
>>> age >= 21
False

هر مقایسه‌ی ریاضی می‌تواند به عنوان بخشی از یک عبارت if به کار گرفته شود که به شما برای تشخیص شرط‌های دقیق موردنظرتان کمک می‌کند.

1.5.3 - بررسی شرط‌های چندگانه

شاید بخواهید چند شرط را همزمان بررسی کنید. برای نمونه گاهی برای انجام عملی به True بودن همزمان دو شرط نیاز دارید. زمانی دیگر ممکن است ارضا شدن تنها یکی از دو شرط کافی باشد. دو کلیدواژه‌ی and و or می‌تواند شما را در این شرایط یاری کند.

به‌کارگیری and برای بررسی شرط‌های چندگانه

برای بررسی درست (True) بودنِ همزمانِ دو شرط از کلیدواژه‌ی and برای ترکیب دو آزمون شرطی استفاده کنید. اگر هر دو آزمون موفق باشند عبارت کلّی درست (True) خواهد بود. در صورتی که یکی یا هر دوی آزمون‌ها ناموفّق باشند، عبارت کلی نیز نادرست (False) خواهد بود.

برای مثال می‌توانید هنگام بررسی سن دو نفر بفهمید که آیا هر دو بالای ۲۱ سال هستند یا نه:

1
2
3
4
5
6
7

>>> age_0 = 22
>>> age_1 = 18
>>> age_0 >= 21 and age_1 >= 21
False
>>> age_1 = 22
>>> age_0 >= 21 and age_1 >= 21
True

در ۱ دو سن age_0 و age_1 را تعریف می‌کنیم. در ۲ بررسی می‌کنیم که آیا هر دو بالای ۲۱ اند یا نه؟ آزمون سمت چپ موفق است امّا راستی نه، پس کل عبارت نادرست (False) است. در ۳ age_1 را به ۲۲ تغییر می‌دهیم. اکنون مقدار age_1 بیشتر از ۲۱ است پس از دو آزمون شرطی موفّق‌اند، این باعث می‌شود که کل عبارت شرطی درست (True) تلقّی شود.

برای بهبود خوانایی می‌توانید دو طرف هر آزمون شرطی پرانتز قرار دهید، هر چند این کار الزامی نیست. اگر از پرانتز استفاده کنید آزمون شما شبیه به این خواهد بود:

1

(age_0 >= 21) and (age_1 >= 21)

به‌کارگیری or برای بررسی شرط‌های چندگانه

کلیدواژه‌ی or هم امکان بررسی چند شرط را برای شما فراهم می‌آورد با این تفاوت که این بار اگر یکی یا هر دوی شرط‌ها برقرار باشند، کل عبارت پذیرفته می‌شود.

مثال مربوط به سن را در نظر بگیرید. این بار به دنبال این هستیم که بفهمیم آیا تنها یکی از دو نفر بالای ۲۱ سال هست یا نه:

1
2
3
4
5
6
7

>>> age_0 = 22
>>> age_1 = 18
>>> age_0 >= 21 or age_1 >= 21
True
>>> age_0 = 18
>>> age_0 >= 21 or age_1 >= 21
False

از تعریف دو متغیّر مربوط به سن در ۱ شروع می‌کنیم. از آن‌جایی که آزمون مربوط به age_0 درست است، کل عبارت ۲ درست (True) ارزیابی می‌شود. سپس age_0 را به ۱۸ کاهش می‌دهیم. در آزمون ۳، هر دو آزمون رد می‌شوند و عبارت کلّی نادرست (False) تعبیر خواهد شد.

بررسی وجود یک مقدار در یک لیست

گاهی مهم است که پیش از انجام کاری بررسی کنیم که یک لیست مقدار خاصّی را شامل می‌شود یا نه. برای نمونه پیش از تکمیل ثبت نام کاربر در یک وب‌سایت، شاید نیاز داشته باشید که بررسی کنید آیا نام کاربریِ انتخابیِ کاربر در لیست نام‌های کاربری قبلی وجود دارد یا نه.

برای دریافتن این که آیا مقدار خاصّی در لیست وجود دارد از کلیدواژه‌ی in استفاده می‌کنیم. فرض کنید می‌خواهید برای یک پیتزافروشی برنامه‌ای بنویسید. لیستی از مواد درخواستی مشتری برای روی پیتزا تهیّه می‌کنیم و سپس بررسی می‌کنیم که آیا آن‌ها در لیست ما وجود دارد یا نه.

1
2
3
4
5

>>> requested_toppings = ['mushrooms', 'onions', 'pineapple']
>>> 'mushrooms' in requested_toppings
True
>>> 'pepperoni' in requested_toppings
False

در ۱ و ۲، کلیدواژه‌ی in از پایتون می‌خواهد وجود ‘mushrooms’ و ‘pepperoni’ را در لیستِ requested_toppings بررسی کند. این تکنیک بسیار قدرتمند است زیرا می‌توانید به کمک آن لیستی از مقادیر ضروری درست کنید و سپس به آسانی بررسی کنید که مقداری مورد نظر شما با یکی از مقادیر داخل لیست برابری می‌کند یا نه.

بررسی وجود نداشتن یک مقدار در یک لیست

زمانی دیگر ممکن است بخواهید وجود نداشتن مقداری را در لیستی بررسی کنید. در این شرایط می‌توانید از کلیدواژه‌ی not استفاده کنید. برای مثال لیستی از کاربران را در نظر بگیرید که از ارسال نظر در یک انجمن منع شده‌اند. می‌خواهید پیش از ثبت یک نظر بررسی کنید که آیا کاربرِ نظردهنده در لیست کاربران ممنوع وجود دارد یا نه.

1
2
3
4
5
6

banned_users = ['andrew', 'carolina', 'david']

user = 'marie'

if user not in banned_users:
    print(f"{user.title()}, you can post a response if you wish.")

خط ۱ به آسانی خوانده می‌شود. اگر مقدار user در لیست banned_users نبود، پایتون True برمی‌گرداند و کد تورفته را اجرا می‌کند.

کاربر ‘marie’ در لیست ‘banned_users’ نیست پس پیامی می‌بیند که از او برای ارسال نظرش دعوت می‌کند:

1

Marie, you can post a response if you wish.

عبارت‌های بولی

در طی آموختن برنامه‌نویسی جایی به عبارت بولی برخواهید خورد. عبارت بولی تنها نامی دیگر برای آزمون شرطی است. مقدار بولی همانندِ مقدارِ یک عبارتِ شرطی پس از ارزیابی، یا درست (True) است یا نادرست (False).

مقدارهای بولی غالباً برای پیگیری و دنبال کردن شرط‌ها به کار می‌رود، مانند این که آیا بازی می‌تواند اجرا شود یا آیا کاربری می‌تواند مطلب خاصّی را روی وب‌سایت ویرایش کند یا نه:

1
2

game_active = True
can_edit = False

مقدارهای بولی برای پیگیری وضعیّت برنامه یا شرط خاصّی که در برنامه مهم است، راهی موثّر ارائه می‌کنند.

خودآزمایی

آزمون‌های شرطی

تعدادی آزمون شرطی بنویسید. گزاره‌ای برای شرح هر آزمون و پیش‌بینی شما از نتیجه‌ی هر کدام چاپ کنید. کد شما باید چیزی شبیه به این باشد:

1
2
3
4
5
6
7

car = 'subaru'

print("Is car == 'subaru'? I predict True.")
print(car == 'subaru')

print("\nIs car == 'audi'? I predict False.")
print(car == 'audi')

• به دقّت به نتایج خود نگاه کنید و مطمئن شوید که دلیل True یا False شدن هر خط را متوجّه می‌شوید.
• دستِ کم ده آزمون بسازید طوری که حدّاقل پنج تای آن‌ها True و پنج‌تای دیگر False شود.

آزمون‌های شرطی بیشتر

نباید خود را به ساختن تنها ده آزمون شرطی محدود کنید. اگر می‌خواهید مقایسه‌های بیشتری بکنید، آزمون‌های بیشتری بنویسید و آن‌ها را به conditional_tests.py بیفزایید. دست کم یک نتیجه‌ی True و یک نتیجه‌ی False برای هر کدام از موارد زیر داشته باشید:

• آزمون برابری و نابرابری برای رشته‌ها
• آزمون‌هایی با متد lower()
• آزمون‌های عددی شامل برابری و نابرابری، بزرگتری و کوچکتری، بزرگتری و تساوی و کوچکتری و تساوی.
• آزمون‌هایی شامل کلیدواژه‌های and و or
• آزمون وجود عضوی در یک لیست
• آزمون وجود نداشتن عضوی در یک لیست

1.5.4 - گزاره‌های if

زمانی که آزمون‌های شرطی را درک کردید می‌توانید نوشتن گزاره‌های if را آغاز کنید. انواع مختلفی از گزاره‌های if وجود دارد و انتخاب آن‌ها به تعداد شرط‌هایی که نیاز به آزمودن دارند بستگی دارد. در بحث مربوط به آزمون‌های شرطی، مثال‌های متعدّدی از عبارت‌های if دیدید امّا اکنون آن را عمیق‌تر بررسی می‌کنیم.

گزاره‌های if ساده

ساده‌ترین نوع گزاره‌ی if یک آزمون و یک عملکرد دارد:

1
2

if conditional_test:
    do something

می‌توانید هر نوع آزمون شرطی را در خط اوّل و هر آن‌چه را که می‌خواهید انجام دهید در بخش تورفته‌ی بعد از آن بنویسید. اگر آزمون شرطی True ارزیابی شود کدی که بعد از گزاره‌ی if آمده اجرا می‌شود امّا اگر False ارزیابی شود پایتون آن کد را نادیده می‌گیرد.

اکنون متغیّری را برای نمایش سن یک نفر در نظر می‌گیریم و می‌خواهیم بدانیم آیا به سنّ قانونی برای رای دادن رسیده یا نه. کد زیر امکان رای دادن شخص را بررسی می‌کند:

1
2
3
4

age = 19

if age >= 18:
    print("You are old enough to vote!")

در 1 پایتون بررسی می‌کند که آیا مقدار age بزرگتر یا مساوی ۱۸ است یا نه؟ چون این شرط برقرار است پایتون دستور print() تورفته را اجرا می‌کند:

1

You are old enough to vote!

تورفتگی در گزاره‌های if همان نقشی را بازی می‌کند که در حلقه‌های for ایفا می‌کرد. تمام خط‌های تورفته‌ی پس از گزاره‌ی if در صورتِ برقراریِ شرط اجرا خواهند شد و کل این خط‌ها در صورت عدم برقراری نادیده گرفته خواهند شد.

می‌توانید هر تعداد خط که خواستید به بخش بعد از گزاره‌ی if اضافه کنید. بیایید خطّی دیگر به خروجی اضافه کنید و بپرسیم که آیا فرد برای رای دادن ثبت نام کرده است یا نه:

1
2
3
4
5

age = 19

if age >= 18:
    print("You are old enough to vote!")
    print("Have you registered to vote yet?")

شرط برقرار است، هر دو دستور print() تورفته‌اند، پس هر دو خط چاپ می‌شود:

1
2

You are old enough to vote!
Have you registered to vote yet?

اگر مقدار age کمتر از ۱۸ باشد این برنامه هیچ خروجی‌ای نخواهد داشت.

گزاره‌های if-else

اغلب می‌خواهید هنگام برقراری یک شرط کار خاصّی انجام دهید و در صورت عدم برقراری کار دیگری. دستور if-else پایتون چنین امکانی فراهم می‌آورد. ساختار if-else مشابه گزاره‌ی if ساده است امّا گزاره‌ی else به شما اجازه می‌دهد که عملی یا مجموعه‌ای از عمل‌ها را پس از برقرار نشدن شرط اجرا کنید.

مانند مثال قبلی خطاب به کسانی که به سن رای دادن رسیده‌اند پیامی چاپ می‌کنیم امّا این بار به کسانی که به سن قانونی نرسیده‌اند هم پیامی می‌دهیم.

1
2
3
4
5
6
7
8
9

age = 17

if age >= 18:
    print("You are old enough to vote!")
    print("Have you registered to vote yet?")

else:
    print("Sorry, you are too young to vote.")
    print("Please register to vote as soon as you turn 18!")

اگر شرط 1 برقرار شود اوّلین مجموعه‌دستورهای تورفته‌ی print() اجرا می‌شود. اگر آزمون False ارزیابی شود، کد else در 2 اجرا خواهد شد. چون این بار age زیر ۱۸ است، شرط برقرار نمی‌شود و کدی اجرا می‌شود که در بخش else آمده است:

1
2

Sorry, you are too young to vote.
Please register to vote as soon as you turn 18!

این کد به این دلیل کار می‌کند که تنها دو حالت ممکن برای ارزیابی وجود دارد: یا شخص به سن قانونی برای رای دادن رسیده یا نرسیده. در چنین شرایطی که پایتون باید یکی از دو کار ممکن را انجام دهد، ساختار if-else به خوبی کار می‌کند. در یک زنجیره‌ی if-else ساده مانند این، همیشه یکی از دو کار اجرا می‌شود.

1.5.5 - زنجیره‌ی if-elif-else

اغلب نیاز دارید که بیش از دو وضعیّت را بررسی کنید. برای ارزیابی چنین شرایطی می‌توانید از دستور if-elif-else پایتون استفاده کنید. پایتون تنها یکی از بخش‌ها را در زنجیره‌ی if-elif-else اجرا می‌کند. تا زمانی که یکی از آزمون‌ها برقرار شود، پایتون آن‌ها را به ترتیب اجرا می‌کند. به محض برقراری یک شرط، کد مربوط به آن اجرا شده و باقی آزمون‌ها نادیده گرفته می‌شوند.

بسیاری از وضعیت‌ها در دنیای واقعی بیش از دو شرط ممکن دارند. برای مثال یک شهربازی را در نظر بگیرید که نرخ‌های مختلفی برای گروه‌های سنّی مختلف در نظر می‌گیرد:

• پذیرش کودکان زیر ۴ سال رایگان است.
• پذیرش افراد بین ۴ تا ۱۸ سال ۲۵ دلار هزینه دارد.
• پذیرش افراد ۱۸ سال و بالاتر ۴۰ دلار هزینه دارد.

چگونه می‌توانیم از گزاره‌ی if برای تعیین هزینه‌ی پذیرش یک شخص استفاده کنیم؟ کد زیر گروه سنّی فرد را بررسی می‌کند و هزینه‌ی متناسب را چاپ می‌کند:

1
2
3
4
5
6
7
8

age = 12

if age < 4:
    print("Your admission cost is $0.")
elif age < 18:
    print("Your admission cost is $25.")
else:
    print("Your admission cost is $40.")

آزمون if در 1 بررسی می‌کند که آیا سن فرد زیر ۴ سال است یا نه. اگر این چنین باشد پیام مناسب چاپ شده و پایتون بقیه‌ی آزمون‌ها را نادیده می‌گیرد. خط elif در 2 در واقع یک if دیگر است و تنها زمانی اجرا می‌شود که آزمون قبلی موفّق نباشد. در این نقطه از زنجیره می‌دانیم که سن فرد حداقل ۴ سال است زیرا آزمون اول نتیجه نداده است. اگر سن فرد زیر ۱۸ سال باشد پیام متناسب چاپ خواهد شد و پایتون بخش else را نادیده می‌گیرد. اگر هر دو آزمون if و elif برقرار نشوند، کد مربوط به else را در 3 اجرا می‌کند.

در این مثال آزمون 1 False ارزیابی می‌شود پس این بخش از کد اجرا نمی‌شود. امّا آزمون دوم True می‌شود (۱۲ کمتر از ۱۸ است) پس این کد اجرا خواهد شد. خروجی یک جمله است که هزینه‌ی پذیرش فرد را نشان می‌دهد:

1

Your admission cost is $25.

هر سنّی بالاتر از ۱۷ موجب رد شدن هر دو آزمون اوّل می‌شود. در چنین شرایطی بخش else اجرا خواهد شد و هزینه‌ی پذیرش ۴۰ دلار است.

به جای چاپ کردن هزینه در هر بخش از زنجیره‌ی if-elif-else، مختصرتر این است که تنها قیمت را در زنجیره مشخّص کنیم و پس از پایان ارزیابی کامل زنجیره، یک بار دستور print() ساده را فراخوانی کنیم:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

age = 12

if age < 4:
    price = 0
elif age < 18:
    price = 25
else:
    price = 40

print(f"Your admission cost is ${price}.")

خط‌ها در 2،1 و 3 مقدار price را بر اساس سن فرد تعیین می‌کند. پس از تعیین شدن قیمت در زنجیره‌ی if-elif-else، فراخوانیِ جداگانه و بدونِ تورفتگی print()، این مقدار را برای گزارش هزینه‌ی پذیرش فرد نمایش می‌دهد.

خروجی این کد مشابه مثال قبل است امّا مقصود زنجیره‌ی if-elif-else اینجا دقیق‌تر و مختصرتر است. به جای تعیین و چاپ کردن قیمت، تنها قیمت پذیرش را تعیین می‌کند. علاوه بر کارآمدی بیشتر، کد بازبینی‌شده نسبت به رویکرد اولیّه راحت‌تر قابل تغییر است. برای تغییر متن پیام خروجی، به جای تغییر سه print() مجزّا، کافی است تنها یک دستور print() را عوض کنید.

استفاده از چند elif

می‌توانید هر تعداد elif که خواستید در کد خود استفاده کنید. مثلاً اگر شهربازی برای افراد مسن تخفیف قائل شده باشد، می‌توانید یک آزمون شرطی دیگر به کد اضافه کنید تا تشخیص دهید فرد مستحقّ دریافت تخفیف است یا نه. فرض کنید افراد بالای ۶۵ سال باید نصف هزینه‌ی معمول پذیرش، یعنی ۲۰ دلار، را بپردازند:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

age = 12

if age < 4:
    price = 0
elif age < 18:
    price = 25
elif age < 65:
    price = 40
else:
    price = 20

print(f"Your admission cost is ${price}.")

بیشترِ کد دست نخورده است. پیش از تعیین قیمت معمولی ۴۰ دلار، بخش elif دوم در 1 بررسی می‌کند که آیا فرد زیر ۶۵ سال است یا نه. توجّه کنید که قیمت تعیین شده در else (2) باید ۲۰ دلار باشد چون تنها افرادی که به این بخش می‌رسند بالای ۶۵ سال سن دارند.

حذف کردن قسمت else

پایتون الزامی به وجود یک بخش else در پایان زنجیره‌ی if-elif نمی‌بیند. گاهی وجود قسمت else سودمند است؛ گاهی به کار‌گیری یک گزاره‌ی elif اضافی برای دریافتن یک شرط مشخّص مورد نظر، واضح‌تر است:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

age = 12

if age < 4:
    price = 0
elif age < 18:
    price = 25
elif age < 65:
    price = 40
elif age >= 65:
    price = 20

print(f"Your admission cost is ${price}.")

قسمت elif افزوده شده در 1 برای افزاد بالاتر از ۶۵ سال قیمت ۲۰ دلار را تعیین می‌کند. این کار از به‌کارگیری یک قسمتِ else عمومی کمی واضح‌تر است. با این تغییر هر قسمتِ کد با گذراندن یک آزمون شرطی مشخّص اجرا خواهد شد.

قسمت else گزاره‌ای همه‌گیر است و با برقراری هر شرطی به جز آن‌ها که در آزمون‌های مشخّص if یا elif مشخّص شده‌اند، اجرا می‌شود که می‌تواند گاهی شامل داده‌های نامعتبر یا حتّی مخرّب باشد. اگر یک شرط پایانی مشخّص برای آزمودن دارید، حذف کردن قسمت else و اضافه کردن یک elif پایانی را در نظر داشته باشید. در نتیجه شما مطمئن‌تر خواهید بود که کد تنها تحت شرایط درست اجرا می‌شود.

1.5.6 - آزمودن چند شرط

زنجیره‌ی if-elif-else قدرتمند است امّا تنها زمانی کاربرد دارد که بخواهید فقط یک شرط برقرار باشد. به محض برقراری یکی از آزمون‌های شرطی پایتون باقی آزمون‌ها را نادیده می‌گیرد. این رفتار به خاطر کارآمدی سودمند است و آزمودن یک شرط مشخّص را برای شما ممکن می‌سازد.

با این حال گاهی مهم است که تمام شرط‌های مورد نظر را بررسی کنیم. در این حالت باید از تعداد گزاره‌ی if متوالی بدون elif یا else استفاده کنیم. این تکنیک زمانی معنا می‌یابد که بیش از یک شرط امکان تحقّق داشته باشند و بخواهید برای هر شرطی که True شود کاری انجام دهید.

حال مثال پیتزافروشی را دوباره بررسی می‌کنیم. اگر کسی دو نوع مواد مختلف برای روی پیتزای خود سفارش دهد، باید مطمئن شوید که هر دو نوع روی پیتزای او ریخته می‌شود:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

requested_toppings = ['mushrooms', 'extra cheese']

if 'mushrooms' in requested_toppings:
    print("Adding mushrooms.")

if 'pepperoni' in requested_toppings:
    print("Adding pepperoni.")

if 'extra cheese' in requested_toppings:
    print("Adding extra cheese.")

print("\nFinished making your pizza!")

در 1 لیستی شامل مواد درخواستی تعریف می‌کنیم. در گزاره‌ی 2 بررسی می‌کنیم که آیا مشتری برای روی پیتزای خود قارچ سفارش داده یا نه. اگر چنین باشد پیامی برای تایید چاپ می‌شود. آزمونی که در 3 برای پپرونی آورده شده یک گزاره‌ی if ساده است، نه elif یا else، بنابراین کد مربوط به آن، صرف از نظر از برقراریِ شرطِ قبلی، اجرا می‌شود. کد خط 4 بررسی می‌کند که بدون توجّه به آزمون قبلی، آیا پنیر اضافی درخواست شده یا نه. این سه آزمون مستقل با هر بار اجرای برنامه اجرا خواهند شد.

از آن‌جایی که تمام شرط‌ها در این مثال ارزیابی می‌شوند، قارچ و پنیر اضافی هر دو به پیتزا اضافه می‌شوند:

1
2
3
4

Adding mushrooms.
Adding extra cheese.

Finished making your pizza!

اگر از ساختار if-elif-else استفاده می‌کردیم این کد به درستی کار نمی‌کرد، زیرا پس از برقراری یکی از شرط‌ها اجرای آن متوقّف می‌شد. اینجا می‌بینیم که خروجی به چه شکل خواهد بود:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

requested_toppings = ['mushrooms', 'extra cheese']

if 'mushrooms' in requested_toppings:
    print("Adding mushrooms.")
elif 'pepperoni' in requested_toppings:
    print("Adding pepperoni.")
elif 'extra cheese' in requested_toppings:
    print("Adding extra cheese.")

print("\nFinished making your pizza!")

آزمون مربوط به ‘mushrooms’ اولین موردی است که تحقّق می‌یابد پس قارچ به پیتزا اضافه می‌شود. با این حال مقادیر ’extra cheese’ و ‘pepperoni’ هرگز بررسی نمی‌شوند زیرا پس از موفقّیت‌آمیز بودن آزمون اوّل، پایتون کدهای دیگر در زنجیره‌ی if-elif-else را اجرا نمی‌کند. اوّلین مورد درخواستی مشتری اضافه می‌شود امّا دوتای دیگر از قلم خواهند افتاد:

1
2
3

Adding mushrooms.

Finished making your pizza!

به طور مختصر، اگر بخواهید تنها یک قسمت از کد اجرا شود از یک زنجیره‌ی if-elif-else استفاده کنید. اگر قسمت‌های مختلف کد باید اجرا شوند از تعدادی گزاره‌ی if مستقل بهره بگیرید.

خودآزمایی

رنگ‌های موجودات بیگانه ۱

فرض کنید که در یک بازی به یک موجود بیگانه شلیک کرده‌ایم. متغیّری به نام alien_color تعریف کنید و به آن مقدار ‘green’، ‘yellow’ یا ‘red’ را نسبت دهید.

• یک گزاره‌ی if بنویسید تا سبز بودن رنگ موجود بیگانه را بررسی کند. اگر چنین بود پیامی چاپ کند که بازیکن ۵ امتیاز گرفته است.
• یک نسخه از این برنامه را به نحوی بنویسید که در آن شرط برقرار می‌شود. نسخه‌ی دیگر را طوری بنویسید که در آن شرط تحقّق نیابد. (در این نسخه برنامه هیچ خروجی‌ای ندارد.)

رنگ‌های موجودات بیگانه ۲

همانند تمرین ۵-۳ رنگی برای موجودات بیگانه انتخاب کنید و یک زنجیره‌ی if-else بنویسید.

• اگر رنگ موجود بیگانه سبز باشد، پیامی چاپ کند مبنی بر این که بازیکن ۵ امتیاز کسب کرده است.
• اگر رنگ سبز نبود اعلام کند که بازیکن ۱۰ امتیاز گرفته است.
• برنامه را یک بار طوری بنویسید که شرط if برقرار شود و بار دیگر شرط else.

رنگ‌های موجودات بیگانه ۳

زنجیره‌ی if-else مثال ۵-۴ را به if-elif-else تبدیل کنید.

• اگر رنگ موجود بیگانه سبز بود، پیامی چاپ کند که بازیکن ۵ امتیاز گرفته است.
• اگر زرد بود، پیامی چاپ کند که بازیکن ۱۰ امتیاز گرفته است.
• اگر قرمز بود، پیامی چاپ کند که بازیکن ۱۵ امتیاز گرفته است.
• سه نسخه از این برنامه را به نحوی بنویسید که هر بار یکی از شرط‌ها برقرار شود.

مراحل زندگی

یک زنجیره‌ی if-elif-else بنویسید که مشخّص کند فرد در کدام مرحله‌ی زندگی است. مقداری برای متغیّر age تعیین کنید، سپس:

• اگر فرد زیر ۲ سال سن داشت، پیامی چاپ کند که فرد نوزاد است.
• اگر سن بین ۲ تا ۴ سال بود پیامی چاپ کند که فرد نوپاست.
• اگر فرد بین ۴ و ۱۳ سال سن دارد، پیامی چاپ کند که فرد کودک است.
• اگر سن بین ۱۳ و ۲۰ سال است پیامی چاپ کند که فرد نوجوان است.
• اگر سن بین ۲۰ و ۶۵ باشد پیامی چاپ کند که فرد بالغ است.
• اگر سن ۶۵ یا بیشتر بود پیامی چاپ کند که فرد کهنسال است.

میوه‌ی مورد علاقه

لیستی از میوه‌های مورد علاقه‌ی خود درست کنید و تعدادی گزاره‌ی if مستقل بنویسید که وجود میوه‌ی خاصّی را در لیست بررسی کند.

• لیستی از سه میوه‌ی مورد علاقه‌ی خود بسازید و آن را favorite_fruits بنامید.
• پنج گزاره‌ی if بنویسید. هر کدام از آن‌ها بررسی می‌کنند که آیا میوه‌ی خاصّی در لیست وجود دارد یا نه. اگر میوه در لیست بود کد داخل گزاره‌ی if باید جمله‌ای مانند You really like bananas چاپ کند.

1.5.7 - به‌کارگیری گزاره‌های if در لیست‌ها

با ترکیب کردن لیست‌ها و گزاره‌های if می‌توانید کارهای جالبی بکنید. می‌توان مقادیر ویژه‌ای را تحت نظر گرفت که نسبت به دیگر مقادیر موجود در لیست نیاز به عمل متفاوتی دارند، می‌توانید شرایطی را که در حال تغییرند به طور موثری مدیریّت کنید. به تدریج ثابت می‌کنید که کد شما همان‌طور که انتظار دارید تحت هر شرایطی کار می‌کند.

بررسی موارد خاص

این فصل با مثالی ساده آغاز شد که در آن نشان دادیم چگونه مقداری ویژه‌ای مانند ‘bmw’ را مدیریت کنیم به نحوی که در مقایسه با دیگر اعضای لیست به شکل دیگری چاپ شود. اکنون که درکی پایه‌ای از آزمون‌های شرطی و گزاره‌های if کسب کرده‌اید، نگاهی دقیق‌تر به نحوه‌ی تحت نظر گرفتن مقدارهای خاصی در یک لیست می‌اندازیم و این که چگونه آن‌ها را به درستی مدیریت کنیم.

اجازه دهید با مثال پیتزافروشی ادامه بدهیم. این پیتزافروشی همزمان با آماده شدن پیتزا، پیامی نشان می‌دهد که مواد درخواستی به پیتزا اضافه شده است. با ساختن لیستی از مواد روی پیتزا که مشتری درخواست کرده، کد این برنامه بسیار بهینه‌تر نوشته می‌شود. سپس به کمک یک حلقه اعلام می‌کنیم که هر مورد درخواستی به پیتزا اضافه شده است:

1
2
3
4
5
6

requested_toppings = ['mushrooms', 'green peppers', 'extra cheese']

for requested_topping in requested_toppings:
    print(f"Adding {requested_topping}.")

print("\nFinished making your pizza!")

خروجی سرراست است زیرا کد تنها یک حلقه‌ی ساده‌ی for است:

1
2
3
4
5