کتاب آزاد آموزش پایتون¶

تاریخچه¶

داستان [1] پایتون از اواخر سال ۱۹۸۲ میلادی آغاز می‌شود، سالی که آقای روسوم پس از پایان دانشگاه به عنوان یک برنامه‌نویس وارد تیم توسعه‌ زبان ABC در مرکز CWI واقع در آمستردام هلند می‌شود. ABC یک زبان برنامه‌نویسی تفسیر‌شده (Interpreted) با اهداف آموزشی است که از اواخر دهه هفتاد میلادی، تحت پروژه‌ای در این مرکز آغاز شده بود. وی چهار یا پنج سال بعد، زمانی که از پروژه‌ زبان ABC نتیجه‌ مطلوب حاصل نمی‌گردد از آن خارج و به تیم توسعه‌ سیستم عامل آمیب می‌پیوندد. این موضوع از آن جهت دارای اهمیت است که در هنگام کار بر روی این سیستم عامل بود که آقای روسوم به فکر ایجاد یک زبان اسکریپتی (Scripting Language) جدید می‌افتد.

در دسامبر سال ۱۹۸۹ میلادی، تعطیلات کریسمس فرصتی می‌شود تا آقای روسوم به ایده سرگرم کننده‌ [2] خود بپردازد. البته پس از آن نیز زمان زیادی از وقت‌های آزاد خود را برای پیشرفت پروژه‌ای که ”Python“ نامیده بود صرف می‌کند. در این مسیر، تجربه‌ کار بر روی زبان ABC و همینطور مطالعات وی بر روی زبان‌ Modula-3 نقش فراوانی داشته است، در‌ واقع او یک نسخه‌ شخصی از بخش‌های مورد علاقه‌ خود از ABC ایجاد نمود. او یک ماشین مجازی ساده، یک تجزیه‌کننده (پارسرParser) ساده و یک سیستم زمان‌اجرا (Runtime System) ساده ایجاد کرد؛ یک زبان با نحو (سینتکس Syntax) اولیه که از تو‌رفتگی (Indentation) برای بلاک‌بندی بهره می‌برد و از انواع داده [3] دیکشنری، لیست، رشته و اعداد پشتیبانی می‌کرد و بر خلاف ABC توسعه‌پذیر می‌بود.

یک سال بعد آقای روسوم از پایتون در پروژه‌ آمیب استفاده می‌کند؛ نتیجه‌ مطلوب و نیز بازخورد آن در بین همکارانش موجب می‌شود تا وی به بسیاری از بهینه سازی‌های اولیه در پایتون اقدام نماید. این روند ادامه می‌یابد تا اینکه سرانجام در ماه دوم از سال ۱۹۹۱ میلادی این زبان را با نسخه 0.9.0 و تحت پروانه‌ای مشابه با پروانه‌ MIT از طریق یکی از «گروه‌های خبری» (یوزنت Usenet) با عنوان alt.sources منتشر می‌سازد که با استقبال بالایی نیز رو به رو می‌گردد.

منشا انتخاب نام پایتون توسط آقای روسوم برخلاف تصور عمومی یا آنچه که از لوگوی آن مشاهده می‌شود به نوع خاصی از مار مربوط نمی‌شود!؛ در حقیقت این نام برگرفته از یک سریال کمدی تولید انگلستان با عنوان ”Monty Python’s Flying Circus“ می‌باشد که پخش اصلی آن در طی سال‌های ۱۹۶۹ تا ۱۹۷۴ میلادی از شبکه‌ BBC One بوده است.

توصیفی کوتاه¶

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

زبان برنامه‌نویسی پایتون همانطور که اشاره شد در سال ۱۹۹۱ میلادی توسط آقای روسوم خلق شده و توسعه‌ آن نیز زیر نظر مستقیم اوست. آقای روسوم زاده‌ سال ۱۹۵۶ میلادی و نخستین دارنده‌ عنوان BDFL (دیکتاتور خیرخواه جاویدان)‌ می‌باشد و هم اکنون (سال ۲۰۱۵) در شرکت Dropbox مشغول به کار است. (صفحه شخصی)

توسعه‌ پایتون با عصر توسعه و محبوبیت زبان‌های متن باز دیگری همچون Tcl ،Perl و Ruby هم‌ زمان بوده که این امر به پیشرفت و توسعه‌ آن کمک زیادی کرده است.

پایتون یک جامعه‌ کاربری بسیار بزرگ و پویا به همراه خود دارد که عامل پیشرفت و توسعه‌ بسیار مهمی برای هر زبان برنامه‌نویسی به شمار می‌رود. این جامعه هر ساله با برپایی همایش‌های گوناگون در سراسر جهان به تبادل آموخته‌ها می‌پردازد. یکی از رایج‌ترین این همایش‌ها PyCon (پای‌کان) می‌باشد که خوشبختانه ‌در ایران (PyCon Iran یا PyIran) نیز برگزار می‌شود.

این زبان تاکنون توسط شرکت یا سازمان‌های مطرح زیادی مورد استفاده قرار گرفته و در برنامه‌های کاربردی زیادی نیز از آن استفاده شده است که از جمله این موارد می‌توان به: reddit ،Pinterest ،Instagram (شبکه‌های اجتماعی) / Google (موتور جستجوگر و نیز سرویس یوتیوب) / Yahoo (سرویس نقشه) / IBM ،Intel ،Cisco ،Seagate (تست سخت‌افزار) / Dropbox (سرویس میزبانی ابری فایل) / EVE Online (بازی‌های آنلاین) / NASA ،Los Alamos (امور علمی) / iRobot (رباتیک) / Pixar ،Industrial Light and Magic ،Walt Disney (ساخت فیلم‌های انیمیشن) / BitTorrent (اشتراک فایل نظیر به نظیر) / CIA (وب‌سایت) / PayPal (سیستم انتقال پول آنلاین) / Mercurial (سیستم کنترل نسخه) / ESRI (نقشه‌برداری در برنامه GIS) و بسیاری دیگر [4] اشاره نمود. (پایتون در stackshare)

یک نکته مهم در مورد زبان برنامه‌نویسی پایتون، انواع پیاده‌سازی‌ (Implementation)‌ آن است. تا‌کنون از این زبان پیاده‌سازی‌های گوناگون و با اهداف متفاوتی توسعه یافته است که از این بین می‌توان به Jython (خاص ماشین مجازی جاوا)، IronPython (خاص چارچوب NET. مایکروسافت)، PyPy (با هدف سرعت اجرای بیشتر)، Stackless (با هدف اجرای بهتر برنامه‌های چند‌نخی) و البته CPython اشاره نمود. [5]

CPython (سی‌پایتون) پیاده‌سازی استاندارد و اصلی زبان پایتون می‌باشد که با استفاده از زبان برنامه‌نویسی C توسعه می‌یابد. توسط CPython می‌توانید علاوه بر کتابخانه‌ پایتون از کتابخانه‌‌ زبان‌های C و ++C نیز بهره ببرید.

توجه داشته باشید، پایتون (Python) نام یک زبان برنامه‌نویسی است و CPython (یا دیگر پیاده‌سازی‌‌های زبان پایتون) در واقع برنامه‌ایست که توسط آن می‌توان کد منبع (سورس کد Source Code) یک برنامه به زبان پایتون را اجرا نمود. به بیانی دیگر CPython یک پردازنده‌ برای زبان پایتون است.

ویژگی‌ها¶

پایتون یک زبان برنامه‌نویسی رایگان، متن باز (Open Source) و با بیانی کامل‌تر، آزاد است که هم‌‌اکنون (یعنی از نسخه‌ 2.1 و جدیدتر) پروانه‌ آن توسط «بنیاد نرم‌افزار پایتون» PSF اداره می‌گردد. پروانه‌ پایتون سازگار با پروانه‌ GPL3 است، با این حال به برنامه‌نویس این اجازه را می‌دهد که بتواند برنامه‌ای با سورس بسته (Closed Source) تولید نماید.

زبان پایتون از اجزای بسته نرم‌افزاری LAMP نیز به شمار می‌رود. این بسته عبارت است از: Linux ~ سیستم عامل / Apache ~ وب سرور / MySQL یا MariaDB ~ پایگاه‌ داده / Python یا Perl یا PHP ~ زبان برنامه‌نویسی.

این زبان خیلی پیش‌تر از آنکه حتی Eric Raymond و Bruce Perens از Open Source صحبت کنند، متن باز بوده است.

پایتون یک زبان برنامه‌نویسی همه منظوره (General-Purpose) است به این معنی که می‌توان از آن در توسعه طیف گسترده‌ای از انواع برنامه‌ها در حوزه‌های نرم‌افزاری گوناگون بهره برد؛ از جمله در توسعه برنامه‌های تحت وب و برنامه‌هایی با قابلیت «واسط گرافیکی کاربر» (GUI).

پایتون یک زبان برنامه‌نویسی به همراه مجموعه‌ بزرگی از قابلیت‌های از پیش آماده و قابل حمل است که به عنوان کتابخانه‌ استاندارد آن شناخته می‌شود. همچنین در کنار این کتابخانه‌ می‌توان از طیف بسیار وسیعی از کتابخانه‌های شخص ثالث (Third-Party) پایتون [6] نیز بهره برد. کتابخانه‌های شخص ثالث ابزارهای مفیدی را در امور فروانی همچون: برنامه‌نویسی علمی ~ NumPy ،SciPy / پردازش زبان‌های طبیعی ~ NLTK / ارتباط درگاه سریال ~ PySerial / ایجاد بازی ~ PyGame ،Pyglet ،PyOpenGL ،PySoy / هوش مصنوعی ~ PyBrain / ایجاد وب سایت ~ Django ،Flask ،Bottle ،CherryPy / پردازش تصویر ~ PIL/Pillow ،PythonMagick / واسط گرافیکی کاربر ~ PyGtk ،PyQt ،WxPython / کار با اسناد rdflib ~ pdf / رمزنگاری ~ PyCrypto ،pyOpenSSL ،cryptography و بسیاری دیگر… که مدام در حال توسعه هستند و بر تعداد و تنوع آن‌ها نیز افزوده می‌شود را در اختیار برنامه‌نویسان پایتون قرار می‌دهند.

پایتون یک زبان برنامه‌نویسی پویا (Dynamic) بوده و نیز از قابلیت مدیریت خودکار حافظه برخوردار است. این زبان شباهت‌هایی با TCL ،Perl ،Ruby ،PHP یا دیگر زبان‌های برنامه‌نویسی پویا دارد. در این نوع زبان‌ها بر‌خلاف زبان‌های ایستا (Static) مانند C++ ،C و Java نیازی به تعریف صریح نوع متغیرها [7] (Variables) نیست و همچنین نوع متغیر در طول برنامه قابل تغییر است. در زبان‌های پویا متغیرها از خود نوعی ندارند و تصمیم گیری برای تخصیص نوع در «زمان اجرا» (RunTime) انجام می‌پذیرد.

بر خلاف زبان C، در پایتون اختصاص و آزاد‌سازی حافظه (Memory) به صورت خودکار انجام می‌شود. پایتون برای آزاد‌سازی حافظه از دو روش «شمارش ارجاع» (Reference Counting) و «زباله روبی» [8] (Garbage Collection) بهره می‌گیرد. (البته فراموش نشود که صحبت در مورد پیاده‌سازی CPython است)

با اینکه پایتون یک زبان پویاست ولی در عین حال یک زبان «وابسته شدید به نوع» (Strongly Typed) نیز می‌باشد. در این نوع زبان‌ها (به مانند Java) تغییر ناگهانی و خودکار نوع داده (یا شی) انجام نمی‌شود؛ به عنوان نمونه چنانچه در پایتون عمل جمع بین یک نوع داده عددی مانند 3 و یک نوع داده غیر عددی مانند "7" صورت گیرد، یک Exception یا استثنای TypeError گزارش می‌گردد. در مقابل، زبان‌های «وابسته ضعیف به نوع» (Weak Typed) قرار دارند؛ در این زبان‌ها (به مانند Perl) نوع بر حسب موقعیت به صورت خودکار تغییر داده می‌شوند. در این مورد زبان‌های برنامه‌نویسی رفتارهای متفاوتی دارند،‌ به عنوان نمونه حاصل عبارت "7" + 3 در زبان Perl با تبدیل (Convert)‌ خودکار نوع داده غیر عددی "7" به عدد (7)، مقدار 10 محاسبه می‌گردد.

پایتون یک زبان برنامه‌نویسی سطح بالا (High-Level) به مانند C ،Ruby ،PHP و Java است که به وسیله‌ آن عمل برنامه‌نویسی به آسانی و با سرعتی بالا انجام می‌پذیرد و بر‌خلاف زبان برنامه‌نویسی سطح پایینی (Low-Level) مانند Assembly، برنامه‌نویس را درگیر مسایل خاص موجود در این سطح به مانند کار با ثبات‌ها (Registers)، آدرس‌های حافظه و غیره… نمی‌سازد.

پایتون یک زبان برنامه‌نویسی چند‌ الگویی (Multi-Paradigm) است و برنامه‌نویس را مجبور به رعایت الگوی خاصی نمی‌کند. این زبان از الگوهای: دستوری (Imperative) یا رویه‌ای (Procedural)، تابعی (Functional) و شی‌گرایی (Object-Oriented) پشتیبانی می‌کند؛ البته همانظور که گفته شد نمی‌توان پایتون را به صورت خالص (Pure) متعلق به هر یک از این الگوها دانست [10].

جدا از پشتیبانی الگوی برنامه‌نویسی شی‌گرا، ساختار پایتون به صورت کامل شی‌گراست و هر چیزی در این زبان یک شی (Object) است؛ در آینده بیشتر در این مورد صحبت خواهیم کرد.

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

۱- کامپایل سورس کد به بایت‌کد (ByteCode)

۲- تفسیر بایت‌کد به زبان ماشین و اجرای آن

به این صورت که ابتدا سورس کد برنامه‌ به یک زبان میانی نزدیک به زبان ماشین با نام بایت‌کد ترجمه می‌شود و سپس بایت‌کد حاصل به ماشین مجازی (Virtual Machine) - به عنوان موتور زمان‌اجرای پایتون - فرستاده و توسط آن تفسیر و اجرا می‌گردد.

کارایی¶

معمولا افراد در مواجه با یادگیری زبان پایتون نگرانی‌هایی در مورد کارایی (Performance) برنامه‌های توسعه یافته با این زبان خواهند داشت به خصوص در جایگاه مقایسه با زبان Java، به هر حال پایتون یک زبان تفسیر‌شده است و در اجرا سرعت کمتری نسبت به زبان‌های کامپایل‌شده مانند C و Java خواهد داشت. معمولا کارایی بالا برابر با سرعت بالاست ولی قضاوت در مورد کارایی به این سادگی درست نیست!

در هر پروژه‌ای بسته به چیزی که می‌خواهیم می‌بایست انتخاب نماییم. اگر مبنای کارایی برای یک پروژه در سرعت بالای اجرا باشد (مانند برنامه‌های سیستمی)؛‌ زبان C همیشه بهترین انتخاب است ولی اگر مبنا در سرعت بالای توسعه و صرفه جویی در منابع از جمله هزینه باشد انتخاب مناسب پایتون است. گاهی نیز بهترین کارایی با استفاده ترکیبی از زبان‌های متفاوت به دست می‌آید.

در بسیاری از کاربردها سرعت پایتون کاملا قابل قبول است، وجود بایت‌کد‌ موجب افزایش سرعت در اجراهای بعدی برنامه می‌شود و نکات برنامه‌نویسی زیادی برای بهبود سرعت اجرا در پایتون وجود دارد که در این کتاب به تدریج اشاره خواهد شد. نباید فراموش کرد که یکی از مهمترین عامل‌های کارایی داشتن الگوریتمی بهینه است و البته نوشتن ماژول‌ها به زبان C نیز موجب افزایش قابل توجه کارایی پایتون می‌شود - پایتون کند است اگر اشتباه استفاده شود - با این وجود در حالت عادی اگر هزار مورد وجود داشته باشد که پایتون برای آن‌ها بهترین انتخاب باشد، سرعت یکی از آن‌ها نخواهد بود و برای توسعه برنامه‌هایی که سرعت اجرا نقش بسیار تعیین کننده‌‌ای دارد باید از زبان‌های دیگری استفاده نمایید.

لازم است به این نکته هم توجه داشته باشیم که تمام این صحبت‌ها در مورد پیاده‌سازی CPython از زبان پایتون بوده و پیاده‌سازی‌های دیگری نیز از زبان پایتون با هدف سرعت بالای اجرا (به مانند PyPy) توسعه یافته است.

نسخه‌ها¶

هم اکنون دو شاخه از پایتون به صورت موازی (Parallel) در کنار یکدیگر در دسترس هستند: نسخه‌های 2x و 3x.

در یک سیر تاریخی، نسخه‌ پایدار 2.0 در شانزدهم اکتبر سال ۲۰۰۰ میلادی و در ادامه‌ نسخه 1.6 منتشر (Release) می‌شود؛ پس از آن نیز توسعه‌ پایتون به همان صورت پیشین ادامه می‌یابد تا این که در دسامبر سال ۲۰۰۸ میلادی نسخه‌ای از پایتون با شماره‌ 3.0 که از آن با عنوان ”Python 3000“ یا ”Py3K“ نیز یاد می‌شود، با رویکرد شکستن «سازگاری با نسخه‌های پیشین» (Backward Compatibility) منتشر می‌گردد. به بیان دیگر: مفسر نسخه‌های جدید (3x) پایتون قادر به اجرای سورس کدی که بر پایه‌ مفسر نسخه‌های پیشین تهیه شده است، نخواهد بود. (که این اتفاق در جامعه پایتون بسیار بحث برانگیز بوده و هست!)

ظاهرا آقای روسوم خیلی پیش از این زمان نیاز به ایجاد یک سری تغییرات در ساختار و سینتکس این زبان را احساس کرده بود. شاید نخستین نشانه‌ از لزوم ایجاد تغییرات در پایتون را بتوان از صحبت‌های ایشان در همایش متن باز اوریلی (OSCON) سال ۲۰۰۲ با عنوان «پشیمانی‌های پایتون» (Python Regrets) دریافت کرد. به هر صورت تیم توسعه‌ پایتون در پی رفع این نیاز، از بین حفظ گذشته‌ پایتون و پایبندی به فلسفه‌ سادگی آن؛ دومی را انتخاب می‌کند، ویژگی‌های کهنه کنار گذاشته و ویژگی‌های جدید جایگزین می‌گردند.

با انتشار یک نسخه‌ جدید به صورت معمول می‌بایست توسعه‌ نسخه‌ قدیمی متوقف شود، ولی از آنجا که زیر‌ساخت شرکت‌های بزرگی به پایتون وابسته بوده (مانند Google) و ارتقا نسخه برای آن‌ها حداقل بسیار زمان‌بر خواهد شد، برنامه‌ها و کتابخانه‌های کوچک و بزرگ بسیار زیادی توسط کاربران جامعه‌ پایتون برای نیاز‌های ریز و کلان گوناگونی توسعه یافته است که سازگار شدن تمام آن‌ها با نسخه‌ جدید پایتون بعید به نظر می‌رسد و از همه مهم‌تر خود برنامه‌نویسان پایتون می‌باشند که پس از سال‌ها اکنون مجبور هستند کارهای دیروز خود را با سینتکس و در مواقعی حتی با کتابخانه و ماژول‌هایی متفاوت به انجام برسانند؛ تیم توسعه‌ پایتون، برای پر کردن شکاف به وجود آمده بین دیروز و امروز پایتون یا به بیانی هموار کردن مسیر مهاجرت به نسخه‌ جدید پایتون،‌ علاوه بر اینکه از پیش سعی کرده بود تا ویژگی‌های جدید و سینتکس نسخه‌ 3.0 را به نسخه‌ 2.6 (که دو ماه زودتر منتشر شده بود) پورت (Port) کند، به توسعه‌ نسخه قدیمی پایان نمی‌دهد و نسخه‌ دیگری را با شماره‌ 2.7 در سوم جولای ۲۰۱۰، تقریبا یک سال پس از انتشار نسخه‌ 3.1 به همراه بسیاری از ویژگی‌های جدید آن منتشر می‌سازد.

بر طبق سند [13] PEP 404، هرگز نسخه‌ای با شماره‌ 2.8 به صورت رسمی منتشر نخواهد شد و نسخه‌ 2.7 با یک پشتیبانی طولانی مدت، نقطه‌ پایان نسخه‌ قدیمی پایتون خواهد بود. ابتدا قرار شد از این نسخه به مدت پنج سال پشتیبانی (تلاش برای رفع باگ‌ها) شود ولی چند ماه پیش، این زمان به ده سال یعنی تا سال ۲۰۲۰ افزایش یافت.

نسخه‌ پایدار (Stable) پایتون با قالب A.B.C؛ مانند 3.4.2 شماره‌‌گذاری و منتشر می‌شود. عدد A، بخش اصلی (Major) شماره نسخه است و زمانی افزایش می‌یابد که واقعا تغییرات بزرگ و زیادی در زبان پایتون ایجاد شده باشد. عدد B، بخش جزئی (Minor) شماره نسخه را نشان می‌دهد و با ایجاد یک سری تغییرات مهم در زبان پایتون افزایش خواهد یافت. عموما شماره‌ نسخه‌ پایتون تنها به صورت A.B نشان داده می‌شود، زیرا عدد C تنها با رفع اشکال (Bug) احتمالی نسخه‌ منتشر شده افزایش می‌یابد (از عدد صفر) که این امر نیز شامل همه‌ نسخه‌های پایتون نمی‌شود.

کدام نسخه؟ برای شروع یادگیری و اهداف آموزشی نسخه‌ 3x مناسب است و در صورت نیاز تنها با مطالعه‌ مقایسه بین این دو نسخه می‌توانید با نسخه‌ قدیمی نیز آشنا شوید. همچنین اگر قصد توسعه‌ برنامه‌های دسکتاپ را داشته (یعنی زمانی که محدود به نسخه‌ نصب شده بر روی سرور نیستید) یا مواقعی که در ایجاد برنامه‌ خود نیازی به کتابخانه‌هایی که هنوز (اوایل ۲۰۱۵) با نسخه‌ 3x سازگار نشده‌اند (مانند Twisted) را ندارید؛‌ استفاده از نسخه‌ 3x بسیار خوب است. به هر حال تلاش می‌شود که این کتاب بتواند به دور از آشفتگی هر دو نسخه را پوشش دهد.

پی‌نوشت¶

😊 امیدوارم مفید بوده باشه

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

دانلود¶

برای ترجمه و اجرای سورس کد ایجاد شده به زبان پایتون لازم است «بسته نصبی پایتون» (همان CPython یا اگر ساده بگوییم: پایتون) که شامل مفسر، کتابخانه استاندارد، برنامه IDLE (ویرایشگر پیش‌فرض پایتون) و… است را دانلود و بر روی سیستم عامل نصب نماییم.

در هر سیستم عاملی ممکن است پایتون از پیش نصب باشد (خصوصا در گنولینوکس) که در صورت رضایت از نسخه‌ موجود، دیگر لزومی به دانلود و نصب آن نخواهد بود؛ برای آگاهی یافتن از این موضوع می‌توانید دستور python --version را در خط فرمان سیستم عامل وارد نمایید؛ البته در ویندوز به دلیل اینکه عملکرد این دستور وابسته به دستکاری متغیر Path می‌باشد، بهتر است از مسیر Control Panel >‌ Programs and Features اقدام نمایید.

هم اکنون این بسته بر پایه دو نسخه‌ متفاوت پایتون (2x و 3x) از صفحه‌ دانلود آن، متناسب با نوع سیستم عامل و معماری پردازنده قابل دانلود است (اندازه:‌ تقریبا بین ۱۲ تا ۲۵ مگابایت) که برای نصب در ویندوز به شکل یک فایل نصبی (با قالب msi) و متناسب با دو معماری 32 (x86) و 64 (AMD64 ،EM64T ،x64 ،x86-64) بیتی منتشر می‌گردد و در صورت نیاز برای نصب آن در گنو‌لینوکس می‌بایست سورس کد آن (که به زبان C است) را دانلود نمایید.

در هنگام نگارش این درس دو نسخه‌ 2.7.9 و 3.4.2 جدیدترین نسخه‌های منتشر یافته‌ پایتون هستند. برای دسترسی به جدید‌ترین ویژگی‌ها، پیشنهاد می‌شود همیشه جدیدترین نسخه‌ موجود از پایتون را دانلود نمایید.

نصب در ویندوز¶

درست به مانند هر برنامه‌ دیگری در ویندوز، نصب به راحتی تنها با چند بار کلیک بر روی دکمه‌ Next به پایان می‌رسد. پیشنهاد می‌شود مسیر پیش‌فرض نصب (مثلا برای نصب نسخه‌ 3.4.2:‌ \C:\Python34) را تغییر ندهید.

در هنگام نصب نسخه‌‌ای که قصد دارید از آن به صورت نسخه‌ پیش‌فرض پایتون خود استفاده نمایید، به این نکته توجه داشته باشید که در مرحله‌ سفارشی‌سازی (Customize) گزینه‌ افزودن خودکار مسیر مفسر پایتون به متغیر Path ویندوز را فعال نمایید (همانند تصویر پایین). در این صورت با وارد کردن دستور python در خط فرمان ویندوز، مفسر پایتون (این نسخه) فراخوانی می‌شود. برای شروع، با وارد کردن دستور python –V یا python --version می‌توانید از نسخه‌ پایتون نصب شده آگاهی یابید:

> python --version
python 3.4.2

در صورت تنظیم نبودن متغیر Path می‌بایست از طریق پنجره خط فرمان و دستور cd به مسیر نصب مفسر پایتون وارد شوید:

> python --version
'python' is not recognized as an internal or external command, operable program or batch file.

> cd C:\Python34\

> python --version
python 3.4.2

البته امکان دستکاری Path در هر زمانی وجود دارد:

مسیر Control Panel > System > Advanced system settings > Advanced را طی کرده و سپس با کلیک بر روی Environment Variables پنجره‌ جدیدی باز می‌گردد که در قسمت System variables آن Path را پیدا و انتخاب نمایید. بر روی Edit در پایین همان پنجره کلیک کرده و عبارت ;C:\Python34;C:\Python34\Scripts (برای نسخه 3.4) یا ;C:\Python27;C:\Python27\Scripts (برای نسخه 2.7) را به ابتدای متن موجود در قسمت Variable value پنجره‌ جدید وارد و سپس بر روی دکمه‌ OK کلیک نمایید. :)

اگر بخواهیم بر روی یک ویندوز از هر دو شاخه پایتون نسخه‌ای یا حتی چند نسخه‌ متفاوت از هر یک به مانند نسخه‌های 2.6، 2.7، 3.3 و 3.4 را نصب نماییم؛ یک راه خوب برای فراخوانی مفسر پایتونِ هر یک از آن‌ها در خط فرمان ویندوز، استفاده از راه‌انداز پایتون (Python Launcher) می‌باشد. در این راهکار نیازی به دستکاری متغیر Path نیست و از دستور py به جای دستور python استفاده می‌شود؛ به این صورت که با دستور py یا py -2 مفسر آخرین نسخه‌ موجود از شاخه 2x پایتون و با دستور py -3 نیز مفسر آخرین نسخه‌ موجود از شاخه 3x پایتون فراخوانی می‌گردد. برای فراخوانی مفسر دیگر نسخه‌ها هم می‌بایست نسخه‌ آن‌ها به صراحت ذکر گردد (مانند: py -3.3 و py -2.6):

> py --version
2.7.9
> py -2 --version
2.7.9
> py -2.6 --version
2.6.6
> py -3 --version
3.4.2
> py -3.3 --version
3.3.5

نصب در گنولینوکس¶

پایتون معمولا در توزیع‌های گنولینوکس از پیش نصب می‌باشد (بر روی برخی نیز از هر دو شاخه آن نسخه‌ایی نصب است؛ به مانند: Ubuntu و Fedora). برای اطمینان کافی است دستورات python2 --version (برای نسخه 2x) و python3 --version (برای نسخه 3x) را در خط فرمان سیستم عامل وارد نمایید؛ به عنوان نمونه وضعیت نسخه‌های پایتون در Ubuntu 14.04 به صورت پایین است:

user> python --version
python 2.7.6

user> python2 --version
python 2.7.6

user> python3 --version
python 3.4.0

اکنون با فرض اینکه توزیع مورد استفاده‌‌، از پیش فاقد نسخه‌ 3x بوده یا اینکه نسخه‌ نصب شده آنقدر قدیمی است که می‌بایست آن را ارتقا (Upgrade) داد؛ پس از دانلود سورس کد نسخه‌ جدید (در این زمان فایل: Python-3.4.2.tar.xz) به صورت زیر عمل خواهیم کرد (نصب نسخه‌ 2x نیز به همین شکل است):

نخست می‌بایست تمام بسته‌های پیش‌نیاز در سیستم عامل نصب گردند. برای این منظور می‌توانید دستورات پایین را (متناسب با نوع توزیع خود) در خط فرمان سیستم عامل وارد نمایید:

در Fedora:

user> sudo dnf update
user> sudo dnf install make automake autoconf pkgconfig glibc-devel gcc gcc-c++ bzip2 bzip2-devel tar tcl tcl-devel tix tix-devel tk tk-devel zlib-devel ncurses-devel sqlite-devel openssl-devel openssl readline-devel gdbm-devel db4-devel expat-devel libGL-devel libffi-devel gmp-devel valgrind-devel systemtap-sdt-devel xz-devel libX11-devel findutils libpcap-devel

در Ubuntu:

user> sudo apt-get update
user> sudo apt-get install build-essential
user> sudo apt-get install make automake autoconf pkg-config libc6-dev gcc g++ bzip2 libbz2-dev tar tcl tcl-dev tix-dev tk tk-dev zlib1g-dev libncursesw5-dev libsqlite3-dev libssl-dev openssl libreadline-dev libgdbm-dev db4.8-util libexpat1-dev libgl-dev libffi-dev libgmp3-dev valgrind systemtap-sdt-dev xz-utils libX11-dev findutils libpcap-dev

پس از اطمینان از نصب بسته‌های پیش‌نیاز به مسیری که سورس کد پایتون (پس از دانلود) در آن قرار دارد رفته (در اینجا: دایرکتوری Downloads) و فایل سورس کد را از حالت فشرده خارج نمایید. حاصل کار یک دایرکتوری جدید با نامی مشابه Python-3.4.2 است که با استفاده از دستور ls قابل مشاهده است؛ اکنون می‌بایست از طریق خط فرمان و دستور cd وارد مسیر آن شوید.

user> cd Downloads/
user> ls
Python-3.4.2.tar.xz

user> tar xf Python-3.4.2.tar.xz

user> ls
Python-3.4.2  Python-3.4.2.tar.xz

user> cd Python-3.4.2/

در پایان دستورات پایین را به ترتیب وارد نمایید:

user> sudo ./configure
user> sudo make
user> sudo make install

اگر پیش از این نسخه‌ای از شاخه 3x پایتون نصب باشد (مانند 3.3)، دستور سطر سوم موجب جایگزین شدن نسخه‌ جدید (3.4) با آن می‌شود؛ این دستور در مواقع ارتقا نسخه پایتون مفید است. چنانچه قصد دارید همچنان به نسخه‌ پیشین نیز دسترسی داشته باشید، دستور make altinstall را جایگزین make install نمایید. به عنوان نمونه وضعیت نسخه‌ 3x پایتون، در زمان‌ قبل و بعد از نصب نسخه‌ جدید به همراه مسیر نصب آن در Fedora 20 آورده شده است. به تفاوت عملکرد دو دستور make altinstall و make install توجه نمایید:

گرفتن نسخه‌های از پیش نصب:

user> python --version
Python 2.7.5

user> python2 --version
Python 2.7.5

user> python3 --version
Python 3.3.2

گرفتن مسیر و نسخه‌ پایتون 3x پس از نصب نسخه 3.4.2 با استفاده از دستور make altinstall :

user> which python3
/usr/bin/python3

user> which python3.4
/usr/local/bin/python3.4

user> python3 --version
Python 3.3.2

user> python3.4 --version
Python 3.4.2

گرفتن مسیر و نسخه‌ پایتون 3x پس از نصب نسخه 3.4.2 با استفاده از دستور make install :

user> which python3
/usr/local/bin/python3

user> which python3.4
/usr/local/bin/python3.4

user> python3 --version
Python 3.4.2

user> python3.4 --version
Python 3.4.2

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

user> sudo ./configure --prefix=/opt/python3.4
user> sudo make
user> sudo make install

در صورت استفاده از این روش، مفسر پایتون نسخه نصب شده را می‌توان مشابه هر یک از دو دستور زیر (با ذکر مسیر نصب - در اینجا: opt/python3.4/)‌ فراخوانی نمود:

user> /opt/python3.4/bin/python3 --version
Python 3.4.2
user> /opt/python3.4/bin/python3.4 --version
Python 3.4.2

برای راحتی در فراخوانی می‌توانید نشانی دایرکتوری مفسر پایتون را به متغیر محیطی Path سیستم عامل اضافه نمایید. برای این کار فایل پنهان bashrc. (البته چنانچه از پوسته پیش‌فرض یعنی bash استفاده می‌کنید) موجود در دایرکتوری home (مسیر ~) را توسط یک ویرایشگر متن، باز نموده و عبارتی مشابه پایین را در آن وارد و سپس تغییر ایجاد شده را ذخیره (Save) نمایید:

export PATH=$PATH:/opt/python3.4/bin

اکنون برای فراخوانی پایتون نصب شده دیگر نیازی به وارد کردن مسیر آن نمی‌باشد ولی به خاطر داشته باشید به دلیل وجود نسخه 3x ای که از پیش نصب بوده (در اینجا: 3.3.2) لازم است نسخه جدید را با ذکر صریح نسخه فراخوانی نمایید:

user> python3 --version
Python 3.3.2
user> python3.4 --version
Python 3.4.2

سیستم مدیریت بسته¶

pip (پِپ) سیستم مدیریت بسته‌‌ پایتون است. pip ابزاری است مبتنی بر خط فرمان که از آن برای نصب، حذف، بروز رسانی و در کل مدیریت بسته‌های (یا کتابخانه‌ها‌ی شخص ثالث) پایتون استفاده می‌گردد. برنامه‌نویس پس از یافتن بسته‌ مورد نیاز خود در PyPI یا وب‌سایت‌ها و سرویس‌های دیگری به مانند github.com و bitbucket.com می‌تواند به وسیله دستور pip در خط فرمان، اقدام به نصب آن در پایتون نماید.

pip از زمان انتشار نسخه‌ 3.4 به بسته‌ نصبی پایتون افزوده شده است و به همراه آن نصب می‌شود ولی در صورت نیاز به pip برای نسخه‌های قدیمی‌تر، می‌بایست آن را به صورت جداگانه‌ نصب نمایید.

برای نصب pip لازم است تا فایل get-pip.py را دانلود نمایید.

سپس به وسیله‌ دستوری مشابه python get-pip.py در خط فرمان، با سطح کاربری Administrator (در ویندوز) یا root (در گنولینوکس) می‌توانید اقدام به نصب pip نمایید. فراموش نشود، در زمان نصب نیاز به اتصال اینترنت می‌باشد.

برای نمونه؛ با فرض دانلود بودن get-pip.py و قرار داشتن آن در دایرکتوری Downloads سیستم عامل،‌ برای نصب pip در نسخه 3x (مثلا قدیمی!) پایتون به صورت پایین عمل می‌نماییم:

در گنولینوکس:

user> cd Downloads/
user> sudo python3 get-pip.py

[...]
Successfully installed [...]

user> pip3 --version
pip 7.0.1 [...]

در ویندوز:

> cd Downloads\
> python get-pip.py

[...]
Successfully installed [...]

> pip --version
pip 7.0.1 [...]

توجه داشته باشید که پیش از این، محل نصب پایتون نسخه 3x به ترتیبی که گفته شد به متغیر Path ویندوز افزوده بودیم و cmd نیز به صورت Administrator اجرا شده است.

کار با pip بسیار آسان است. به عنوان نمونه برای نصب Bottle که یک وب فریم‌ورک (Web Framework) برای پایتون است از دستور pip install bottle استفاده می‌گردد. با وارد کردن این دستور، Bottle در PyPI (به عنوان مخزن پیش‌فرض pip) جستجو می‌شود و پس از یافتن، ابتدا دانلود، سپس نصب و به دایرکتوری site-packages پایتون افزوده می‌شود.

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

• نصب آخرین نسخه از یک بسته:

  # pip install [package name]
  
  root> pip install SomePackage
  

• نصب یک نسخه خاص از یک بسته:

  # pip install [package name]==[version]
  
  root> pip install SomePackage==1.0.4
  

• حذف یک بسته:

  # pip uninstall [package name]
  
  root> pip uninstall SomePackage
  

• بروز رسانی یک بسته:

  # pip install --upgrade [package name]
  
  root> pip install --upgrade SomePackage
  

  برای بروز رسانی خود pip نیز از همین الگو استفاده می‌شود: pip install --upgrade pip

  البته در ویندوز می‌بایست از دستور python -m pip install -U pip استفاده نمایید.

  به جای upgrade-- می توانید از U- نیز استفاده نمایید.

• گرفتن فهرست تمام بسته‌های نصب شده:

  user> pip list
  

• گرفتن فهرست تمام بسته‌هایی که می‌بایست بروز رسانی شوند:

  user> pip list --outdated
  

• مشاهده جزییات یک بسته نصب شده:

  # pip show [package name]
  
  user> pip show SomePackage
  

• نصب تمام بسته‌هایی که درون یک فایل متنی به مانند requirements.txt مشخص شده است (فایل نمونه):

  root> pip install -r requirements.txt
  

😊 امیدوارم مفید بوده باشه

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

ساختار پروژه¶

نخستین گام در توسعه‌ یک برنامه پایتون ایجاد یک پروژه است که پس از آن نوشتن کدها یا ایجاد سورس کد (Source code) برنامه آغاز می‌شود.

سورس کد یک پروژه به زبان پایتون در قالب یک یا چند «ماژول» (Module) توسعه می‌یابد که در سورس کدهایی با بیش از یک ماژول بهتر است ماژول‌هایی که از نظر منطقی با یکدیگر مرتبط هستند را درون دایرکتوری‌هایی مجزا قرار دهیم که به این نوع دایرکتوری‌ها در زبان پایتون «بسته» (Package) گفته می‌شود.

در تعریف زبان پایتون دو نوع ماژول وجود دارد:

۱- Pure Module (ماژول ناب)، همان تعریف عادی از ماژول پایتون است؛ فایل‌هایی با پسوند py که کد (تعاریف و دستورات) پایتون در آن‌ها نوشته می‌شوند.

۲- Extension Module (ماژول توسعه)، ماژول‌هایی که توسط زبان‌های برنامه‌نویسی دیگری به غیر از پایتون ایجاد شده‌اند. از درس یکم به خاطر داریم که پایتون یک زبان توسعه‌پذیر است و در کنار آن می‌توان از کد‌های نوشته شده با دیگر زبان‌های برنامه‌نویسی استفاده نمود: به مانند C و ++C در پیاده‌سازی CPython یا Java در پیاده‌سازی Jython یا #C در پیاده‌سازی IronPython - [ایجاد و استفاده از این نوع ماژول در درسی جداگانه بررسی خواهد شد.]

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

SampleProject
.
├── sample_project.py
├── module_one.py
└── pakage/
    ├── __init__.py
    ├── module_two.py
    └── module_three.py

در ایجاد سورس کد باید به صورتی عمل شود که با اجرای یک ماژول‌ مشخص تمام برنامه اجرا گردد. این ماژول معمولا هم نام پروژه در نظر گرفته و با عنوان «اسکریپت» (Script) از آن یاد می‌شود (اینجا:‌ sample_project.py). در واقع اسکریپت، ماژولی است که با هدف اجرای برنامه توسعه می‌یابد و ایجاد سورس کد نیز از آن شروع می‌گردد. از طرفی همانطور که می‌دانیم یکی از ویژگی‌های پایتون امکان برنامه نویسی ماژولار (Modular) است به این صورت که می‌توان کد‌های خود را بر حسب نیاز در ماژول‌هایی جداگانه نوشت و با وارد کردن (Import) آن‌ها در اسکریپت (یا ماژول‌های دیگر) از کد درون آن‌ها استفاده نمود. با این منطق می‌شود سورس کد یک پروژه از پایتون را تنها شامل یک اسکریپت تصور کرد که می‌تواند توسط تعدادی ماژول گسترش یابد؛ البته ممکن است ماژول‌ها نیز بر حسب نیاز در بسته‌هایی جداگانه قرار گرفته باشند.

اکنون اطلاعات کافی برای شروع یک پروژه از پایتون را دارید ولی چنانچه می‌خواهید با ساختار مناسب پروژه‌ای که قرار است برای استفاده افراد دیگر از طریق PyPI یا سرویس‌هایی نظیر github.com منتشر شود (مانند یک کتابخانه کاربردی) آشنا شوید، ادامه این بخش را نیز مطالعه نمایید. در غیر این صورت می‌توانید به بخش بعدی از همین درس پرش نمایید.

جدا از سورس کد لازم است موارد دیگری نیز در ساختار این نوع پروژه‌ها در نظر گرفته شود؛ به ساختار پایین توجه نمایید:

SampleProject
.
├── docs/
├── LICENSE.txt
├── MANIFEST.in
├── README.rst
├── requirements.txt
├── sampleproject/
│   ├── __init__.py
│   ├── module_one.py
│   ├── pakage/
│   │   ├── __init__.py
│   │   ├── module_two.py
│   │   └── module_three.py
│   ├── sample_project.py
│   └── test/
├── setup.cfg
└── setup.py

ساختار ابتدایی تنها شامل سورس کد می‌بود ولی در این ساختار تمام سورس کد در قالب یک بسته پایتون بخشی از مجموعه بزرگتری است که در آن یک سری فایل به مانند requirements.txt ،README.rst و setup.py به همراه دو دایرکتوری docs و test افزوده شده است. در ادامه کمی از کاربرد این موارد توضیح داده می‌شود ولی تاکید می‌شود که در حال حاضر نیازی به رعایت این ساختار نیست و در انتهای کتاب با ایجاد یک پروژه عملی و قرار دادن آن بر روی github.com و PyPI به صورت کاربردی با آن‌ها آشنا خواهید شد. [برای کسب اطلاعات بیشتر می‌توانید از اسناد پایتون استفاده نمایید]

setup.py: این فایل مهم دو کارکرد دارد: ۱- پیکربندی پروژه که از طریق آرگومان‌های تابع آماده ()setup درون این فایل صورت می‌پذیرد. ۲- یک رابط خط فرمان برای اجرای دستورات کاربردی مرتبط با پروژه (الگویی مشابه: <python setup.py <commands).

فهرست این دستورات از طریق وارد کردن دستوری مشابه python setup.py --help-commands قابل مشاهده است.

setup.cfg: ساختاری شبیه به یک فایل ini داشته و در صورت نیاز گزینه‌های مربوط به دستورات خط فرمان setup.py در این فایل تعریف می‌گردند. برای مشاهده فهرست گزینه‌های یک دستور مشخص می‌توانید از الگوی <python setup.py --help <commands پیروی نمایید.

README.rst: تمام پروژه‌ها می‌بایست شامل سندی برای توصیف خود باشند. در پایتون برای ایجاد اسناد معمولا از زبان نشانه‌گذاری reStructuredText استفاده می‌گردد و به همین دلیل این اسناد پسوند rst دارند که البته اجباری به این مورد نیست و می‌توانید برای ایجاد این فایل از Markdown (پسوند md) نیز استفاده نمایید.

MANIFEST.in: معمولا از این فایل برای معرفی فایل‌های غیر پایتونی موجود در پروژه استفاده می‌شود. زمانی که قصد ایجاد «سورس توزیع» یا sdist از پروژه را داشته باشید (دستوری مشابه: python setup.py sdist) تنها فایل‌های مشخصی از پروژه شناسایی می‌شوند و شناساندن باقی فایل‌ها (در صورت وجود) می‌بایست توسط این فایل (البته با الگویی خاص) انجام گیرد.

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

LICENSE.txt: این فایل پروانه‌ انتشار پروژه را شامل می‌شود و اغلب حاوی یک کپی از متن پروانه‌های متن باز رایج به مانند MIT ،GPL یا BSD می‌باشد.

docs: در این دایرکتوری اسناد (راهنما، آموزش و…) پروژه قرار داده می‌شوند. ایجاد این اسناد توسط Sphinx در درسی جداگانه بررسی خواهد شد.

test: این دایرکتوری محل نگهداری برنامه تست پروژه می‌باشد. ایجاد تست پروژه نیز در درسی جداگانه بررسی می‌گردد. این دایرکتوری می‌تواند هم در بالا ترین شاخه از پروژه و هم در داخل دایرکتوری سورس کد قرار داده شود.

با ایجاد یک توزیع (Distribution) از این ساختار و انتشار آن [که در آینده خواهید آموخت]، امکان نصب پروژه از طریق pip به وجود می‌آید. معمولا به جای واژه «توزیع» از واژه «بسته» (Package) استفاده می‌گردد؛ همانطور که pip نیز «سیستم مدیریت بسته پایتون» نامیده می‌شود و هیچگاه نباید آن را با مفهوم «بسته» که تا پیش از این مطرح شده است اشتباه گرفت.

ایجاد سورس کد¶

برای ایجاد فایل‌های سورس کد (ماژول‌ها و اسکریپت) نیاز به هیچ برنامه یا ابزار خاصی نیست و تنها با استفاده از یک ویرایشگر ساده متن (مانند برنامه Notepad در ویندوز) می‌توانید آن‌ها را ایجاد و ویرایش نمایید.

در ادامه پروژه‌ای به نام FirstProject که سورس کد آن تنها شامل یک اسکریپت است را ایجاد می‌نماییم. وظیفه این اسکریپت فرستادن حاصل عبارت 4÷(6×5-50) به خروجی (Output) خواهد بود.

برنامه‌ ویرایشگر متن پیش‌فرض سیستم عامل را اجرا نموده و به کمک آن یکی از کدهای پایین را (متناسب با نسخه پایتون مورد نظر خود) در فایلی با نام مشابه first_project و پسوند py نوشته و بر روی دیسک (در مسیر دایرکتوری Documents سیستم عامل) ذخیره می‌نماییم.

برای نسخه 2x، ساختار FirstProject و محتوای فایل first_project_2x.py را به صورت پایین در نظر می‌گیریم:

FirstProject
.
└── first_project_2x.py

1
2
3
4
5
6
7

#-*- coding: utf-8 -*-

# Python 2.x
# File Name: first_project_2x.py
# This script prints a value to the screen.

print "(50-5×6)÷4 =", (50-5*6)/4

و برای نسخه 3x، ساختار FirstProject و محتوای فایل first_project_3x.py را به صورت پایین در نظر می‌گیریم:

FirstProject
.
└── first_project_3x.py

1
2
3
4
5

# Python 3.x
# File Name: first_project_3x.py
# This script prints a value to the screen.

print("(50-5×6)÷4 =", (50-5*6)/4)

در بخش بعدی به اجرای سورس کد FirstProject خواهیم پرداخت؛ در این بخش بهتر است کمی به بررسی کدهای آن بپردازیم:

متن ماژول‌های پایتون 2x به صورت پیش‌فرض از استاندارد یونیکد (Unicode) پشتیبانی نمی‌کنند و توسط اسکی (ASCII) کدگذاری (Encoding) می‌شوند که تنها امکان استفاده از ۱۲۸ کاراکتر را می‌دهد. می‌توان با افزودن سطری مطابق الگوی -*- coding: encoding -*-# در ابتدای ماژول‌های پایتون (سطر یکم یا دوم) شیوه کدگذاری را به شکل دلخواه تعیین نماییم. [PEP 263]

بر همین اساس کدگذاری اسکریپت first_script_2x.py را به دلیل استفاده از کاراکترهایی خارج از مجموعه ASCII (÷ و ×) به UTF-8 تغییر داده‌ایم. پایتون 3x به صورت پیش‌فرض از استاندارد یونیکد پشتیبانی می‌کند.

در زبان پایتون هر متنی که بعد از کاراکتر ”Number sign“ یا # (در همان سطر) قرار بگیرد توسط مفسر پایتون نادیده گرفته می‌شود و تاثیری در روند ترجمه و اجرای کدها ندارد، به این نوع متن‌ «توضیح» (کامنت Comment) گفته می‌شود و از آن برای مستندسازی (Documentation) ماژول یعنی ارایه توضیح در مورد بخشی از کد استفاده می‌گردد. ارایه توضیح نقش زیادی در خوانایی ماژول دارد و کمک می‌کند تا افراد دیگر - حتی خودتان - بتوانند عملکرد کدهای ماژول (یا اسکریپت) شما را بفهمند.

سطرهای خالی (Blank Lines) نیز توسط مفسر پایتون نادیده گرفته می‌شوند و تاثیری در روند ترجمه و اجرای کدها ندارند. استفاده درست از سطرهای خالی بر خوانایی کدهای ماژول می‌افزاید.

روش رایج فرستادن داده به خروجی (اینجا:‌ چاپ بر روی صفحه نمایش) در پایتون، استفاده از دستور print (در نسخه 2x) یا تابع ()print (در نسخه 3x) است. بارزترین تفاوت نسخه 3.0 پایتون با نسخه‌های پیش از خود،‌ تبدیل دستور print به تابع (Function) می‌باشد. برای تابع، داده درون پرانتز قرار داده می‌شود. [در درسی جداگانه به بررسی تابع‌ها در پایتون خواهیم پرداخت]

دستور (یا تابع) print توانایی دریافت هر تعداد داده و از هر نوع را دارد و در صورت دریافت یک عبارت محاسباتی (Arithmetic) یا منطقی (Logical) ابتدا حاصل آن را محاسبه یا ارزیابی کرده و پس از تبدیل به نوع داده string در خروجی قرار می‌دهد. در هنگام فرستادن چندین داده گوناگون به خروجی می‌بایست آن‌ها را توسط کاما (Comma) از یکدیگر جدا نماییم. در اینجا نیز print دو داده برای فرستادن به خروجی دریافت کرده است؛ یک نوع داده string و یک عبارت محاسباتی.

به دنباله‌ای از کاراکترها که بین دو نماد نقل قول (Quotation) یا " " محصور شده‌ باشند، string گفته می‌شود.

اجرای سورس کد¶

در حالت کلی به دو شیوه می‌توان به زبان پایتون کد نوشت و اجرا نمود: ۱- به حالت تعاملی (Interactive) با مفسر پایتون ۲- با ایجاد اسکریپت پایتون.

شیوه تعاملی: در این روش می‌بایست ابتدا دستور فراخوانی مفسر پایتون (حالت عمومی دستور: python) را در رابط خط فرمان سیستم عامل وارد نمایید؛ توسط این دستور خط فرمان وارد حالت تعاملی پایتون می‌شود و اکنون به سادگی می‌توانید شروع به کد‌نویسی نمایید. در این حالت هر کدی که وارد شود بلافاصله اجرا شده و در صورت لزوم نتیجه آن نیز نمایش داده می‌شود. از آنجا که در این روش امکان برگشت و ویرایش کدهای وارد شده وجود ندارد، در عمل زیاد کارآمد نبوده و از آن بیشتر در مواردی مانند گرفتن نتیجه‌ قطعه کدهای کوچک، اهداف آموزشی، دریافت راهنمایی یا ماشین حساب! استفاده می‌گردد. چگونگی کار با حالت تعاملی پایتون در درس بعدی بررسی می‌شود.

user> python
Python 2.7.9 (default, Jan 12 2015, 12:41:47)
[GCC 4.9.2 20141101 (Red Hat 4.9.2-1)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>
>>> a = 3
>>> b = 2
>>> a * b
6
>>>

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

برای اجرای اسکریپت می‌بایست در خط فرمان سیستم عامل دستور فراخوانی مفسر پایتون را به همراه نام کامل اسکریپت (نشانی + نام + پسوند) وارد نمایید.

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

user> python2 Documents/FirstProject/first_project_2x.py
(50-5×6)÷4 = 5

user> python3 Documents/FirstProject/first_project_3x.py
(50-5×6)÷4 = 5.0

اگر به حاصل عبارت 4÷(6×5-50) در خروجی دو اسکریپت دقت کرده باشید حتما متوجه تفاوت آن شده‌اید. پایتون 2x حاصل تقسیم دو عدد صحیح (Integer) را به صورت یک عدد صحیح محاسبه و از مقدار بعد از ممیز (در صورت وجود) صرف نظر می‌کند ولی پایتون 3x همواره حاصل تقسیم را به صورت یک عدد اعشاری (Floating Point) و با دقتی بیشتر بر می‌گرداند. باز هم در این مورد صحبت خواهیم کرد.

نتیجه اجرای دو اسکریپت یاد شده در هر سیستم عاملی همان است که در بالا مشاهده می‌نمایید. چنانچه کاربر سیستم عامل ویندوز هستید به این نکته توجه داشته باشید که به دلیل وجود کاراکترهای خاصی (÷ و ×) که قرار است توسط print بر روی خط فرمان نمایش داده شوند و همچنین عدم پشتیبانی پیش‌فرض خط فرمان ویندوز از کدگذاری UTF-8، به هنگام اجرای اسکریپت خطایی گزارش می‌شود که ارتباطی با کد پایتون ندارد. در این مواقع پیشنهاد می‌شود از پایتون 3x و برنامه PowerShell استفاده نموده و پیش از اجرای اسکریپت دستور chcp 65001 را وارد نمایید - به صورت پایین:

PS > chcp 65001
Active code page: 65001

PS > python Documents\FirstProject\first_script_3x.py
(50-5×6)÷4 = 5.0

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

معمولا در گنولینوکس سطری به مانند پایین به ابتدای اسکریپت‌های پایتون (فقط در سطر یکم) اضافه می‌کنند، در این صورت به هنگام اجرا دیگر نیازی به فراخوانی مفسر پایتون نبوده و تنها می‌بایست پس از تغییر حالت (Mode) اسکریپت مورد نظر به حالت اجرا (توسط دستور chmod)، آن را به روش معمول در یونیکس اجرا نماییم:

1

#!/usr/bin/env python3

env یک دستور شل (Shell) یونیکس است که در زمان اجرای اسکریپت مفسر پایتون را می‌یابد و نشانی آن را جایگزین می‌کند. به جای استفاده از env می‌توان نشانی مفسر پایتون مورد نظر را به صورت صریح مانند usr/bin/python3/!# نوشت که البته در مواردی که پایتون به صورت جداگانه نصب شده باشد (نشانی مفسر در این حالت: usr/local/bin/python3/)، کارایی ندارد و موجب شکست در اجرا می‌گردد.

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

1
2
3
4
5
6
7
8

#!/usr/bin/env python
#-*- coding: utf-8 -*-

# Python 2.x
# File: first_project_2x.py
# This script prints a value to the screen.

print "(50-5×6)÷4 =", (50-5*6)/4

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

user> chmod +x Documents/FirstProject/first_project_2x.py

user> Documents/FirstProject/first_project_2x.py
(50-5×6)÷4 = 5

user> cd Documents/FirstProject/

user> chmod +x first_project_2x.py

user> ./first_project_2x.py
(50-5×6)÷4 = 5

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

• PyDev: یک IDE کامل، متن باز و رایگان است که برای پلتفرم Eclipse ارایه می‌شود.
• PyCharm: محصولی از شرکت فوق‌العاده JetBrains است که البته نسخه کامل آن فروشی است ولی نسخه کامیونیتی (Community) آن رایگان و متن باز می‌باشد که از بسیاری ویژگی‌ها و امکانات ویژه برخوردار است. (مقایسه نسخه‌ها)
• NetBeans: یک IDE کامل، متن باز و رایگان است که طرفداران بسیاری دارد. NetBeans به صورت پیش‌فرض از پایتون پشتیبانی نمی‌کند و باید پلاگین مربوط به آن نصب گردد. (صفحه راهنمای نصب)

پشت صحنه اجرا¶

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

بایت‌کد هر ماژول‌ پایتون در قالب فایلی با پسوند pyc که یاد‌آور py Compiled است، ذخیره می‌گردد. این فایل در یک زیردایرکتوری با نام __pycache__ داخل همان دایرکتوری ماژول ذخیره می‌شود و نام گذاری آن نیز با توجه به نام ماژول و نسخه‌ مفسر پایتون مورد استفاده، انجام می‌گیرد (نمونه: module.cpython-34.pyc). مفسر پایتون از این فایل ذخیره شده جهت افزایش سرعت اجرا در آینده بهره خواهد برد؛ به این صورت که در نوبت‌های بعدی اجرا چنانچه تغییری در کدهای ماژول یا نسخه‌ مفسر پایتون صورت نگرفته باشد، مفسر با بارگذاری فایل بایت‌کد از کامپایل مجدد سورس کد به بایت‌کد صرف نظر می‌کند.

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

ایجاد محیط مجازی¶

حالتی را در نظر بگیرید که در ایجاد پروژه‌های مختلف به نسخه‌های متفاوتی از برخی کتابخانه‌ها نیاز دارید؛ در این صورت چگونه می‌توانید چندین نسخه‌ متفاوت از یک کتابخانه‌ را در پایتون نصب نمایید؟ برای نمونه، فرض نمایید می‌خواهیم بر روی توسعه دو وب‌سایت؛ یکی توسط نسخه جدید (1.8) وب فریم‌ورک جنگو (Django) و دیگری بر روی یک نسخه قدیمی (0.96) از آن کار کنیم، ولی نمی‌توانیم!؛ زیرا که نمی‌شود هر دوی این نسخه‌ها را با هم در پایتون (دایرکتوری site-packages) نصب داشت. در این وضعیت راه حل ایجاد محیط‌هایی مجازی (Virtual Environments) برای توسعه پروژه‌های مورد نظر است؛ محیطی که توسعه و اجرای هر پروژه پایتون را به همراه تمام وابستگی‌های (Dependencies) آن از پروژه‌های دیگر جدا یا ایزوله (isolate) می‌کند. در ادامه به بررسی دو ابزار رایج در این رابطه می‌پردازیم.

user> sudo pip install -U pip

[...]
Successfully installed pip[...]

user>

user> sudo pip install virtualenv

[...]
Successfully installed virtualenv[...]

user>

user> virtualenv Documents/SampleENV/

user> virtualenv --python=python2 ENV

user> virtualenv --python=python3 ENV

user> virtualenv --python=/opt/python3.3/bin/python ENV

> virtualenv --python=C:\Python25\python.exe Documents\SampleENV\

user> cd Documents/SampleENV/
user> source bin/activate
(SampleENV)$

(SampleENV)$ deactivate
user>

> cd Documents\SampleENV\
> Scripts\activate.bat
(SampleENV)>

(SampleENV)> deactivate.bat
>

user> pyvenv Documents/SampleENV/

user> cd Documents/SampleENV/
user> source bin/activate
(SampleENV)$

(SampleENV)$ deactivate
user>

> C:\Python34\python C:\Python34\Tools\Scripts\pyvenv.py Documents\SampleENV\

> C:\Python34\python -m venv Documents\SampleENV\

> cd Documents\SampleENV\
> Scripts\activate.bat
(SampleENV)>

(SampleENV)> deactivate.bat
>

حالت تعاملی¶

از درس پیش به خاطر داریم که کدهای پایتون را می‌توان به دو روش اجرا نمود: ۱- ایجاد اسکریپت و معرفی آن به مفسر پایتون که در همان درس بررسی شد ۲- به شکل تعاملی با مفسر پایتون که موضوع همین درس است.

پایتون یک زبان برنامه‌نویسی با قابلیت «حالت تعاملی» (Interactive Mode) است؛ این قابلیت که مبتنی بر خط فرمان است، امکانی را برای پردازش و اجرای کدهای (دستورها، عبارت‌ها [1] و تعریف‌ها) زبان پایتون فراهم می‌آورد. کدنویسی در این حالت به مانند زمانی است که یک اسکریپت را ایجاد می‌نمایید؛ ولی با هر بار فشردن کلید Enter صفحه کلید، مفسر پایتون آن را به صورت خودکار اجرا می‌کند.

البته حالت تعاملی محدودیت‌هایی دارد که خواهید دید ولی از برخی زوایا بسیار مناسب و کاربردی است؛ به عنوان نمونه ممکن است قصد آزمودن یکی از قابلیت‌های زبان پایتون را داشته باشید یا اینکه بخواهید خروجی یک قطعه کد کوتاه را مشاهده نمایید که در این صورت ایجاد اسکریپت و سپس اجرای آن می‌تواند کار پر زحمتی به نظر برسد!،‌ از طرفی دریافت راهنمایی نیز از دیگر مزایای آن است که در یادآوری، شناخت و کسب آگاهی از موارد زبان پایتون (کلمه‌های کلیدی، تابع‌ها، کلاس‌ها، ماژول‌ها و…) بسیار کاربردی و مفید می‌باشد، حتی برخی نیز از این حالت پایتون به عنوان یک ماشین حساب بهره می‌گیرند!.

برای ورود به حالت تعاملی پایتون از دستور فراخوانی مفسر (حالت عمومی: python) - به شکل تنها و بدون آرگومان‌ - در رابط خط فرمان سیستم عامل، استفاده می‌شود.

ورود به حالت تعاملی پایتون 2x - ویندوز:

> cd C:\\Python27
> python
Python 2.7.9 (default, Dec 10 2014, 12:28:03) [MSC v.1500 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

ورود به حالت تعاملی پایتون 3x - گنولینوکس:

user> python3
Python 3.4.2 (default, Jan 25 2015, 20:02:16)
[GCC 4.9.2 20141101 (Red Hat 4.9.2-1)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

پس از ورود یک پیغام نمایش داده می‌شود؛ در این پیغام ضمن ارایه اطلاعات پایه در مورد مفسر پایتون و سیستم عامل، پیشنهاد می‌شود که جهت یافتن اطلاعات بیشتر در مورد زبان برنامه‌نویسی پایتون از دستورهای ویژه‌ایی استفاده نمایید:

• ()license: باعث نمایش چندین صفحه مرتبط با تاریخ توسعه و پروانه‌های پایتون می‌گردد که البته از طریق - صفحه تاریخچه و پروانه پایتون - نیز قابل مشاهده است. برای مرور از کلید Enter و خروج از کلید q صفحه کلید استفاده نمایید.
• credits: فهرستی از سازمان‌ها و شرکت‌های مشارکت کننده در توسعه زبان پایتون را نمایش می‌دهد.
• copyright: فهرست کپی‌رایت زبان پایتون از ابتدا تا کنون را نمایش می‌دهد.
• help: این دستور کاربرد زیادی دارد که در ادامه بررسی می‌شود. با استفاده از این دستور می‌توان در مورد اشیا و اجزای مختلف موجود در زبان پایتون راهنمایی گرفت.

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

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

>>> print("(50-5×6)÷4 =", (50-5*6)/4)
(50-5×6)÷4 = 5.0

>>> def func():
...     print("(50-5×6)÷4 =", (50-5*6)/4)
...
>>> func()
(50-5×6)÷4 = 5.0

برای پاک کردن صفحه از کلید‌های ترکیبی Ctrl–L استفاده نمایید. به منظور خروج نیز می‌توانید عبارت ()quit را وارد کرده یا از کلیدهای ترکیبی Ctrl–D در گنولینوکس و Ctrl–Z با یک Enter پس از آن در ویندوز استفاده نمایید.

از مزایای حالت تعاملی این است که در بیشتر مواقع برای مشاهده نتیجه، نیازی به استفاده از print نمی‌باشد:

>>> a = 2
>>> a
2

>>> (50-5*6)/4
5.0

و چنانچه مشغول انجام محاسبات ریاضی هستید می‌توانید از یک متغیر خاص با نام _ (خط زیرین: Underscore) استفاده نمایید؛ این متغیر همواره به آخرین مقدار [2] محاسبه شده اشاره دارد:

>>> 5 * 6
30
>>> _
30
>>> 50 - _
20
>>> _ / 4
5.0

مثالی دیگر - در کاربرد ریاضی، برخی تابع‌ها توسط ماژول math از کتابخانه استاندارد پایتون در دسترس هستند [اسناد پایتون]:

>>> import math

>>> math.sqrt(36)
6.0

>>> math.pow(3, 2)
9.0

>>> math.radians(90)
1.5707963267948966

>>> math.sin(_)
1.0

برای وارد کردن یک ماژول به اسکریپت (یا ماژولی دیگر) از دستور import استفاده می‌گردد. در یک درس جداگانه به صورت کامل صحبت خواهد شد ولی برای ادامه این درس تا همین حد بدانید که برای فراخوانی تابع‌های موجود در یک ماژول import شده از الگوی «نام ماژول + نقطه + نام تابع مورد نظر» استفاده می‌گردد - در دستور import پسوند ماژول نوشته نمی‌شود.

مثالی دیگر - sys یکی از ماژول‌های مهم پایتون است؛ این ماژول امکان دسترسی به برخی از متغیرهای مورد استفاده مفسر (در زمان اجرا) و همچنین تابع‌هایی که با مفسر در ارتباط هستند را فراهم می‌آورد [اسناد پایتون]:

>>> import sys

>>> sys.version
'3.4.2 (default, Jan 25 2015, 20:02:16) \n[GCC 4.9.2 20141101 (Red Hat 4.9.2-1)]'

>>> sys.version_info
sys.version_info(major=3, minor=4, micro=2, releaselevel='final', serial=0)

>>> sys.platform
'linux'

>>> sys.getdefaultencoding()
'utf-8'

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

>>> import sys

>>> sys.exit("Error: Goodbye! :| ")
Error: Goodbye! :|

user>

دریافت راهنمایی¶

یکی از دستورهای پیشنهادی در پیغام ابتدایی حالت تعاملی، help بود که با وارد کردن آن متن پایین نمایش داده می‌شود:

>>> help
Type help() for interactive help, or help(object) for help about object.

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

روش یکم: رفتن به حالت راهنمای تعاملی

برای این منظور از دستور ()help استفاده می‌گردد - با وارد کردن این دستور ضمن نمایش پیغام خوش‌آمد گویی، نماد سطر (<<<) نیز به <help تغییر پیدا می‌کند:

>>> help()

Welcome to Python 3.4's help utility!

If this is your first time using Python, you should definitely check out
the tutorial on the Internet at http://docs.python.org/3/tutorial/.

Enter the name of any module, keyword, or topic to get help on writing
Python programs and using Python modules.  To quit this help utility and
return to the interpreter, just type "quit".

To get a list of available modules, keywords, symbols, or topics, type
"modules", "keywords", "symbols", or "topics".  Each module also comes
with a one-line summary of what it does; to list the modules whose name
or summary contain a given string such as "spam", type "modules spam".

help>

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

• modules: نمایش فهرستی از نام تمامی ماژول‌های در دسترس
• keywords:‌ نمایش تمام کلمه‌های کلیدی پایتون
• symbols:‌ نمایش تمام نماد‌های معنادار در پایتون
• topics: نمایش فهرستی از مباحث مربوط به پایتون

# Python 3.x

help> keywords

Here is a list of the Python keywords.  Enter any keyword to get more help.

False               def                 if                  raise
None                del                 import              return
True                elif                in                  try
and                 else                is                  while
as                  except              lambda              with
assert              finally             nonlocal            yield
break               for                 not
class               from                or
continue            global              pass

help> def

Function definitions
********************

A function definition defines a user-defined function object (see
section *The standard type hierarchy*):

[...]

A function definition is an executable statement.  Its execution binds
the function name in the current local namespace to a function object
(a wrapper around the executable code for the function).  This
function object contains a reference to the current global namespace
:

برای خروج از راهنمای تعاملی، quit (یا q) را وارد نماید.

روش دوم: فراخوانی تابع راهنما

در این روش از الگوی (help(object برای دریافت اطلاعات درباره یک شی (object)، به صورت مستقیم و بدون ورود به راهنمای تعاملی استفاده می‌شود - تنها کافی است نام شی مورد نظر را درون پرانتز قرار دهید (به جای واژه object):

>>> help(print)

Help on built-in function print in module builtins:

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.
(END)

>>>

از این روش با الگوی دیگری هم استفاده می‌شود. الگوی ("help("string یعنی قرار دادن نام موردی که می‌خواهید درباره آن اطلاعات بگیرید درون پرانتز به شکلی محصور با دو نماد نقل قول ( ” ” ) - این الگو عملکردی مشابه با روش قبل (روش یکم) دارد با این تفاوت که دریافت اطلاعات به صورت مستقیم و بدون ورود به راهنمای تعاملی انجام می‌پذیرد. در واقع برای به دست آوردن اطلاعات درباره موردی که شی نمی‌باشد (مانند هر یک از دستورهای symbols ،keywords ،modules و topics یا دستور print در پایتون 2x یا نام ماژول‌ها یا…) لازم است به این صورت اقدام گردد:

# Python 2.x

>>> help("keywords")

Here is a list of the Python keywords.  Enter any keyword to get more help.

and                 elif                if                  print
as                  else                import              raise
assert              except              in                  return
break               exec                is                  try
class               finally             lambda              while
continue            for                 not                 with
def                 from                or                  yield
del                 global              pass

>>> help("print")

The "print" statement
*********************

print_stmt ::= "print" ([expression ("," expression)* [","]]
                | ">>" expression [("," expression)+ [","]])

"print" evaluates each expression in turn and writes the resulting
object to standard output (see below).  If an object is not a string,
it is first converted to a string using the rules for string
conversions.  The (resulting or original) string is then written.  A
space is written before each object is (converted and) written, unless
the output system believes it is positioned at the beginning of a
line.  This is the case (1) when no characters have yet been written
to standard output, (2) when the last character written to standard
output is a whitespace character except "' '", or (3) when the last
write operation on standard output was not a "print" statement. (In
some cases it may be functional to write an empty string to standard
output for this reason.)

Note: Objects which act like file objects but which are not the
    built-in file objects often do not properly emulate this aspect of
    the file object's behavior, so it is best not to rely on this.

:

گزینه‌های فراخوانی¶

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

در پایتون 2x [اسناد پایتون]:

python [-BdEiOQsRStuUvVWxX3?] [-c command | -m module-name | script | - ] [args]

در پایتون 3x [اسناد پایتون]:

python [-bBdEhiIOqsSuvVWx?] [-c command | -m module-name | script | - ] [args]

همانطور که مشاهده می‌شود این دستور می‌تواند سه دسته آرگومان را بپذیرد:

دسته یکم (Options):

شامل برخی از حروف الفباست که به همراه یک کاراکتر خطِ فاصله (Dash) - بعد از دستور اصلی یعنی python می‌آیند؛ برخی از این گزینه‌ها به شرح زیر است:

• q− (تنها در پایتون 3x) - در هنگام ورود به حالت تعاملی پایتون از نمایش پیغام ابتدایی صرف نظر می‌شود:

  user> python3 -q
  >>> 2 + 2
  4
  

• Q- (تنها در پایتون 2x) - در هنگام اجرای یک اسکریپت و برای کنترل عملگرهای تقسیم / موجود در آن به کار می‌رود؛ به این صورت که پس از آن می‌بایست یکی از کلمه‌های warn ،new ،old و warnall ذکر گردد.

  • Qold: حاصل تقسیم دو عدد صحیح یک عدد صحیح باشد.
  • Qnew: حاصل تقسیم دو عدد صحیح یک عدد ممیز شناور باشد - مانند نسخه 3x پایتون.
  • Qwarn: حاصل تقسیم دو عدد صحیح یک عدد صحیح باشد، به همراه نمایش پیام هشدار به ازای هر عملگر.
  • Qwarnall: به مانند Qwarn است ولی به ازای تمام عملگرهای تقسیم به کار رفته در اسکریپت تنها یک پیام هشدار نمایش داده می‌شود.

  python -Qnew script.py
  

• O- یا OO- - راه‌اندازی بهینه‌ساز (Optimization) پایه بایت‌کد، که می‌تواند تا حدودی موجب بهبود کارایی اسکریپت گردد. استفاده از گزینه OO- علاوه بر بهینه سازی، موجب دور انداختن مستندات [3] (Docstrings) موجود در اسکریپت نیز می‌شود:

  python -O script.py
  

  Tip

  در صورت استفاده از این گزینه‌ها، به جای فایل pyc. (بایت‌کد معمولی)، فایلی با پسوند pyo. (بایت‌کد بهینه شده) ایجاد می‌گردد.

• B- - مفسر پایتون از ذخیره بایت‌کد ماژول‌های import شده بر روی دیسک خودداری می‌کند:

  python -B script.py
  

• d- - برخی از گزارش‌های اضافه خطایابی (در صورت وجود) نمایش داده می‌شوند:

  python -d script.py
  

• i- - پس از اجرای اسکریپت، خط فرمان به حالت تعاملی پایتون وارد می‌شود:

  python -i script.py
  

• V- (برابر با version--) - نسخه پایتون نمایش داده می‌شود:

  python -V
  

• ?- یا h- (برابر با help--) - فهرست گزینه‌های فراخوانی پایتون به همراه توضیحاتی کوتاه نمایش داده می‌شود:

  python -h
  

• S- - از import شدن ماژول site جلوگیری می‌شود:

  python -S
  

  به صورت عادی ماژول site در زمان راه‌اندازی مفسر پایتون به صورت خودکار import می‌گردد و وظیفه آن گسترش sys.path است. به عنوان نمونه؛ این ماژول مسیر دایرکتوری site-packages را به sys.path اضافه می‌کند.

  دایرکتوری site-packages محل نگهداری بسته‌ها یا کتابخانه‌های شخص ثالثی است که با استفاده از pip اقدام به نصب آن‌ها در پایتون کرده‌ایم.

  هر زمان که ماژولی import می‌شود مفسر پایتون در داخل دایرکتوری‌های مشخصی به دنبال آن می‌گردد؛ این دایرکتوری‌ها در sys.path فهرست شده‌اند.

  برای نمونه - پایتون 3x در ویندوز:

  > python -q
  
  >>> import sys
  >>> sys.path
  ['', 'C:\\Python34', 'C:\\Windows\\SYSTEM32\\python34.zip', 'C:\\Python34\\DLLs', 'C:\\Python34\\lib', 'C:\\Python34\\lib\\site-packages']
  >>>
  

  برای نمونه - پایتون 3x در گنولینوکس:

  user> python3 -qS
  
  >>> import sys
  >>> sys.path
  ['', '/usr/local/lib/python34.zip', '/usr/local/lib/python3.4/', '/usr/local/lib/python3.4/plat-linux', '/usr/local/lib/python3.4/lib-dynload']
  >>>
  

  از گزینه S استفاده شده است و همانطور که مشاهده می‌نمایید دیگر از دایرکتوری site-packages خبری نیست!

  Tip

  نخستین دایرکتوری که مفسر در آن به دنبال نام ماژول می‌گردد؛ دایرکتوری حاوی اسکریپت است که در کدهای بالا (چون که مربوط به حالت تعاملی پایتون است) توسط '' مشخص شده است.

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

  می‌توانید با نوشتن مسیر دایرکتوری‌های دلخواه خود درون یک فایل متنی با پسوند pth. و قرار دادن آن درون دایرکتوری site-packages، این دایرکتوری‌ها را نیز به sys.path بیافزایید. برای نمونه فایل mypath.pth را (در سیستم عامل گنولینوکس) ایجاد می‌نماییم:

  user> cd /usr/local/lib/python3.4/site-packages
  user> sudo touch mypath.pth
  user> sudo chmod 777 mypath.pth
  

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

  /home/saeid/Documents
  /home/saeid/Documents/me
  

  اکنون تمام ماژول‌های موجود در این دایرکتوری‌ها قابل import هستند؛ به فهرست sys.path توجه نمایید:

  user> python3 -q
  
  >>> import sys
  >>> sys.path
  ['', '/usr/local/lib/python34.zip', '/usr/local/lib/python3.4', '/usr/local/lib/python3.4/plat-linux', '/usr/local/lib/python3.4/lib-dynload', '/usr/local/lib/python3.4/site-packages', '/home/saeid/Documents', '/home/saeid/Documents/me']
  >>>
  

  همین کار را می‌توان از طریق برنامه‌نویسی نیز انجام داد، البته پس از اتمام اجرای اسکریپت (در اینجا: خروج از حالت تعاملی) اثر آن از بین می‌رود:

  user> python3 -q
  
  >>> import sys
  >>> sys.path.append('/home/saeid/Documents')
  >>> sys.path.append('/home/saeid/Documents/me')
  

  تابع append دایرکتوری مورد نظر را به انتهای فهرست sys.path اضافه می‌کند. البته می‌توان با استفاده از تابع insert به جای append جایگاه دایرکتوری دلخواه خود را با استفاده از آرگومان نخست آن در sys.path مشخص نمود؛ با این کار دایرکتوری مورد نظر زودتر از دایرکتوری‌های بعد خودش توسط مفسر مورد جستجو قرار می‌گیرد - فایده این کار زمانی مشخص می‌شود که در دایرکتوری‌هایی مجزا، ماژولی با نام یکسان وجود داشته باشد؛ در این صورت ماژولی که زودتر توسط مفسر دیده شود به عنوان ماژول مورد نظر import می‌شود:

  user> python3 -q
  
  >>> import sys
  >>> sys.path.insert(1,'/home/saeid/Documents/me')
  >>> sys.path
  ['', '/home/saeid/Documents/me', '/usr/local/lib/python34.zip', '/usr/local/lib/python3.4', '/usr/local/lib/python3.4/plat-linux', '/usr/local/lib/python3.4/lib-dynload', '/usr/local/lib/python3.4/site-packages']
  >>>
  

  چند درس جلوتر خواهید آموخت که مقدار sys.path در واقع یک شی از نوع list است؛ append و insert نیز تابع‌هایی [4] هستند که توسط یک شی از نوع list می‌توانند فراخوانی گردند. در این مرحله تنها به یاد داشته باشید که موقعیت‌ها در یک شی از نوع list از عدد صفر شماره‌گذاری می‌گردند.

دسته دوم:

• c command- - این الگو امکان اجرای دستورهای پایتون را بدون ورود به حالت تعاملی یا ایجاد اسکریپت، فراهم می‌سازد:

  user> python3 -c "import sys; print(sys.path)"
  ['', '/usr/local/lib/python34.zip', '/usr/local/lib/python3.4', '/usr/local/lib/python3.4/plat-linux', '/usr/local/lib/python3.4/lib-dynload', '/usr/local/lib/python3.4/site-packages']
  

  Note

  دستورها باید درون نمادهای نقل قول محصور باشند.

  استفاده از سمی‌کالن ( ; )‌ در پایان دستورهای پایتون اجباری نیست ولی چنانچه بخواهیم چند دستور را در یک سطر قرار بدهیم می‌بایست از آن استفاده نماییم.

• m module-name- - این الگو امکان اجرای یک ماژول (از میان فهرست sys.path) را به عنوان ماژول __main__ فراهم می‌سازد.

  جالب‌ترین نمونه برای بیان کاربرد این الگو، اجرای ماژول SimpleHTTPServer است. زمانی که نیاز به راه‌اندازی سریع یک وب سرور را دارید و نمی‌خواهید خود را درگیر نصب و پیکربندی Apache یا دیگر وب سرور‌ها نمایید؛ می‌توانید از این ماژول پایتون بهره بگیرید. این ماژول امکانات یک وب سرور ساده را در اختیار شما قرار می‌دهد. البته این ماژول در نسخه 3x پایتون در ماژول http.server ادغام شده است.

  در پایتون 2x [اسناد پایتون]:

  user> python -m SimpleHTTPServer 8080
  

  در پایتون 3x [اسناد پایتون]:

  user> python3 -m http.server 8080
  

  Note

  در استفاده از این الگو نیز همانند زمان import، پسوند ماژول (py) نوشته نمی‌شود.

  می‌توان شماره پورت را وارد نکرد که در این حالت به صورت پیش‌فرض پورت 8000 در نظر گرفته می‌شود.

  ولی منظور از ماژول __main__ چیست؟

  هنگامی که ماژولی (برای نخستین بار) import می‌شود، مفسر پایتون به صورت خودکار تمام کد‌های درون آن را اجرا می‌کند. در مواردی ممکن است یک فایل py. حاوی کدهایی باشد که تنها می‌بایست در حالت اسکریپت به اجرا درآید؛ در این شرایط با import شدن فایل، این کد‌ها نیز اجرا می‌گردند که خواست برنامه‌نویس نمی‌باشد!. از طرفی در پایتون یک سری مقادیر و متغیرهای ویژه و از پیش تعریف شده به مانند __name__ وجود دارد. متغیر __name__ به نام ماژول اشاره دارد؛ در حالت اسکریپت (اجرای یک ماژول به صورت مستقیم - نمونه دستور: python script.py - درس پیش توضیح داده شد) مقدار __name__ برابر با یک مقدار ویژه به نام __main__ می‌گردد که از این موضوع می‌توان برای کنترل اجرای کدها استفاده کرد.

  معمولا کدهای اسکریپت به گونه‌ای نوشته می‌شوند که اجرای آن‌ها وابسته به اجرای یک تابع اصلی باشد که معمولا ()main نامیده می‌شود که در انتها بتوان با قرار دادن شرط برابری مقدار __name__ با __main__ برای اجرای تابع یاد شده، از اجرای کد‌های مورد نظر تنها در حالت اجرا به صورت اسکریپت (و نه در زمان import) مطمئن شد.

  1 2 3 4 5

  def main(): print("this runs only when executed directly") if __name__ == '__main__': main()

• script - این الگو (python script.py) بیان‌‌گر همان روش اجرای اسکریپت است که در درس پیش به صورت کامل راجب آن صحبت شد.

دسته سوم (Arguments):

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

1
2
3
4
5
6
7
8
9

# file: Documents/script-argv-3x.py
# Python 3.x

import sys

print(sys.argv)
print(sys.argv[0])
print(sys.argv[1])
print(sys.argv[2])

اسکریپت بالا را با ارسال دو آرگومان arg_1 و arg_2 اجرا می‌نماییم:

user> python3 Documents/script-argv-3x.py arg_1 arg_2

['/home/saeid/Documents/script-argv-3x.py', 'arg_1', 'arg_2']
/home/saeid/Documents/script-argv-3x.py
arg_1
arg_2

مقدار sys.argv نیز یک شی از نوع list است: [… ,Ο, Ο, Ο] - برای دسترسی به عناصر موجود در شی list، از الگویی مشابه [object[index که در آن …,index=0,1,2,3 است، استفاده می‌گردد؛ به عنوان نمونه [sys.argv[0 به نخستین عنصر موجود در sys.argv اشاره دارد.

عضو نخست sys.argv یا [sys.argv[0 همواره حاوی نام اسکریپت است. البته به جز در مواقعی که از c- استفاده کرده‌ایم که در این صورت برابر مقدار 'c-' خواهد بود:

user> python3 -c "import sys; print(sys.argv)" 2
['-c', '2']

پی‌نوشت¶

😊 امیدوارم مفید بوده باشه

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

برنامه‌نویسی شی‌گرا¶

«برنامه‌نویسی شی‌گرا» (Object-Oriented Programming) یا به اختصار OOP یک الگو یا شیوه تفکر در برنامه‌نویسی است که برگرفته از دنیای واقعی بوده و از دهه ۱۹۶۰ میلادی مطرح گشته است. به زبانی که از این الگو پشتیبانی کند، «زبان شی‌گرا» گفته می‌شود؛ Simula 67 و Smalltalk نخستین زبان‌های برنامه‌نویسی شی‌گرا هستند. ایده شی‌گرایی در پاسخ به برخی از نیازها که الگوهای موجود پاسخ‌گو آن‌ها نبودند به وجود آمد؛ نیازهایی مانند: توانایی حل تمامی مسائل پیچیده (Complex)، «پنهان‌سازی داده» (Data Hiding)، «قابلیت استفاده مجدد» (Reusability) بیشتر، وابستگی کمتر به توابع، انعطاف بالا و…

رویکرد برنامه‌نویسی شی‌گرا «از پایین به بالا» (Bottom-Up) است؛ یعنی ابتدا واحدهایی کوچک از برنامه ایجاد می‌شوند و سپس با پیوند این واحدها، واحدهایی بزرگتر و در نهایت شکلی کامل از برنامه به وجود می‌آید. برنامه‌نویسی شی‌گرا در قالب دو مفهوم «کلاس» (Class) و «شی» (Object) ارایه می‌گردد. هر کلاس واحدی از برنامه است که تعدادی داده و عملیات‌ را در خود نگه‌داری می‌کند و هر شی نیز حالتی (State) مشخص از یک کلاس می‌باشد.

در برنامه‌نویسی شی‌گرا، هر برنامه در قالب موجودیت‌های کوچکی که در واقع همان اشیا هستند و با یکدیگر تعامل دارند در نظر گرفته می‌شود. برای داشتن این اشیا می‌بایست ابتدا کلاس‌های برنامه را تعریف نماییم؛ هر کلاس «رفتار» (Behavior) و «صفات» (Attributes) اشیایی که قرار است از آن ایجاد شوند را تعریف می‌کند. از یک کلاس می‌توان هر تعداد که بخواهیم شی ایجاد نماییم. هر شی بیانگر یک «حالت» یا یک «نمونه» (Instance) از کلاس خود است.

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

به هر شی کلاس، یک نمونه از آن کلاس گفته می‌شود و هر زمان که یک شی از کلاسی ایجاد می‌گردد در واقع یک نمونه از آن ساخته می‌شود. به این عمل در شی‌گرایی «نمونه‌سازی» (Instantiation) گفته می‌شود. بر همین اساس دو نوع کلاس در شی‌گرایی وجود دارد: ۱- کلاس‌های عادی که توانایی نمونه‌سازی دارند و به آن‌ها ”Concrete Class“ گفته می‌شود ۲- کلاس‌هایی که توانایی نمونه‌سازی ندارند و به آن‌ها ”Abstract Class“ گفته می‌شود.

یکی از مفاهیم دیگر در برنامه‌نویسی شی‌گرا، «کپسوله‌سازی» (Encapsulation) است. کپسوله‌سازی به معنی قرار دادن عناصر یک ساختار در قالب موجودیتی جدید می‌باشد. در برنامه‌نویسی شی‌گرا با ایجاد هر نمونه از کلاس، عناصر آن (صفات و رفتارها) در قالب یک موجودیت جدید به نام «شی» قرار می‌گیرد. کپسوله‌سازی در شی‌گرایی امکانی است برای پنهان‌سازی داده‌ها؛ در این شرایط اشیا بدون اینکه از درون یکدیگر و چگونگی کارکرد هم کوچکترین آگاهی داشته باشند به تعامل با یکدیگر می‌پردازند.

گفتیم هر کلاس از تعدادی داده و عملیات درون خود نگهداری می‌کند و همچنین گفتیم هر کلاس رفتار و صفات اشیایی که قرار است از آن ایجاد شوند را تعریف می‌کند؛ اکنون با ارایه تعریفی کامل‌تر خواهیم گفت که: هر کلاس از دو بخش «اعضای داده» (Data Members) و «توابع عضو» (Member Functions) تشکیل شده است. اعضای داده در واقع همان متغیر‌های درون کلاس هستند که خصوصیات یا صفات شی را بیان می‌کنند و در شی‌گرایی با عنوان «فیلد» (Field) یا «صفت» (Attribute) از آن‌ها یاد می‌شود. توابع عضو نیز عملیات یا کارهایی هستند که یک شی از کلاس قادر به انجام آن‌ها می‌باشد؛ می‌توان توابع عضو را بیانگر رفتار اشیا کلاس دانست. در شی‌گرایی به این توابع «متد» (Method) گفته می‌شود.

پس از نمونه‌سازی، شی حاوی تمامی اعضای داده و توابع عضوی است که توسط کلاس مربوط به آن تعریف شده است و برای دسترسی به آن‌ها از الگو: «نام شی + نقطه + نام صفت یا متد()» استفاده می‌گردد. همانند:

car_object.color
car_object.drive()

همانطور که در زمان پیاده‌سازی کلاس خواهید دید؛ با ایجاد هر نمونه از کلاس یک متد خاص در آن به صورت خودکار اجرا می‌گردد. این متد «سازنده» (Constructor) نام دارد و کار آن «مقداردهی اولیه» (Initialization) شی است. این کار موجب اطمینان از مقداردهی تمامی اعضای داده پیش از استفاده شی در برنامه می‌گردد.

برای مثال به کلاس خودرو برگردیم و برای آن صفات: رنگ بدنه، ظرفیت باک، بیشینه سرعت و متدهای: راندن، دریافت میزان سوخت، سوخت گیری، تنظیم سرعت، توقف را در نظر بگیریم. اکنون می‌توانیم با تنظیم صفات، نمونه‌ها یا اشیای مورد نظر خود را از این کلاس ایجاد نماییم. برای مثال: دو خودروی آبی با ظرفیت باک ۲۰ لیتر و بیشینه سرعت ۸۰ کیلومتر-ساعت یا یک خودروی صورتی با ظرفیت باک ۴۰ لیتر و بیشینه سرعت ۱۶۰ کیلومتر-ساعت که البته هر سه آن‌ها تمام متدهای کلاس را در خود دارند:

تا به اینجا با مفاهیم «کلاس»، «صفت»، «متد»، «شی»، «نمونه‌سازی» و «کپسوله‌سازی» آشنا شده‌ایم؛ در ادامه به توضیح سه مفهوم مهم دیگر از برنامه‌نویسی شی‌گرا که عبارتند از: «وراثت» (Inheritance)، «چندریختی» (Polymorphism) و «انتزاع» یا «تجرید» (Abstraction) خواهیم پرداخت.

وراثت:

وراثت یکی از شکل‌های «قابلیت استفاده مجدد» کد بوده که برنامه‌نویس را قادر می‌سازد تا با ارث‌بری صفات و متدهای یک یا چند کلاس موجود، کلاس‌های جدیدی را ایجاد نماید.

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

به کلاسی که از آن ارث‌بری می‌شود ”Parent Class“ یا ”Base Class“ (کلاس پایه) یا ”Superclass“ و به کلاسی که اقدام به ارث‌بری می‌کند ”Child Class“ (کلاس فرزند) یا ”Derived Class“ یا ”Subclass“ گفته می‌شود.

ارث‌بری توسط «نسبت هست-یک» (IS-A Relationship) بیان می‌شود؛ این نسبت می‌گوید کلاس فرزند یک نوع از چیزی است که کلاس پایه هست. کلاس A از کلاس B ارث‌بری دارد؛ در این حالت می‌گوییم: A is a type of B، یعنی درست است اگر بگوییم: «سیب» یک نوع «میوه» است یا «خودرو» یک نوع «وسیله نقلیه» است ولی توجه داشته باشید که این یک ارتباط یک‌طرفه از کلاس فرزند به کلاس پایه است و نمی‌توانیم بگوییم: «میوه» یک نوع «سیب» است یا «وسیله نقلیه» یک نوع «خودرو» است.

کلاس‌ها می‌توانند مستقل باشند ولی هنگامی که وارد رابطه‌های وراثت می‌شوند، یک ساختار سلسله مراتب (Hierarchy) به شکل درخت را تشکیل می‌دهند. برای نمونه به ساختار سلسله مراتب وراثت پایین که مربوط به برخی اشکال هندسی است توجه نمایید، پیکان‌ها نشانگر نسبت is-a هستند.

در برنامه‌نویسی شی‌گرا نسبت دیگری نیز با عنوان «نسبت دارد-یک» (HAS-A Relationship) وجود دارد که بیانگر مفهومی به نام «ترکیب» (Composition) است که شکل دیگری از قابلیت استفاده مجدد کد می‌باشد ولی مفهومی متفاوت با وراثت دارد. این نسبت زمانی بیان می‌شود که درون یک کلاس (مانند: C) از کلاس دیگری (مانند: D) نمونه‌سازی شده باشد؛ یعنی شی کلاس C درون خودش شی‌ای از کلاس D را داشته باشد؛ در این حالت می‌گوییم: C has a D. به یاد دارید خواندیم کلاس خودرو از کلاس‌های کوچکتری ساخته شده است؛ مثلا کلاس موتور - یعنی درون این کلاس یک شی از کلاس موتور ایجاد شده است، اکنون می‌توانیم بگوییم: «خودرو» یک «موتور» دارد.

چندریختی:

مفهوم چندریختی بیانگر توانایی کلاس فرزند در تعریف متدهایی است که در کلاس پایه موجود می‌باشند. برای نمونه دو کلاس «ماهی» و «گربه» را که هر دو آن‌ها از کلاسی به نام «حیوانات» ارث‌بری دارند را در نظر بگیرید؛ در کلاس حیوانات متدی با عنوان «غذا خوردن» که عملی مشترک در میان تمام حیوانات است وجود دارد ولی از آنجا که چگونگی انجام آن در ماهی و گربه متفاوت است، بنابراین هر دو این کلاس‌ها نیاز دارند تا متد «غذا خوردن» مخصوص خود را داشته باشند - در این جاست که این متد در کلاس‌های فرزند بازتعریف می‌شود، به این عمل ”Method Overriding“ گفته می‌شود. با Override کردن یک متد، متد کلاس پایه زیر سایه متد مشابه در کلاس فرزند قرار می‌گیرد و از نظر اشیا کلاس فرزند پنهان می‌شود.

تجرید:

تجرید در برنامه‌نویسی شی‌گرا به همراه مفهوم چندریختی می‌آید و توسط دو مفهوم «کلاس‌های مجرد» (Abstract Classes) و «متدهای مجرد» (Abstract Methods) ارایه می‌گردد.

«کلاس مجرد» کلاسی است که شامل یک یا چند «متد مجرد» باشد و «متد مجرد» متدی است که اعلان (Declare) شده ولی بدنه آن ‌تعریف (Define) نشده است. کلاس‌های مجرد قابلیت نمونه‌سازی ندارند و نمی‌توان از آن‌ها شی ایجاد نمود؛ چرا که هدف از توسعه آن‌ها قرار گرفتن در بالاترین سطح (یا چند سطح بالایی) درخت وراثت، به عنوان کلاس پایه برای ارث‌بری کلاس‌های پایین‌تر می‌باشد. ایده طراحی کلاس مجرد در تعیین یک نقشه توسعه برای کلاس‌های فرزند آن است؛ تعیین صفات و متدهای لازم ولی واگذاردن تعریف متدها بر عهده کلاس‌های فرزند.

به عنوان نمونه سه کلاس «ماهی»، «گربه» و «کبوتر» را در نظر بگیرید. این کلاس‌ها جدا از رفتارهای خاص خود (مانند: «پرواز کردن» در کبوتر یا «شنا کردن» در ماهی)، در یک سری رفتار به مانند «نفس کشیدن»، «غذا خوردن» و… مشترک هستند. راه درستِ توسعه این کلاس‌ها تعیین یک «کلاس پایه» برای رفتارهای مشترک و ارث‌بری هر سه آن‌ها می‌باشد. ولی از آنجا که هر یک، این رفتارهای مشترک را به گونه‌ای دیگر انجام می‌دهد؛ راه درست‌تر آن است که یک «کلاس مجرد» به عنوان «کلاس پایه» آن‌ها در نظر بگیریم؛ در این حالت هر کدام از کلاس‌ها ضمن دانستن رفتارهای لازم می‌تواند آن‌‌ها را متناسب با خواست خود تعریف نماید.

اشیا در پایتون¶

علاوه‌بر اینکه پایتون یک زبان برنامه‌نویسی شی‌گراست، ساختار آن نیز بر مبنای شی‌گرایی توسعه یافته است و اینطور بیان می‌شود که هر چیزی در پایتون یک شی است. اشیا، انتزاعِ پایتون برای ارایه «انواع داده‌» (Data Types) هستند. به بیان دیگر تمام داده‌های یک برنامه پایتونی یا به صورت مستقیم یک شی است یا از روابط بین اشیا ایجاد می‌گردد. برای نمونه: 56، "!Hello World"، توابع و… حتی خود کلاس‌ها نیز توسط یک نوع شی ارایه می‌شوند.

هر شی در پایتون حاوی یک «شناسه» (identity)، یک «نوع» (type) و یک «مقدار» (value) است.

• «شناسه» در زمان ایجاد شی به آن اختصاص می‌یابد و غیر قابل تغییر است. تابع ()id شناسه شی را به صورت یک عدد صحیح برمی‌گرداند که این مقدار در CPython بیانگر نشانی (Address) شی در حافظه (Memory) است:

  >>> id(5)
  140468674877440
  
  >>> num = 0.25
  >>> id(num)
  140468676592120
  
  >>> msg = "Hello World!"
  >>> id(msg)
  140468675425264
  

• هر شی در پایتون دارای یک «نوع» یا ”type“ است که عملیات قابل پشتیبانی و نیز مقادیر ممکن برای شی را تعریف می‌کند. نوع هر شی توسط تابع ()type قابل مشاهده است و همانند شناسه غیر قابل تغییر می‌باشد:

  >>> # python 3.x
  >>> type(127)
  <class 'int'>
  
  >>> # python 2.x
  >>> type(127)
  <type 'int'>
  

  Caution

  تمام اعداد صحیح (Integers) در پایتون یک شی از نوع int می‌باشند. [با انواع آماده (Built-in) شی در پایتون توسط دروس آینده آشنا خواهید شد.]

• «مقدار» برخی اشیا در پایتون قابل تغییر است که به این دسته از اشیا ”mutable“ (تغییر پذیر) گفته می‌شود؛ ولی مقدار برخی دیگر قابل تغییر نمی‌باشد (مانند اعداد: شی 127) که به آن‌ها اشیا ”immutable“ (تغییر ناپذیر) می‌گویند.

کلاس‌ها در پایتون¶

از نسخه 2.2 طراحی کلاس‌ها در پایتون تغییر کرد [New-style Classes] که البته ساختار قدیمی همچنان در نسخه 2x باقی مانده است. [مبنای آموزش در این کتاب طراحی جدید می‌باشد.]

در ساختار جدید مفهوم ”type“ برابر مفهوم ”class“ طراحی شده است. در این ساختار هر کلاس خود یک شی از کلاسی به نام ”type“ می‌باشد و همچنین تمامی کلاس‌ها از کلاسی به نام ”object“ ارث‌بری دارند:

>>> # Python 3.x
>>> num = 3

>>> num.__class__
<class 'int'>

>>> type(num)
<class 'int'>

>>> type(type(num))
<class 'type'>

>>> type(num).__class__
<class 'type'>

>>> type(num).__bases__
(<class 'object'>,)

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

>>> # Python 3.x

>>> class MyClassName:
...     pass
...
>>>

>>> type(MyClassName)
<class 'type'>

>>> MyClassName.__bases__
(<class 'object'>,)
>>>

>>> # Python 2.x

>>> class MyClassName(object):
...     pass
...
>>>

>>> type(MyClassName)
<type 'type'>

>>> MyClassName.__bases__
(<type 'object'>,)
>>>

>>> # Python 3.x

>>> class ChildClassName(BaseClassNameOne, BaseClassNameTwo):
...     pass
...
>>>

>>> ChildClassName.__bases__
(<class '__main__.BaseClassNameOne'>, <class '__main__.BaseClassNameTwo'>)

>>> # Python 2.x

>>> class BaseClassNameOne(object):
...     pass
...
>>>

>>> class BaseClassNameTwo(object):
...     pass
...
>>>

>>> class ChildClassName(BaseClassNameOne, BaseClassNameTwo):
...     pass
...
>>>

>>> ChildClassName.__bases__
(<class '__main__.BaseClassNameOne'>, <class '__main__.BaseClassNameTwo'>)

>>> # Python 3.x

>>> import inspect
>>> inspect.getmro(ChildClassName)
(<class '__main__.ChildClassName'>, <class '__main__.BaseClassNameOne'>, <class '__main__.BaseClassNameTwo'>, <class 'object'>)

>>> # Python 2.x

>>> import inspect
>>> inspect.getmro(ChildClassName)
(<class '__main__.ChildClassName'>, <class '__main__.BaseClassNameOne'>, <class '__main__.BaseClassNameTwo'>, <type 'object'>)

سطرها¶

مفسر پایتون و همچنین کاربر، کدهای درون هر ماژول را در قالب تعدادی سطر می‌بینند؛ سطرهای فیزیکی (Physical Lines) و منطقی (Logical Lines). سطرهای فیزیکی در واقع همان سطرهایی است که توسط ویرایشگرهای متن شماره‌گذاری می‌شوند و به راحتی توسط کاربر قابل تشخیص هستند ولی سطرهای منطقی برداشت مفسر از اجزای برنامه است؛ هر سطر منطقی بیانگر یک دستور (Statement) پایتون است. برای نمونه دستور print در نسخه 2x پایتون را در نظر بگیرید:

1
2

msg = "Welcome!"
print msg

در نمونه کد بالا: سطر یکم، یک دستور انتساب (Assign) را نشان می‌دهد؛ این دستور مقدار سمت راست خودش را به متغیر msg نسبت می‌دهد. کم و بیش با دستور سطر دوم نیز آشنا هستید این دستور مقدار مربوط به متغیر دریافتی را بر روی خروجی نمایش می‌دهد. در اینجا دو دستور یعنی دو سطر منطقی وجود دارد که هر یک در قالب یک سطر فیزیکی پیاده‌سازی شده است.

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

1

msg = "Welcome!"; print msg

در این حالت می‌بایست سطرهای منطقی (یا همان دستور‌ها)، توسط کاراکتر ; (Semicolon) از یکدیگر جدا گردند.

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

1
2
3

msg = "Python Programming \
Language."  # This is a message.
print msg

در نمونه کد بالا: دو سطر فیزیکی نخست از دید مفسر به شکل تنها یک سطر منطقی دیده می‌شود. در پایتون برای شکستن یک دستور در چند سطر فیزیکی از کاراکتر \ (Backslash) استفاده می‌گردد. البته توجه داشته باشید که از \ نمی‌توان برای شکستن سطر توضیح (Comment) استفاده کرد و همچنین نمی‌توان پس از آن هیچ توضیحی درج کرد.

برای خوانایی بیشتر بهتر است دستور‌های طولانی شکسته شوند. دستورهایی که شامل { }، [ ] و ( ) هستند را می‌توان بدون استفاده از \ شکست و در قالب چند سطر فیزیکی نوشت:

1
2
3
4

month_names = ['Januari', 'Februari', 'Maart',      # These are the
               'April',   'Mei',      'Juni',       # Dutch names
               'Juli',    'Augustus', 'September',  # for the months
               'Oktober', 'November', 'December']   # of the year

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

«سطرهای خالی» (Blank lines): سطری که تنها حاوی فضای خالی (Spaceها یا Tabها) باشد، توسط مفسر نادیده گرفته می‌شود و به بایت‌کد ترجمه نمی‌گردد. از این سطرها می‌توان برای خوانایی بیشتر کدها بهره گرفت - مانند سطر سوم در نمونه کد پایین:

1
2
3
4

def power(a, b):
    return a ** b

print power(2, 3)

مستند‌سازی¶

هر چند اساس طراحی زبان پایتون بر خوانایی بالای کد است ولی «مستندسازی» (Documentation) برنامه یعنی استفاده از امکاناتی همچون ارایه توضیح در کدها می‌تواند به درک و خوانایی هر چه بهتر کدهای برنامه برای مراجعات آینده برنامه‌نویس و افراد دیگری که می‌خواهند بر روی توسعه آن فعال باشند یا از آن استفاده کنند نیز بسیار مفید خواهد بود. در این بخش به بررسی دو امکان درج Comment و Docstring برای مستند‌سازی برنامه می‌پردازیم.

1
2
3
4
5
6
7
8
9

# A comment, this is so you can read your program later.
# Anything after the # is ignored by python.

print "I could have code like this."   # and the comment after is ignored

# You can also use a comment to "disable" or comment out a piece of code:
# print "This won't run."

print "This will run."

1
2
3
4
5
6
7

def complex(real=0.0, imag=0.0):
    """Form a complex number.

    Keyword arguments:
    real -- the real part (default 0.0)
    imag -- the imaginary part (default 0.0)
    """

>>> complex.__doc__
'Form a complex number.\n\n    Keyword arguments:\n    real -- the real part (default 0.0)\n    imag -- the imaginary part (default 0.0)\n    '

>>> print(complex.__doc__)
Form a complex number.

    Keyword arguments:
    real -- the real part (default 0.0)
    imag -- the imaginary part (default 0.0)

>>>

#!/usr/bin/env python
#-*- coding: utf-8 -*-

"""
Module docstring.
"""

import [...]
[...]

تورفتگی¶

بلاک‌بندی در زبان پایتون توسط «تورفتگی» (Indentation) سطرها مشخص می‌گردد؛ این عمل در زبان‌هایی مانند C توسط آکولاد { } انجام می‌شود. تورفتگی در واقع عبارت است از میزان فضای خالی (Spaceها و Tabها) هر دستور از ابتدای سطر فیزیکی خود. نکته مهم این است که تمام دستورهای موجود در یک بلاک می‌بایست به یک میزان فاصله نسبت به سرآیند خود تورفتگی داشته باشند:

1
2
3
4
5
6

// C

if (x > y) {
x = 1;
y = 2;
}

1
2
3
4
5

# Python

if x > y:
    x = 1
    y = 2

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

روش رایج ایجاد تورفتگی استفاده از کلید Space است و سعی کنید هرگز به صورت ترکیبی از کلیدهای Sapce و Tab استفاده نکنید هر چند که در نسخه 3x پایتون امکان استفاده ترکیبی از این دو کلید وجود ندارد! اگر مایل به استفاده از کلید Tab هستید باید به صورت یکدست تمام تورفتگی‌های برنامه خود را فقط با استفاده از آن ایجاد نمایید.

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

1
2
3
4

def long_function_name(
        var_one, var_two, var_three,
        var_four):
    print(var_one)

در دستورهایی به مانند پایین نیز ایجاد تراز آرگومان‌ها هم حالت مناسبی است:

1
2

foo = long_function_name(var_one, var_two,
                         var_three, var_four)

دستور¶

«دستور» (Statement) واحدی از کد است که شامل کلمه‌های کلیدی بوده، اجرا می‌گردد و کاری را به انجام می‌رساند. در پایتون دو نوع دستور وجود دارد:

دستورهای ساده (Simple Statements): دستورهایی هستند که تنها در یک سطر منطقی پیاده‌سازی می‌شوند. مانند دستور import، دستور pass، دستور انتساب، فراخوانی تابع و…

دستورهای مرکب (Compound Statements): گروهی از دستورها هستند که می‌توانند یک بخشی (مانند: دستور def - تعریف تابع) یا چند بخشی (مانند: دستور شرط if / elif / else) باشند؛ هر بخش (Clause) نیز شامل یک سرآیند (Header) و یک بدنه (Suite) است. هر سرآیند با یک کلمه کلیدی آغاز می‌شود و با یک : (Colon) نیز پایان می‌پذیرد. بدنه پس از سرآیند و با رعایت سطح تورفتگی بیشتر نسبت به آن نوشته می‌شود:

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

def binary_search(seq, key):
    lo = 0
    hi = len(seq) - 1
    while hi >= lo:
        mid = lo + (hi - lo) // 2
        if seq[mid] < key:
            lo = mid + 1
        elif seq[mid] > key:
            hi = mid - 1
        else:
            return mid
    return False

شناسه¶

«شناسه» (Identifier) نامی است نمادین که به دلخواه کاربر تعیین و از آن برای شناسایی (identify) متغیر‌ها، توابع، کلاس‌ها، ماژول‌ها یا دیگر اشیا پایتون از یکدیگر استفاده می‌شود. انتخاب شناسه در پایتون نکاتی دارد که می‌بایست از سوی کاربر در نظر گرفته شود:

• تنها با یکی از حروف بزرگ یا کوچک الفبا انگلیسی (A..Z یا a..z) یا کاراکتر _ (Underscore) شروع شود.
• در ادامه می‌تواند هیچ یا چند حرف الفبا انگلیسی (کوچک و بزرگ)، کاراکتر _ و عدد (9..0) - با هر ترتیبی - آورده شود.
• هیچ محدودیتی در طول شناسه وجود ندارد و می‌تواند از یک تا هر تعداد کاراکتر باشد.

با یک نگاه حرفه‌ای‌تر، ساختار لغوی (Lexical) شناسه به شکل پایین بیان می‌شود [اسناد پایتون]:

identifier  ::= (letter|"_") (letter | digit | "_")*

letter      ::= lowercase | uppercase
lowercase   ::= "a"..."z"
uppercase   ::= "A"..."Z"
digit       ::= "0"..."9"

برای نمونه - چند شناسه درست:

a    _p    __var    MyClass    get_length    getLength    var2    var_2    S01E16

برای نمونه - چند شناسه نادرست:

me@mail    get.length    2_var    6    $var    4pi

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

• شناسه خصوصی (Private) ماژول: اگر شناسه‌ای با یک کاراکتر _ آغاز شود (و نه پایان پذیرد) توسط مفسر پایتون در این نقش ارزیابی می‌گردد. مانند: name_ (و نه: _name_ یا _name)
• شناسه خصوصی کلاس: اگر شناسه‌ای با دو کاراکتر _ آغاز شود (و نه پایان پذیرد) توسط مفسر پایتون در این نقش ارزیابی می‌گردد. مانند: name__ (و نه: __name__ یا __name)

جدا از این مورد، در پایتون صفت‌ها (Attributes) و متدهای خاصی وجود دارد که از پیش تعریف گشته‌اند و برای مفسر مفهوم مشخصی دارند. شناسه این صفت‌ها و متدها با دو کاراکتر _ آغاز می‌شود و همینطور پایان می‌پذیرد؛ درست به مانند صفت‌های __class__ و __doc__ که پیش از این استفاده کردیم.

بنابراین به هنگام استفاده از کاراکتر _ در شناسه (به خصوص در ابتدای آن) باید آگاهی کافی داشته باشیم. [به موارد اشاره شده در آینده پرداخته خواهد شد.]

برای شناسه‌های تک حرفی توجه داشته باشید که از انتخاب حروف l (اِل کوچک) و I (آی بزرگ) اجتناب کنید زیرا این دو حرف در برخی فونت‌ها شبیه هم هستند و البته همینطور حرف O (اُ بزرگ) که می‌تواند شبیه به صفر باشد.

>>> # Python 3.x

>>> help("keywords")
Here is a list of the Python keywords.  Enter any keyword to get more help.

False               def                 if                  raise
None                del                 import              return
True                elif                in                  try
and                 else                is                  while
as                  except              lambda              with
assert              finally             nonlocal            yield
break               for                 not
class               from                or
continue            global              pass

>>> # Python 2.x

>>> help("keywords")
Here is a list of the Python keywords.  Enter any keyword to get more help.

and                 elif                if                  print
as                  else                import              raise
assert              except              in                  return
break               exec                is                  try
class               finally             lambda              while
continue            for                 not                 with
def                 from                or                  yield
del                 global              pass

>>> # Python 3.x

>>> import keyword

>>> keyword.iskeyword(a)
False

>>> keyword.iskeyword("def")
True

>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

>>> # Python 3.x
>>> import keyword
>>> len(keyword.kwlist)
33

>>> # Python 2.x
>>> import keyword
>>> len(keyword.kwlist)
31

متغیر¶

یک «متغیر» (Variable) در بیشتر زبان‌های برنامه‌نویسی به مانند C بیانگر محلی در حافظه می‌باشد که مقداری در آن قرار گرفته است. برای نمونه سه دستور پایین را در نظر بگیرید:

int a = 1;

a = 2;

int b = a;

در نمونه کد بالا: دستور ;int a = 1 بیان می‌کند که محلی از حافظه به نام a برای نگهداری اعداد صحیح (integers) در نظر گرفته شود و مقدار 1 در آن قرار بگیرد؛ از این پس متغیر a معرف این نقطه از حافظه می‌باشد (درست به مانند یک جعبه) که اکنون حاوی مقدار 1 است (شکل پایین - یک). در ادامه دستور ;a = 2 موجب می‌شود مقدار پیشین متغیر a حذف (از جعبه خارج) و مقدار جدید یعنی 2 در آن قرار داده شود (شکل پایین - دو). توجه داشته باشید که در این دسته زبان‌ها، نوع (type) توسط متغیر تعیین می‌گردد و تلاش برای قرار دادن نوع داده دیگری به غیر از int در متغیر a (به مانند 3.7 یا "string") موجب بروز خطا در زمان کامپایل می‌گردد. دستور سوم:‌ ;int b = a در ابتدا موجب ایجاد یک محل جدید در حافظه با نام b و از نوع همان اعداد صحیح می‌شود و سپس مقدار درون متغیر a را درون آن کپی می‌کند؛ اکنون دو محل برای نگهداری نوع داده int در حافظه موجود است که هر دو حاوی مقدار 2 می‌باشند (شکل پایین - سه).

ولی در پایتون:

یک متغیر چیزی نیست جز یک نام که به یک شی مشخص در حافظه ارجاع (یا اشاره) دارد. تعریف متغیر در پایتون بسیار ساده است و تنها با انتساب (Assign) شی به یک نام ایجاد می‌گردد. نمادِ =، عملگر (Operator) انتساب در پایتون است. در تعریف متغیر پایتون برخلاف آنچه در زبان C مشاهده کردیم ;int a،‌ نیازی به تعیین نوع برای آن نیست چرا که نوع (type) از روی شی تعیین می‌گردد و یک متغیر در طول زمان اجرا می‌تواند به شی‌هایی از انواع متفاوت ارجاع داشته باشد. برای نمونه سه دستور پایین را در نظر بگیرید:

a = 1

a = 2

b = a

مفسر با رسیدن به دستور a = 1، سه گام پایین را انجام می‌دهد:

1. یک شی از نوع اعداد صحیح و مقدار 1 را در جایی از حافظه ایجاد می‌کند. چرا اعداد صحیح؟ نوع توسط شی تعیین می‌گردد و 1 عددی است صحیح!.
2. متغیرِ (یا همان نامِ) a را در جایی دیگر از حافظه ایجاد می‌کند (البته در صورتی که قبلا ایجاد نشده باشد).
3. یک پیوند از متغیر a به شی 1 برقرار می‌کند. به این پیوند «ارجاع» (Reference) گفته می‌شود که به صورت یک اشاره‌گر (Pointer) در حافظه پیاده‌سازی می‌گردد.

انتساب شی دیگری (که می‌تواند از هر نوع دیگری باشد) به یک متغیر موجود؛ موجب حذف ارجاع قبلی آن و ارجاع به شی جدید می‌شود. دستور a = 2 موجب ایجاد شی 2، حذف ارجاع متغیر a به شی 1 و ایجاد ارجاعی جدید از متغیر a به شی 2 می‌شود. هر متغیر نامی است برای اشاره به یک شی؛ دستور b = a نیز می‌گوید: یک متغیر جدید با نام b ایجاد گردد و به همان شی‌ای ارجاع داشته باشد که متغیر a ارجاع دارد.

ولی اکنون که ارجاعی به شی 1 وجود ندارد، با آن چه می‌شود؟

هر شی شامل یک «شمارنده ارجاع» (Reference Counter) نیز هست؛ به این صورت که در هر لحظه تعداد ارجاع‌ها به آن شی را نشان می‌دهد و با هر ارجاع جدید به شی، یک واحد به آن اضافه می‌شود و با حذف هر ارجاع نیز یک واحد کاهش می‌یابد. چنانچه مقدار آن به صفر برسد، شی آن توسط تکنیک ”Garbage Collection“ پاک می‌گردد و مقدار حافظه‌ای که توسط شی مصرف شده بود آزاد می‌گردد. برای مشاهده تعداد ارجاع‌ها به یک شی می‌توان از تابع ()getrefcount درون ماژول sys استفاده کرد [اسناد پایتون].

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

>>> import sys

>>> a = 1
>>> sys.getrefcount(1)
760

>>> a = 2
>>> sys.getrefcount(1)
759
>>> sys.getrefcount(2)
96

>>> b = a
>>> sys.getrefcount(2)
97

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

>>> a = b = c = "python"

>>> a
'python'
>>> b
'python'
>>> c
'python'

>>> a, b, c, d = 1, 4.5, "python", 2

>>> a
1
>>> b
4.5
>>> c
'python'
>>> d
2

>>> a = 1
>>> b = 2

>>> a, b = b, a

>>> a
2
>>> b
1

1

final int HOURS = 24;

1
2
3
4

# File: constant.py
# Path: /home/saeid/Documents/MyModule

HOURS = 24

>>> import sys
>>> sys.path.append('/home/saeid/Documents/MyModule')

>>> import constant
>>> constant.HOURS
24

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

# File: constant.py
# Path: /home/saeid/Documents/MyModule

class _const:

    class ConstError(TypeError): pass

    def __setattr__(self, name, value):
        if name in self.__dict__:
            raise self.ConstError("Can't rebind const(%s)" % name)
        self.__dict__[name] = value

import sys
sys.modules[__name__] = _const()

>>> import sys
>>> sys.path.append('/home/saeid/Documents/MyModule')

>>> import constant
>>> constant.HOURS = 24
>>> constant.HOURS
24
>>> constant.HOURS = 23
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/home/saeid/Documents/MyModule/constant.py", line 10, in __setattr__
    raise self.ConstError("Can't rebind const(%s)" % name)
constant.ConstError: Can't rebind const(HOURS)
>>> constant.HOURS
24

عملگر‌ها¶

«عملگر» (Operator) به نمادی گفته می‌شود که عمل مشخصی را بر روی اشیا به انجام می‌رساند؛ به مانند عملگر انتساب = که پیش از این بررسی شد. همچنین به اشیایی که عملگر‌ بر روی آن‌ها عملی را به انجام می‌رساند «عملوند» (Operand) گفته می‌شود. عملگرها دارای انواع مختلفی هستند که در ادامه بررسی خواهیم کرد.

۱. عملگرهای حسابی (Arithmetic Operators): + - * ** / // %

• + جمع (Addition): مقدار عملوندهای دو طرف خود را با یکدیگر جمع می‌کند. 2 + 1 حاصل: 3

• - تفریق (Subtraction): مقدار عملوند سمت راست را از مقدار عملوند سمت چپ خود منها می‌کند: 4 - 7 حاصل: 3

• * ضرب (Multiplication): مقدار عملوندهای دو طرف خود را در یکدیگر ضرب می‌کند: 2 * 5 حاصل: 10

• ** توان (Exponent): مقدار عملوند سمت چپ را به توان مقدار عملوند سمت راست خود می‌رساند. 3 ** 2 حاصل: 8

• / تقسیم (Division): مقدار عملوند سمت چپ را بر مقدار عملوند سمت راست خود تقسیم می‌کند و خارج قسمت را برمی‌گرداند:

  >>> # Python 3.x              >>> # Python 2.x
  
  >>> 7 / 3                     >>> 7 / 3
  2.3333333333333335            2
  >>> 12 / 3                    >>> 12 / 3
  4.0                           4
  >>> 6.0 / 2                   >>> 6.0 / 2
  3.0                           3.0
  

  همانطور که در نمونه کد بالا مشاهده می‌‌شود؛ در نسخه‌های 3x حاصل هر تقسیمی همواره به صورت عدد اعشاری محاسبه می‌گردد ولی در نسخه‌های 2x حاصل تقسیم دو عدد صحیح به همان صورت عدد صحیح محاسبه و از مقدار اعشار (در صورت وجود) صرف نظر می‌گردد. می‌توان به صورت پایین این ویژگی را به نسخه‌های 2x اضافه کرد [اسناد پایتون]:

  >>> # Python 2.x
  >>> from __future__ import division
  >>> 7 / 3
  2.3333333333333335
  >>> 12 / 3
  4.0
  

• // تقسیم گردشده پایین (Floor Division): مقدار عملوند سمت چپ را بر مقدار عملوند سمت راست خود تقسیم می‌کند و خارج قسمت را با حذف مقدار اعشاری (در صورت وجود) برمی‌گرداند. حاصل این عملگر برای اعداد صحیح به صورت یک عدد صحیح محاسبه می‌گردد، به نتایج نمونه کد پایین توجه نمایید:

  >>> # Python 3.x              >>> # Python 2.x
  
  >>> 7 // 3                    >>> 7 // 3
  2                             2
  >>> 12 // 3                   >>> 12 // 3
  4                             4
  >>> 6.0 // 2                  >>> 6.0 // 2
  3.0                           3.0
  >>> 7.0 // 3                  >>> 7.0 // 3
  2.0                           2.0
  

• % باقی‌ مانده (Modulus): مقدار عملوند سمت چپ را بر مقدار عملوند سمت راست خود تقسیم می‌کند و باقی‌ مانده را برمی‌گرداند. 3 % 7 حاصل: 1

۲. عملگرهای مقایسه‌ (Comparison Operators): == =! <> < > =< =>

• == برابر (Equal): چنانچه مقدار عملوندهای دو طرف برابر باشند، True را برمی‌گرداند. 1 == 3 : False
• =! نابرابر (Not Equal): چنانچه مقدار عملوندهای دو طرف برابر نباشند، True را برمی‌گرداند. 1 =! 3 : True
• <> نابرابر (Not Equal): عملکرد آن همانند =! است ولی فقط در نسخه 2x پایتون قابل استفاده است. 1 <> 3 : True
• < بزرگتر از (Greater Than): چنانچه مقدار عملوند سمت چپ بزرگتر از مقدار عملوند سمت راست آن باشد، True را برمی‌گرداند. 5 < 3 : False
• > کوچکتر از (Less Than): چنانچه مقدار عملوند سمت چپ کوچکتر از مقدار عملوند سمت راست آن باشد، True را برمی‌گرداند. 5 > 3 : True
• =< برابر یا بزرگتر از (Greater Than or Equal): چنانچه مقدار عملوند سمت چپ برابر یا بزرگتر از مقدار عملوند سمت راست آن باشد، True را برمی‌گرداند. 5 =< 7 : True
• => برابر یا کوچکتر از (Less Than or Equal): چنانچه مقدار عملوند سمت چپ برابر یا کوچکتر از مقدار عملوند سمت راست آن باشد، True را برمی‌گرداند. 5 => 7 : False

۳. عملگرهای انتساب (Assignment Operators):

• = عملوند سمت راست را به عملوند سمت چپ خود نسبت می‌دهد. چنانچه یک عبارت محاسباتی در سمت راست باشد، حاصل آن را به عملوند سمت چپ نسبت می‌دهد:

  >>> a = 3
  
  >>> b = 2
  
  >>> c = a + b
  >>> c
  5
  

• =+ =- =* =** =/ =// =% عملگرهای ترکیبی (انتساب حسابی): این عملگرها ابتدا عمل مربوط به عملگر حسابی را بر روی مقدار عملوندهای دو طرف خود به انجام می‌رسانند و سپس حاصل را به عملوند سمت چپ نسبت می‌دهند:

  >>> a += b
  >>> a
  5
  

  >>> a -= b
  >>> a
  1
  

  >>> a *= b
  >>> a
  6
  

  >>> a **= b
  >>> a
  9
  

  >>> # Python 3.x                  >>> # Python 2.x
  >>> a /= b                        >>> a /= b
  >>> a                             >>> a
  1.5                               1
  

۴. عملگرهای بیتی (Bitwise Operators): & | ^ ~ >> <<

این دسته از عملگرها، عمل مشخصی را بر روی تک تک بیت‌های عملوند‌(ها) انجام می‌دهند. در پایتون برای استفاده از این عملگرها لزومی به تبدیل اعداد به پایه دو (دودویی یا باینری Binary) وجود ندارد ولی در اینجا برای مشاهده بهتر عملکرد آن‌ها از اعداد دودویی استفاده کرده‌ایم. در زبان پایتون اعداد پایه دو همواره می‌بایست با یک 0b شروع شوند:

>>> a = 0b0011
>>> a
3
>>> b = 0b0010
>>> b
2

از تابع ()bin می‌توان برای به دست آوردن مقدار دودویی یک عدد ده‌دهی استفاده کرد؛ البته توجه داشته باشید که این تابع مقدار دودویی را در قالب متنی (نوع String) بر می‌گرداند - نکته دیگر اینکه در حالت تعاملی پایتون با وارد کردن اعداد دودویی، خروجی ده‌دهی به دست می‌آید:

>>> bin(10)
'0b1010'

>>> type(bin(10))
<class 'str'>

>>> 0b1010
10

• &: معادل AND بیتی است - تنها بیت‌هایی از خروجی آن 1 خواهند بود که هر دو بیت متناظر از عملوندهای آن 1 باشند:

  >>> a & b                  0000 0011
  2                          0000 0010
                      (AND) -----------
                             0000 0010  = 2
  

• |: معادل OR بیتی است - تنها بیت‌هایی از خروجی آن 0 خواهند بود که هر دو بیت متناظر از عملوندهای آن 0 باشند:

  >>> a | b                  0000 0011
  3                          0000 0010
                       (OR) -----------
                             0000 0011  = 3
  

• ^: معادل XOR بیتی است - تنها بیت‌هایی از خروجی آن 1 خواهند بود که هر دو بیت متناظر از عملوندهای آن مخالف یکدیگر باشند:

  >>> a ^ b                  0000 0011
  1                          0000 0010
                      (XOR) -----------
                             0000 0001  = 1
  

• ~ معادل NOT بیتی و تک عملوندی است - هر یک از بیت‌های عملوند خود را از 0 به 1 و برعکس تبدیل می‌کند:

  >>> ~ a                    0000 0011
  -4                  (NOT) -----------
                             1111 1100
  

  یک شیوه برای نمایش اعداد علامت دار دودویی، همین عمل یعنی برعکس کردن بیت‌ها (0 به 1 و 1 به 0) است که به آن نمایش «مکمل یک» (One’s Complement) اعداد دودویی گفته می‌شود. ولی مفسر پایتون به صورت پیش‌فرض اعداد علامت دار را به شیوه رایج‌تر دیگری ارزیابی می‌کند که به نام نمایش «مکمل دو» (Two’s Complement) شناخته می‌شود؛ در این روش پس از برعکس شدن بیت‌ها، حاصل با عدد 1 جمع می‌شود. بنابراین در نمونه کد بالا حاصل NOT عدد a برابر 11111100 می‌شود که نمایش عدد 4 - در پایه دو به شیوه مکمل دو است:

  n = 3                       0000 0011
  3 = 0000 0011        (NOT) -----------
                              1111 1100  = -3 (in One’s Complement)
                                         = -4 (in Two’s Complement)
  

  Two’s Complement
  
  n = 4                       0000 0100
  4 = 0000 0100        (NOT) -----------
                              1111 1011
                                      1
                       ( + ) -----------
                              1111 1100  = -4
  

  می‌توان مقدار a ~ را برابر حاصل عبارت 1 - a- در نظر گرفت. بنابراین:

  >>> ~ a + 1
  -3
  

• >> شیفت چپ (Left Shift): بیت‌های عملوند سمت چپ را به مقدار عملوند سمت راست خود به سمت چپ جابه‌جا می‌کند - مکان‌های رد شده با صفر مقداردهی می‌شوند:

  >>> a << 3                  0000 0011
  24                   (LSH) -----------
                              0001 1000  = 24
  

• << شیفت راست (Right Shift): بیت‌های عملوند سمت چپ را به مقدار عملوند سمت راست خود به سمت راست جابه‌جا می‌کند - مکان‌های رد شده با صفر مقداردهی می‌شوند:

  >>> a = 88                  0101 1000
  >>> a >> 3           (RSH) -----------
  11                          0000 1011  = 11
  

• =& =| =^ =>> =<< عملگرهای ترکیبی (انتساب بیتی): این عملگرها ابتدا عمل مربوط به عملگر بیتی را بر روی عملوندهای دو طرف خود به انجام می‌رسانند و سپس حاصل را به عملوند سمت چپ نسبت می‌دهند.

۵. عملگرهای منطقی (Logical Operators):

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

a	b	a and b	a or b	not a	not b
True	False	False	True	False	True
False	True	False	True	True	False
False	False	False	False	True	True
True	True	True	True	False	False

عملگر and تنها زمانی که هر دو عملوند آن ارزش True داشته باشند، True را بر می‌گرداند. عملگر or تنها زمانی که هر دو عملوند آن ارزش False داشته باشند، False را برمی‌گرداند. عملگر not نیز ارزش عملود خود را برعکس می‌کند (True به False و False به True).

۶. عملگرهای عضویت (Membership Operators):

شامل دو عملگر in و not in می‌باشد که از آن‌ها برای بررسی وجود یک مقدار در میان اعضای یک دنباله (sequence مانند: رشته، لیست و…) استفاده می‌شود.

• in: اگر مقدار عملوند سمت چپ خود را در عملوند سمت راست بیابد، True و در غیر این صورت False را بر می‌گرداند.
• not in: اگر مقدار عملوند سمت چپ خود را در عملوند سمت راست نیابد، True و در غیر این صورت False را بر می‌گرداند.

>>> "py" in "python"
True
>>> 1 in [1, 2, 3]
True
>>> "s" not in "python"
True
>>> 3 not in [1, 2, 3]
False

۷. عملگرهای هویت (Identity Operators):

شامل دو عملگر is و is not است که از آن‌ها برای بررسی یکی بودن دو شی استفاده می‌شود.

• is: اگر هر دو عملوند به یک شی ارجاع داشته باشند، True و در غیر این صورت False را بر می‌گرداند.
• is not: اگر هر دو عملوند به یک شی ارجاع نداشته باشند، True و در غیر این صورت False را بر می‌گرداند.

>>> a = 3

>>> a is 3
True

اولویت‌ها

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

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

( )               # پرانتز
**
~
-       +         # منفی و مثبت
*       /       //      %
-       +         # بعلاوه و منها
<<      >>
&       ^       |
==      !=      <>
<       <=      >       >=
=       **=     /=      //=      %=      *=      -=      +=
is      is not
in      in not
not     and     or

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

>>> # Python 3.x

>>> 4 + 2 - 3 + 2 * 5
13
>>> 4 + ((2 - 3) + 2) * 5
9
>>> 9 / 3 * 2
6.0
>>> 3 * 2 / 9
0.6666666666666666
>>> (5 - 3) ** (7 - 3)
16
>>> 4 + 3 ** 2 - 9 / 3 * 3
4.0
>>> 4 * 2 == 5 + 3
True

😊 امیدوارم مفید بوده باشه

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

صحیح¶

این نوع از اشیا تمام اعداد مثبت و منفی بدون «ممیز اعشار» را شامل می‌شوند؛ مانند: 1234، 26- و…

ارایه نوع عدد صحیح از موارد اختلاف در نسخه‌های 2x و 3x می‌باشد.

در نسخه‌های 2x اعداد صحیح در قالب دو نوع int (با محدودیت اندازه) و long (بدون محدودیت اندازه) بیان می‌شوند:

>>> a = 3           # Python 2.x
>>> type(a)
<type 'int'>

>>> b = 3L
>>> type(b)
<type 'long'>

به این صورت که اگر عدد صحیحی با حرف L (اِل بزرگ) یا l (اِل کوچک) پایان یابد؛ به صورت نوع long در نظر گرفته خواهد شد. البته توجه داشته باشید چنانچه در نوع int سرریز (Overflow) رخ دهد؛ خطایی به وجود نخواهد آمد و پایتون به صورت خودکار شی نوع int را به شی‌ای از نوع long تبدیل (Convert) خواهد کرد.

بیشینه و کمینه مقدار یک شی از نوع int به ترتیب با استفاده از sys.maxint و sys.maxint - 1 - قابل دریافت است که می‌توانید این مقادیر را در یک نمونه کامپیوتر با معماری ۶۴ بیتی به صورت پایین مشاهده نمایید:

>>> import sys            # Python 2.x

>>> sys.maxint
9223372036854775807
>>> type(_)               # _ is result of the last executed statement  => 9223372036854775807
<type 'int'>

>>> - sys.maxint - 1
-9223372036854775808

>>> type(sys.maxint + 1)
<type 'long'>

در نسخه‌های 3x اعداد صحیح تنها در قالب یک نوع int (بدون محدودیت اندازه) ارایه می‌گردد و باید توجه داشت که استفاده از حرف L (یا l) در پایان اعداد صحیح مجاز نمی‌باشد:

>>> a = 3                   # Python 3.x
>>> type(a)
<class 'int'>

>>> b = 3L
  File "<stdin>", line 1
    b = 3L
         ^
SyntaxError: invalid syntax
>>>

در این نسخه‌ها sys.maxint حذف شده است ولی می‌توان به جای آن از sys.maxsize استفاده کرد که مقدار آن در نمونه کامپیوتر پیش برابر پایین است:

>>> import sys              # Python 3.x

>>> sys.maxsize
9223372036854775807
>>> type(_)
<class 'int'>

>>> type(sys.maxsize + 1)
<class 'int'>

در هر دو شاخه از پایتون؛ اعداد صحیح را می‌توان علاوه بر پایه ده؛ در پایه دو (Binary)، پایه هشت (Octal) و پایه شانزده (Hexadecimal) نیز در نظر گرفت. به این صورت که:

• اعداد پایه دو می‌بایست با یک 0b یا 0B (صفر و حرف بی کوچک یا بزرگ) آغاز گردند؛ مانند: 0b11 که برابر عدد 3 در پایه ده است:

  >>> a = 0b11
  >>> type(a)
  <class 'int'>
  >>> a
  3
  

• اعداد پایه هشت می‌بایست با یک 0o یا 0O (صفر و حرف اُ کوچک یا بزرگ) آغاز گردند؛ مانند: 0o14 که برابر عدد 12 در پایه ده است:

  >>> a = 0o14
  >>> type(a)
  <class 'int'>
  >>> a
  12
  

  همچنین در نسخه‌های 2x برای مشخص کردن عددی در این پایه می‌توان به جای 0o یا 0O، تنها از یک صفر 0 استفاده کرد:

  >>> 0o14    # Python 3.x and Python 2.x
  12
  
  >>> 014     # Python 2.x
  12
  

• اعداد پایه شانزده می‌بایست با یک 0x یا 0X (صفر و حرف اِکس کوچک یا بزرگ) آغاز گردند؛ مانند: 0xA5 که برابر عدد 165 در پایه ده است:

  >>> a = 0xA5
  >>> type(a)
  <class 'int'>
  >>> a
  165
  >>> print(a)
  165
  

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

برای تبدیل یک عدد صحیح در پایه ده به هر یک از این پایه‌ها می‌توانید از تابع‌های آماده ()bin [اسناد پایتون] برای تبدیل به پایه دو، ()oct [اسناد پایتون] برای تبدیل به پایه هشت و ()hex [اسناد پایتون] برای تبدیل به پایه شانزده استفاده نمایید. تنها توجه داشته باشید که خروجی هر یک از این تابع‌ها به صورت یک شی از نوع رشته یا String برگردانده می‌شود و نه یک نوع عددی:

>>> a = 3
>>> b = bin(a)
>>> b
'0b11'
>>> type(b)
<class 'str'>

>>> a = 12
>>> b = oct(a)
>>> b
'0o14'
>>> type(b)
<class 'str'>

>>> a = 165
>>> b = hex(a)
>>> b
'0xa5'
>>> type(b)
<class 'str'>

و برای برگرداندن پایه اعداد صحیح به پایه ده می‌توان از کلاس ()int [اسناد پایتون] استفاده کرد. آرگومان‌های نمونه این کلاس به صورت (int(str, base می‌باشد؛ آرگومان یکم: str می‌بایست یک «رشته عددی» یعنی یک عدد صحیح (در هر پایه‌ای) داخل نمادهای نقل قول (Quotation) باشد که آرگومان دوم، پایه (Base) آن را مشخص می‌کند. در نهایت این کلاس یک شی int متناظر با آرگومان یکم ولی در پایه ده را برمی‌گرداند:

>>> a = 165

>>> type(a)
<class 'int'>

>>> b = hex(a)          # Converted to hexadecimal
>>> b
'0xa5'

>>> type(b)
<class 'str'>

>>> int(b, 16)           # str='0xa5' base=16
165

>>> type(int(b, 16))
<class 'int'>

توجه داشته باشید که می‌توان اعداد را بدون حرف مشخص کننده پایه (0x 0o 0b) به این کلاس ارسال کنیم. همچنین از این کلاس می‌توان برای تبدیل نوع رشته‌های عددی در پایه ده به عدد صحیح استفاده کرد. مقدار پیش‌فرض آرگومان پایه 10 است؛ بنابراین در هنگام ارسال اعداد در این پایه، نیازی به ذکر پایه 10 نمی‌باشد:

>>> int("A5", 16)    # 0xA5
165

>>> a = "56"
>>> int(a, 10)
56
>>> int(a)
56

>>> int()
0

()int بدون آرگومان یک شی صفر از نوع صحیح را برمی‌گرداند.

با تفاوت شیوه ارایه نوع اعداد صحیح در بین نسخه‌های 2x و 3x پایتون آشنا شده‌ایم. فقط باید توجه داشت که در نسخه‌های 2x پایتون؛ کلاس ()int [اسناد پایتون] یک شی از نوع int را برمی‌گرداند و برای ایجاد اشیایی از نوع long کلاس مشابه دیگری با نام ()long [اسناد پایتون] در دسترس است:

>>> a = 25     # Python 2.x

>>> int(a)
25

>>> long(a)
25L

در هر دو شاخه از پایتون؛ اعداد در پایه ده را می‌توان با نوع عددی - نه به شکل رشته عددی - نیز به تابع ()int (یا ()long) ارسال نمود.

برای به دست آوردن اندازه یا میزان حافظه گرفته شده توسط یک شی به واحد بایت (Byte) می‌توان از تابع ()getsizeof [اسناد پایتون] درون ماژول sys استفاده نماییم - خروجی این تابع برای دو شی صحیح دلخواه در یک نمونه کامپیوتر ۶۴ بیتی به صورت پایین است:

>>> import sys                # Python 3.x
>>> a = 1
>>> sys.getsizeof(a)
28
>>> sys.getsizeof(10**100)
72

>>> import sys                # Python 2.x
>>> a = 1
>>> sys.getsizeof(a)
24
>>> sys.getsizeof(10**100)
72

ممیز شناور¶

تمام اعداد مثبت و منفی که شامل یک «ممیز اعشار» هستند در پایتون به صورت اشیایی با نوع float (معادل نوع double در زبان C) ارایه می‌شوند؛ مانند: 3.1415، .5 (برابر 5.0) و…

>>> a = 3.1415
>>> type(a)
<class 'float'>

>>> import sys
>>> sys.getsizeof(a)
24

جزییات این نوع با استفاده از sys.float_info [اسناد پایتون] قابل مشاهده است:

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

گاهی برای نمایش اعداد از شیوه «نماد علمی» (Scientific Notation) استفاده می‌شود؛ در پایتون هم می‌توان از حرف E یا e که معادل «ضرب در ۱۰ به توانِ» می‌باشد، برای این منظور استفاده کرد.

>>> 3e2
300.0

>>> type(3e2)
<class 'float'>

>>> 3e-2
0.03

>>> 3e+2
300.0

می‌توان از کلاس ()float [اسناد پایتون] برای تبدیل اعداد یا رشته‌های عددی به یک شی ممیز شناور استفاده کرد:

>>> a = 920

>>> type(a)
<class 'int'>

>>> float(a)
920.0

>>> type(float(a))
<class 'float'>

>>> float("920")
920.0

>>> float("3e+2")
300.0

>>> float()
0.0

()float بدون آرگومان یک شی صفر از نوع ممیز شناور را برمی‌گرداند.

چنانچه عددی از نوع ممیز شناور در آرگومان کلاس ()int قرار بگیرد؛ تنها بخش صحیح عدد برگردانده می‌شود:

>>> a = 2.31
>>> type(a)
<class 'float'>

>>> int(a)
2
>>> type(int(a))
<class 'int'>

>>> int(3.9)
3

با استفاده از کلاس ()float می‌توانیم اشیایی با مقدارهای مثبت و منفی «بی‌نهایت» (infinity) برابر: inf یا infinity و «تعریف نشده» (Not a Number) برابر: NaN ایجاد نماییم - چگونگی کوچک یا بزرگ نوشتن حروف این کلمه‌ها تفاوتی در آن‌ها ایجاد نمی‌کند:

>>> a = float('infinity')
>>> a = float('inf')
>>> a
inf

>>> b = float('-infinity')
>>> b = float('-inf')
>>> b
-inf

>>> c = float('NaN')
>>> c
nan

>>> a = float('inf')

>>> 5 / a
0.0

>>> a / a
nan

>>> a = float('inf')
>>> b = float('inf')
>>> a == b
True

>>> a = float('nan')
>>> b = float('nan')
>>> a == b
False

دو شی NaN با یکدیگر برابر نیستند.

برای بررسی اینکه مقدار یک شی «بی‌نهایت» یا «تعریف نشده» است؛ می‌توان به ترتیب از تابع‌های ()isinf [اسناد پایتون] و ()isnan [اسناد پایتون] درون ماژول math استفاده نماییم:

>>> a = float('inf')
>>> b = float('nan')

>>> import math

>>> math.isinf(a)
True
>>> math.isnan(b)
True

مختلط¶

همانطور که می‌دانیم اعداد مختلط (Complex Numbers) از یک بخش حقیقی (Real) و یک بخش موهومی (Imaginary) تشکیل شده‌اند. این اعداد در پایتون الگویی برابر RealPart + ImaginaryPart j دارند که حرف j نشانگر «واحد موهومی» است. این اعداد در پایتون توسط اشیایی با نوع complex ارایه می‌شوند:

>>> a = 3 + 4j
>>> type(a)
<class 'complex'>

>>> import sys
>>> sys.getsizeof(a)
32

از کلاس ()complex [اسناد پایتون] می‌توان برای ایجاد یک شی complex استفاده کرد. این کلاس الگویی مشابه (complex(real, imag دارد؛ آرگومان‌های نمونه real و imag بیانگر اعدادی هستند که به ترتیب قرار است در بخش‌های حقیقی و موهومی عدد مختلط مورد نظر وجود داشته باشند. اگر هر کدام از آرگومان‌ها ارسال نگردند به صورت پیش‌فرض صفر در نظر گرفته خواهند شد:

>>> a = 3
>>> b = 4

>>> type(a)
<class 'int'>
>>> type(b)
<class 'int'>

>>> complex(a, b)
(3+4j)

>>> type(complex(a, b))
<class 'complex'>

>>> complex(3, 4)
(3+4j)

>>> complex(3)
(3+0j)

>>> complex(0, 4)
4j

>>> complex(4j)
4j

>>> a = 3 + 4j
>>> a
(3+4j)

>>> a = 3.2 + 4j
>>> a
(3.2+4j)

>>> a = 3.0 + 4j
>>> a
(3+4j)

>>> a = 3.0 + 4.0j
>>> a
(3+4j)