کاوش و درک پایتون از طریق تکه‌های کد شگفت‌انگیز.

ترجمه‌ها: انگلیسی English | چینی 中文 | ویتنامی Tiếng Việt | اسپانیایی Español | کره‌ای 한국어 | روسی Русский | آلمانی Deutsch | Persian فارسی | اضافه کردن ترجمه

حالت‌های دیگر: وبسایت تعاملی | دفترچه تعاملی

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

این یه پروژه باحاله که سعی داریم توش توضیح بدیم که پشت پرده یه سری قطعه‌کدهای غیرشهودی و قابلیت‌های کمتر شناخته شده پایتون چه خبره.

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

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

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

پس، بزن بریم...

• فهرست مطالب
• ساختار مثال‌ها
• استفاده
• 👀 مثال‌ها
  • بخش: ذهن خود را به چالش بکشید!
    • ◀ اول از همه! *
      • 💡 توضیح
    • ◀ بعضی وقت‌ها رشته‌ها می‌توانند دردسرساز شوند
      • 💡 توضیح:
    • ◀ مراقب عملیات‌های زنجیره‌ای باشید
      • 💡 توضیح:
    • ◀ چطور از عملگر is استفاده نکنیم
      • 💡 توضیح:
    • ◀ کلیدهای هش
      • 💡 توضیح
    • ◀ در عمق وجود همه ما یکسان هستیم
      • 💡 توضیح:
    • ◀ بی‌نظمی در خود نظم *
      • 💡 توضیح:
      • 💡 توضیح:
    • ◀ برای چی؟
      • 💡 توضیح:
    • ◀ اختلاف زمانی در محاسبه
      • 💡 توضیح
    • ◀ هر گردی، گردو نیست
      • 💡 توضیح
    • ◀ یک بازی دوز که توش X همون اول برنده میشه!
      • 💡 توضیح:
    • ◀ متغیر شرودینگر *
      • 💡 توضیح:
    • ◀ اول مرغ بوده یا تخم مرغ؟ *
      • 💡 توضیح
    • ◀ روابط بین زیرمجموعه کلاس‌ها
      • 💡 توضیح:
    • ◀ برابری و هویت متدها
      • 💡 توضیح
    • ◀ آل-ترو-یشن *
      • 💡 توضیحات:
      • 💡 توضیح:
    • ◀ رشته‌ها و بک‌اسلش‌ها
      • 💡 توضیح:
    • ◀ گره نیست، نَه!
      • 💡 توضیح:
    • ◀ رشته‌های نیمه سه‌نقل‌قولی
      • 💡 توضیح:
    • ◀ مشکل بولین ها چیست؟
      • 💡 توضیح:
    • ◀ متغیرهای کلاس و متغیرهای نمونه
      • 💡 توضیح:
    • ◀ واگذار کردن None
      • 💡 توضیح:
    • ◀ بازگرداندن با استفاده از yield from!
      • 💡 توضیح:
    • ◀ بازتاب‌ناپذیری *
      • 💡 توضیح:
    • ◀ تغییر دادن اشیای تغییرناپذیر!
      • 💡 توضیح:
    • ◀ متغیری که از اسکوپ بیرونی ناپدید می‌شود
      • 💡 توضیح:
    • ◀ تبدیل اسرارآمیز نوع کلید
      • 💡 توضیح:
    • ◀ ببینیم می‌توانید این را حدس بزنید؟
      • 💡 توضیح:
    • ◀ از حد مجاز برای تبدیل رشته به عدد صحیح فراتر می‌رود
      • 💡 توضیح:
  • بخش: شیب‌های لغزنده
    • ◀ تغییر یک دیکشنری هنگام پیمایش روی آن
      • 💡 توضیح:
    • ◀ عملیات سرسختانه‌ی del
      • 💡 توضیح:
    • ◀ متغیری که از حوزه خارج است
      • 💡 توضیح:
    • ◀ حذف المان‌های لیست در حین پیمایش
      • 💡 توضیح:
    • ◀ زیپِ دارای اتلاف برای پیمایشگرها *
      • 💡 توضیح:
    • ◀ نشت کردن متغیرهای حلقه!
      • 💡 توضیح:
    • ◀ مراقب آرگومان‌های تغییرپذیر پیش‌فرض باشید!
      • 💡 توضیح:
    • ◀ گرفتن استثناها (Exceptions)
      • 💡 توضیح
    • ◀ عملوندهای یکسان، داستانی متفاوت!
      • 💡 توضیح:
    • ◀ تفکیک نام‌ها با نادیده گرفتن حوزه‌ی کلاس
      • 💡 توضیح
    • ◀ گرد کردن به روش بانکدار *
      • 💡 توضیح:
    • ◀ سوزن‌هایی در انبار کاه *
      • 💡 توضیح:
    • ◀ تقسیم‌ها *
      • 💡 توضیح:
    • ◀ واردسازی‌های عمومی *
      • 💡 توضیح:
    • ◀ همه چیز مرتب شده؟ *
      • 💡 توضیح:
    • ◀ زمان نیمه‌شب وجود ندارد؟
      • 💡 توضیح:
  • بخش: گنجینه‌های پنهان!
    • ◀ خب پایتون، می‌توانی کاری کنی پرواز کنم؟
      • 💡 توضیح:
    • ◀ goto، ولی چرا؟
      • 💡 توضیح:
    • ◀ خودتان را آماده کنید!
      • 💡 توضیح:
    • ◀ بیایید با «عمو زبان مهربان برای همیشه» آشنا شویم
      • 💡 توضیح:
    • ◀ حتی پایتون هم می‌داند که عشق پیچیده است
      • 💡 توضیح:
    • ◀ بله، این واقعاً وجود دارد!
      • 💡 توضیح:
    • ◀ عملگر Ellipsis *
      • 💡توضیح
    • ◀ بی‌نهایت (Inpinity)
      • 💡 توضیح:
    • ◀ بیایید خرابکاری کنیم
      • 💡 توضیح:
  • بخش: ظاهرها فریبنده‌اند!
    • ◀ خطوط را رد می‌کند؟
      • 💡 توضیح
    • ◀ تله‌پورت کردن
      • 💡 توضیح:
    • ◀ خب، یک جای کار مشکوک است...
      • 💡 توضیح
  • بخش: متفرقه
    • ◀ += سریع‌تر است
      • 💡 توضیح:
    • ◀ بیایید یک رشته‌ی بزرگ بسازیم!
      • 💡 توضیح
    • ◀ کُند کردن جستجوها در dict *
      • 💡 توضیح:
    • ◀ حجیم کردن دیکشنری نمونه‌ها (instance dicts) *
      • 💡 توضیح:
    • ◀ موارد جزئی *
• مشارکت
• تقدیر و تشکر - چند لینک جالب!
• 🎓 مجوز
  • دوستانتان را هم شگفت‌زده کنید!
  • آیا به یک نسخه pdf نیاز دارید؟

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

◀ یه اسم خوشگل

# راه اندازی کد
# آماده سازی برای جادو...

خروجی (نسخه(های) پایتون):

>>> triggering_statement
یه خروجی غیرمنتظره

(دلخواه): توضیح یک‌خطی خروجی غیرمنتظره

💡 توضیح:

• توضیح کوتاه درمورد این‌که چی داره اتفاق میافته و چرا.

# راه اندازی کد
# مثال‌های بیشتر برای شفاف سازی (در صورت نیاز)

خروجی (نسخه(های) پایتون):

>>> trigger # یک مثال که رونمایی از جادو رو راحت‌تر می‌کنه
# یک خروجی توجیه شده و واضح

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

یه راه خوب برای بیشتر بهره بردن، به نظرم، اینه که مثال‌ها رو به ترتیب متوالی بخونید و برای هر مثال:

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

به دلایلی، عملگر "Walrus" (:=) که در نسخه ۳.۸ پایتون معرفی شد، خیلی محبوب شده. بیاید بررسیش کنیم.

1.

# Python version 3.8+

>>> a = "wtf_walrus"
>>> a
'wtf_walrus'

>>> a := "wtf_walrus"
File "<stdin>", line 1
    a := "wtf_walrus"
      ^
SyntaxError: invalid syntax

>>> (a := "wtf_walrus") # ولی این کار می‌کنه
'wtf_walrus'
>>> a
'wtf_walrus'

2 .

# Python version 3.8+

>>> a = 6, 9
>>> a
(6, 9)

>>> (a := 6, 9)
(6, 9)
>>> a
6

>>> a, b = 6, 9 # باز کردن معمولی
>>> a, b
(6, 9)
>>> (a, b = 16, 19) # آخ آخ
  File "<stdin>", line 1
    (a, b = 16, 19)
          ^
SyntaxError: invalid syntax

>>> (a, b := 16, 19) # این یه تاپل ۳تایی چاپ می‌کنه رو صفحه
(6, 16, 19)

>>> a # هنوز تغییر نکرده؟
6

>>> b
16

مرور سریع بر عملگر Walrus

عملگر Walrus همونطور که اشاره شد، در نسخه ۳.۸ پایتون معرفی شد. این عملگر می‌تونه تو موقعیت‌هایی کاربردی باشه که شما می‌خواید داخل یه عبارت، مقادیری رو به متغیرها اختصاص بدید.

def some_func():
        # فرض کنید اینجا یک سری محاسبه سنگین انجام میشه
        # time.sleep(1000)
        return 5

# پس به جای اینکه این کارو بکنید:
if some_func():
        print(some_func()) # که خیلی راه نادرستیه چون محاسبه دوبار انجام میشه

# یا حتی این کارو کنید (که کار بدی هم نیست)
a = some_func()
if a:
    print(a)

# می‌تونید از این به بعد به طور مختصر بنویسید:
if a := some_func():
        print(a)

خروجی (+۳.۸):

5
5
5

این باعث میشه که یک خط کمتر کد بزنیم و از دوبار فراخوندن some_func جلوگیری کرد.

• "عبارت اختصاص‌دادن مقدار" بدون پرانتز (نحوه استفاده عملگر Walrus)، در سطح بالا محدود است، SyntaxError در عبارت a := "wtf_walrus" در قطعه‌کد اول به همین دلیل است. قرار دادن آن داخل پرانتز، همانطور که می‌خواستیم کار کرد و مقدار را به a اختصاص داد.

• به طور معمول، قرار دادن عبارتی که دارای = است داخل پرانتز مجاز نیست. به همین دلیل ‍عبارت (a, b = 6, 9) به ما خطای سینتکس داد.

• قائده استفاده از عملگر Walrus به صورت NAME:= expr است، به طوری که NAME یک شناسه صحیح و expr یک عبارت صحیح است. به همین دلیل باز و بسته کردن با تکرار (iterable) پشتیبانی نمی‌شوند. پس،

  • عبارت (a := 6, 9) معادل عبارت ((a := 6), 9) و در نهایت (a, 9) است. (که مقدار a عدد 6 است)

    >>> (a := 6, 9) == ((a := 6), 9)
    True
    >>> x = (a := 696, 9)
    >>> x
    (696, 9)
    >>> x[0] is a # هر دو به یک مکان در حافظه دستگاه اشاره می‌کنند
    True

  • به طور مشابه، عبارت (a, b := 16, 19) معادل عبارت (a, (b := 16), 19) است که چیزی جز یک تاپل ۳تایی نیست.

1.

>>> a = "some_string"
>>> id(a)
140420665652016
>>> id("some" + "_" + "string") # دقت کنید که هردو شناسه یکسانند.
140420665652016

2.

>>> a = "wtf"
>>> b = "wtf"
>>> a is b
True

>>> a = "wtf!"
>>> b = "wtf!"
>>> a is b
False

3.

>>> a, b = "wtf!", "wtf!"
>>> a is b # همه‌ی نسخه‌ها به جز 3.7.x
True

>>> a = "wtf!"; b = "wtf!"
>>> a is b # ممکن است True یا False باشد بسته به جایی که آن را اجرا می‌کنید (python shell / ipython / به‌صورت اسکریپت)
False

# این بار در فایل some_file.py
a = "wtf!"
b = "wtf!"
print(a is b)

# موقع اجرای ماژول، True را چاپ می‌کند!

4.

خروجی (< Python3.7 )

>>> 'a' * 20 is 'aaaaaaaaaaaaaaaaaaaa'
True
>>> 'a' * 21 is 'aaaaaaaaaaaaaaaaaaaaa'
False

منطقیه، نه؟

• در قطعه‌کد اول و دوم، رفتار کد به دلیل یک بهینه سازی در CPython است (به نام داوطلب سازی رشته‌ها) که باعث می‌شود از برخی مقادیر غیرقابل تغییر، به جای مقداردهی مجدد، دوباره استفاده شود.
• بیشتر متغیرهایی که به‌این صورت جایگزین می‌شوند، در حافظه دستگاه به مقدار داوطلب خود اشاره می‌کنند (تا از حافظه کمتری استفاده شود)
• در قطعه‌کدهای بالا، رشته‌ها به‌صورت غیرمستقیم داوطلب می‌شوند. تصمیم اینکه رشته‌ها چه زمانی به صورت غیرمستقیم داوطلب شوند به نحوه پیاده‌سازی و مقداردهی آن‌ها بستگی دارد. برخی قوانین وجود دارند تا بتوانیم داوطلب شدن یا نشدن یک رشته را حدس بزنیم:
  • همه رشته‌ها با طول صفر یا یک داوطلب می‌شوند.
  • رشته‌ها در زمان کامپایل داوطلب می‌شوند ('wtf' داوطلب می‌شود اما ''.join(['w', 't', 'f']) داوطلب نمی‌شود)
  • رشته‌هایی که از حروف ASCII ، اعداد صحیح و آندرلاین تشکیل نشده‌باشند داوطلب نمی‌شود. به همین دلیل 'wtf!' به خاطر وجود '!' داوطلب نشد. پیاده‌سازی این قانون در CPython در اینجا قرار دارد.

• زمانی که "wtf!" را در یک خط به a و b اختصاص می‌دهیم، مفسر پایتون شیء جدید می‌سازد و متغیر دوم را به آن ارجاع می‌دهد. اگر مقدار دهی در خط‌های جدا از هم انجام شود، در واقع مفسر "خبر ندارد" که یک شیء مختص به "wtf!" از قبل در برنامه وجود دارد (زیرا "wtf!" به دلایلی که در بالا گفته شد، به‌صورت غیرمستقیم داوطلب نمی‌شود). این بهینه سازی در زمان کامپایل انجام می‌شود. این بهینه سازی همچنین برای نسخه های (x).۳.۷ وجود ندارد (برای گفت‌وگوی بیشتر این موضوع را ببینید).
• یک واحد کامپایل در یک محیط تعاملی مانند IPython از یک عبارت تشکیل می‌شود، در حالی که برای ماژول‌ها شامل کل ماژول می‌شود. a, b = "wtf!", "wtf!" یک عبارت است. در حالی که a = "wtf!"; b = "wtf!" دو عبارت در یک خط است. به همین دلیل شناسه‌ها در a = "wtf!"; b = "wtf!" متفاوتند و همین‌طور وقتی با مفسر پایتون داخل فایل some_file.py اجرا می‌شوند، شناسه‌ها یکسانند.
• تغییر ناگهانی در خروجی قطعه‌کد چهارم به دلیل بهینه‌سازی پنجره‌ای است که تکنیکی معروف به جمع آوری ثابت‌ها است. به همین خاطر عبارت 'a'*20 با 'aaaaaaaaaaaaaaaaaaaa' در هنگام کامپایل جایگزین می‌شود تا کمی بار از دوش چرخه‌ساعتی پردازنده کم شود. تکنیک جمع آوری ثابت‌ها فقط مخصوص رشته‌هایی با طول کمتر از 21 است. (چرا؟ فرض کنید که فایل .pyc که توسط کامپایلر ساخته می‌شود چقدر بزرگ می‌شد اگر عبارت 'a'*10**10). این هم کد پیاده‌سازی این تکنیک در CPython.
• توجه: در پایتون ۳.۷، جمع آوری ثابت‌ها از بهینه‌ساز پنجره‌ای به بهینه‌ساز AST جدید انتقال داده شد همراه با تغییراتی در منطق آن. پس چهارمین قطعه‌کد در پایتون نسخه ۳.۷ کار نمی‌کند. شما می‌توانید در اینجا بیشتر درمورد این تغییرات بخوانید.

>>> (False == False) in [False] # منطقیه
False
>>> False == (False in [False]) # منطقیه
False
>>> False == False in [False] # حالا چی؟
True

>>> True is False == False
False
>>> False is False is False
True

>>> 1 > 0 < 1
True
>>> (1 > 0) < 1
False
>>> 1 > (0 < 1)
False

طبق https://docs.python.org/3/reference/expressions.html#comparisons

اگر a، b، c، ...، y، z عبارت‌های عملیات و op1، op2، ...، opN عملگرهای عملیات باشند، آنگاه عملیات a op1 b op2 c ... y opN z معادل عملیات a op1 b and b op2 c and ... y opN z است. فقط دقت کنید که هر عبارت یک بار ارزیابی می‌شود.

شاید چنین رفتاری برای شما احمقانه به نظر بیاد ولی برای عملیات‌هایی مثل a == b == c و 0 <= x <= 100 عالی عمل می‌کنه.

• عبارت False is False is False معادل عبارت (False is False) and (False is False) است

• عبارت True is False == False معادل عبارت (True is False) and (False == False) است و از آنجایی که قسمت اول این عبارت (True is False) پس از ارزیابی برابر با False می‌شود. پس کل عبارت معادل False می‌شود.

• عبارت 1 > 0 < 1 معادل عبارت (1 > 0) and (0 < 1) است.

• عبارت (1 > 0) < 1 معادل عبارت True < 1 است و :

  >>> int(True)
  1
  >>> True + 1 # مربوط به این بخش نیست ولی همینجوری گذاشتم
  2

  پس عبارت True < 1 معادل عبارت 1 < 1 می‌شود که در کل معادل False است.

عبارت پایین خیلی معروفه و تو کل اینترنت موجوده.

1.

>>> a = 256
>>> b = 256
>>> a is b
True

>>> a = 257
>>> b = 257
>>> a is b
False

2.

>>> a = []
>>> b = []
>>> a is b
False

>>> a = tuple()
>>> b = tuple()
>>> a is b
True

3. خروجی

>>> a, b = 257, 257
>>> a is b
True

خروجی (مخصوص نسخه‌های (x).۳.۷)

>>> a, b = 257, 257
>>> a is b
False

فرض بین عملگرهای is و ==

• عملگر is بررسی میکنه که دو متغیر در حافظه دستگاه به یک شیء اشاره میکنند یا نه (یعنی شناسه متغیرها رو با هم تطبیق میده).

• عملگر == مقدار متغیرها رو با هم مقایسه میکنه و یکسان بودنشون رو بررسی میکنه.

• پس is برای معادل بودن متغیرها در حافظه دستگاه و == برای معادل بودن مقادیر استفاده میشه. یه مثال برای شفاف سازی بیشتر:

  >>> class A: pass
  >>> A() is A() # این‌ها دو شیء خالی هستند که در دو جای مختلف در حافظه قرار دارند.
  False

عدد 256 از قبل تو حافظه قرار داده شده ولی 257 نه؟

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

نقل قول از https://docs.python.org/3/c-api/long.html

در پیاده سازی فعلی یک آرایه از اشیاء عددی صحیح برای تمام اعداد صحیح بین -5 تا 256 نگه‌داری می‌شود. وقتی شما یک عدد صحیح در این بازه به مقداردهی می‌کنید، فقط یک ارجاع به آن عدد که از قبل در حافظه ذخیره شده است دریافت می‌کنید. پس تغییر مقدار عدد 1 باید ممکن باشد. که در این مورد من به رفتار پایتون شک دارم تعریف‌نشده است. :-)

>>> id(256)
10922528
>>> a = 256
>>> b = 256
>>> id(a)
10922528
>>> id(b)
10922528
>>> id(257)
140084850247312
>>> x = 257
>>> y = 257
>>> id(x)
140084850247440
>>> id(y)
140084850247344

در اینجا مفسر وقتی عبارت y = 257 رو اجرا میکنه، به اندازه کافی زیرکانه عمل نمیکنه که تشخیص بده که ما یک عدد صحیح با مقدار 257 در حافظه ذخیره کرده‌ایم، پس به ساختن یک شیء جدید در حافظه ادامه میده.

یک بهینه سازی مشابه شامل حال مقادیر غیرقابل تغییر دیگه مانند تاپل‌های خالی هم میشه. از اونجایی که لیست‌ها قابل تغییرند، عبارت [] is [] مقدار False رو برمیگردونه و عبارت () is () مقدار True رو برمیگردونه. به همین دلیله که قطعه کد دوم چنین رفتاری داره. بریم سراغ سومی.

متغیرهای a و b وقتی در یک خط با مقادیر یکسانی مقداردهی میشن، هردو به یک شیء در حافظه اشاره میکنن

خروجی

>>> a, b = 257, 257
>>> id(a)
140640774013296
>>> id(b)
140640774013296
>>> a = 257
>>> b = 257
>>> id(a)
140640774013392
>>> id(b)
140640774013488

• وقتی a و b در یک خط با 257 مقداردهی میشن، مفسر پایتون یک شیء برای یکی از متغیرها در حافظه میسازه و متغیر دوم رو در حافظه به اون ارجاع میده. اگه این کار رو تو دو خط جدا از هم انجام بدید، درواقع مفسر پایتون از وجود مقدار 257 به عنوان یک شیء، "خبر نداره".

• این یک بهینه سازی توسط کامپایلر هست و مخصوصا در محیط تعاملی به کار برده میشه. وقتی شما دو خط رو در یک مفسر زنده وارد می‌کنید، اون‌ها به صورت جداگانه کامپایل میشن، به همین دلیل بهینه سازی به صورت جداگانه برای هرکدوم اعمال میشه. اگر بخواهید این مثال رو در یک فایل .py امتحان کنید، رفتار متفاوتی می‌بینید زیرا فایل به صورت کلی و یک‌جا کامپایل میشه. این بهینه سازی محدود به اعداد صحیح نیست و برای انواع داده‌های غیرقابل تغییر دیگه مانند رشته‌ها (مثال "رشته‌ها می‌توانند دردسرساز شوند" رو ببینید) و اعداد اعشاری هم اعمال میشه.

  >>> a, b = 257.0, 257.0
  >>> a is b
  True

• چرا این برای پایتون ۳.۷ کار نکرد؟ دلیل انتزاعیش اینه که چنین بهینه‌سازی‌های کامپایلری وابسته به پیاده‌سازی هستن (یعنی بسته به نسخه، و نوع سیستم‌عامل و چیزهای دیگه تغییر میکنن). من هنوز پیگیرم که بدونم که کدوم تغییر تو پیاده‌سازی باعث همچین مشکلاتی میشه، می‌تونید برای خبرهای بیشتر این موضوع رو نگاه کنید.

1.

some_dict = {}
some_dict[5.5] = "JavaScript"
some_dict[5.0] = "Ruby"
some_dict[5] = "Python"

خروجی:

>>> some_dict[5.5]
"JavaScript"
>>> some_dict[5.0] # رشته ("Python")، رشته ("Ruby") رو از بین برد؟
"Python"
>>> some_dict[5]
"Python"

>>> complex_five = 5 + 0j
>>> type(complex_five)
complex
>>> some_dict[complex_five]
"Python"

خب، چرا Python همه جارو گرفت؟

• تو دیکشنری‌های پایتون چیزی که کلیدها رو یگانه میکنه مقدار کلیدهاست، نه شناسه اون‌ها. پس با اینکه 5، 5.0 و 5 + 0j شیءهای متمایزی از نوع‌های متفاوتی هستند ولی از اون جایی که مقدارشون با هم برابره، نمیتونن داخل یه dict به عنوان کلید جدا از هم باشن (حتی به عنوان مقادیر داخل یه set نمیتونن باشن). وقتی بخواید داخل یه دیکشنری جست‌وجو کنید، به محض اینکه یکی از این داده‌ها رو وارد کنید، مقدار نگاشته‌شده به کلیدی که مقدار برابر با اون داده داره ولی نوعش متفاوته، با موفقیت برگردونده میشه (به جای اینکه به ارور KeyError بردخورد کنید.).

  >>> 5 == 5.0 == 5 + 0j
  True
  >>> 5 is not 5.0 is not 5 + 0j
  True
  >>> some_dict = {}
  >>> some_dict[5.0] = "Ruby"
  >>> 5.0 in some_dict
  True
  >>> (5 in some_dict) and (5 + 0j in some_dict)
  True

• همچنین این قانون برای مقداردهی توی دیکشنری هم اعمال میشه. وقتی شما عبارت some_dict[5] = "Python" رو اجرا می‌کنید، پایتون دنبال کلیدی با مقدار یکسان می‌گرده که اینجا ما داریم 5.0 -> "Ruby" و مقدار نگاشته‌شده به این کلید در دیکشنری رو با مقدار جدید جایگزین میکنه و کلید رو همونجوری که هست باقی میذاره.

  >>> some_dict
  {5.0: 'Ruby'}
  >>> some_dict[5] = "Python"
  >>> some_dict
  {5.0: 'Python'}

• خب پس چطوری میتونیم مقدار خود کلید رو به 5 تغییر بدیم (جای 5.0)؟ راستش ما نمیتونیم این کار رو درجا انجام بدیم، ولی میتونیم اول اون کلید رو پاک کنیم (del some_dict[5.0]) و بعد کلیدی که میخوایم رو قرار بدیم (some_dict[5]) تا بتونیم عدد صحیح 5 رو به جای عدد اعشاری 5.0 به عنوان کلید داخل دیکشنری داشته باشیم. درکل خیلی کم پیش میاد که بخوایم چنین کاری کنیم.

• پایتون چطوری توی دیکشنری که کلید 5.0 رو داره، کلید 5 رو پیدا کرد؟ پایتون این کار رو توی زمان ثابتی توسط توابع هش انجام میده بدون اینکه مجبور باشه همه کلیدها رو بررسی کنه. وقتی پایتون دنبال کلیدی مثل foo داخل یه dict میگرده، اول مقدار hash(foo) رو محاسبه میکنه (که توی زمان ثابتی انجام میشه). از اونجایی که توی پایتون برای مقایسه برابری مقدار دو شیء لازمه که هش یکسانی هم داشته باشند (مستندات). 5، 5.0 و 5 + 0j مقدار هش یکسانی دارند.

  >>> 5 == 5.0 == 5 + 0j
  True
  >>> hash(5) == hash(5.0) == hash(5 + 0j)
  True

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

class WTF:
  pass

خروجی:

>>> WTF() == WTF() # دو نمونه متفاوت از یک کلاس نمیتونند برابر هم باشند
False
>>> WTF() is WTF() # شناسه‌ها هم متفاوتند
False
>>> hash(WTF()) == hash(WTF()) # هش‌ها هم _باید_ متفاوت باشند
True
>>> id(WTF()) == id(WTF())
True

• وقتی id صدا زده شد، پایتون یک شیء با کلاس WTF ساخت و اون رو به تابع id داد. تابع id شناسه این شیء رو میگیره (درواقع آدرس اون شیء در حافظه دستگاه) و شیء رو حذف میکنه.

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

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

• ولی چرا با عملگر is مقدار False رو دریافت کردیم؟ بیاید با یه قطعه‌کد ببینیم دلیلش رو.

  class WTF(object):
    def __init__(self): print("I")
    def __del__(self): print("D")

  خروجی:

  >>> WTF() is WTF()
  I
  I
  D
  D
  False
  >>> id(WTF()) == id(WTF())
  I
  D
  I
  D
  True

  همونطور که مشاهده می‌کنید، ترتیب حذف شدن شیءها باعث تفاوت میشه.

from collections import OrderedDict

dictionary = dict()
dictionary[1] = 'a'; dictionary[2] = 'b';

ordered_dict = OrderedDict()
ordered_dict[1] = 'a'; ordered_dict[2] = 'b';

another_ordered_dict = OrderedDict()
another_ordered_dict[2] = 'b'; another_ordered_dict[1] = 'a';

class DictWithHash(dict):
    """
    یک dict که تابع جادویی __hash__ هم توش پیاده شده.
    """
    __hash__ = lambda self: 0

class OrderedDictWithHash(OrderedDict):
    """
    یک OrderedDict که تابع جادویی __hash__ هم توش پیاده شده.
    """
    __hash__ = lambda self: 0

خروجی

>>> dictionary == ordered_dict # اگر مقدار اولی با دومی برابره
True
>>> dictionary == another_ordered_dict # و مقدار اولی با سومی برابره
True
>>> ordered_dict == another_ordered_dict # پس چرا مقدار دومی با سومی برابر نیست؟
False

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

>>> len({dictionary, ordered_dict, another_ordered_dict})
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'dict'

# منطقیه چون dict ها __hash__ توشون پیاده‌سازی نشده. پس بیاید از
# کلاس‌هایی که خودمون درست کردیم استفاده کنیم.
>>> dictionary = DictWithHash()
>>> dictionary[1] = 'a'; dictionary[2] = 'b';
>>> ordered_dict = OrderedDictWithHash()
>>> ordered_dict[1] = 'a'; ordered_dict[2] = 'b';
>>> another_ordered_dict = OrderedDictWithHash()
>>> another_ordered_dict[2] = 'b'; another_ordered_dict[1] = 'a';
>>> len({dictionary, ordered_dict, another_ordered_dict})
1
>>> len({ordered_dict, another_ordered_dict, dictionary}) # ترتیب رو عوض می‌کنیم
2

چی شد؟

• دلیل اینکه این مقایسه بین متغیرهای dictionary، ordered_dict و another_ordered_dict به درستی اجرا نمیشه به خاطر نحوه پیاده‌سازی تابع __eq__ در کلاس OrderedDict هست. طبق مستندات

  مقایسه برابری بین شیءهایی از نوع OrderedDict به ترتیب اعضای آن‌ها هم بستگی دارد و به صورت list(od1.items())==list(od2.items()) پیاده سازی شده است. مقایسه برابری بین شیءهای OrderedDict و شیءهای قابل نگاشت دیگر به ترتیب اعضای آن‌ها بستگی ندارد و مقایسه همانند دیکشنری‌های عادی انجام می‌شود.

• این رفتار باعث میشه که بتونیم OrderedDict ها رو هرجایی که یک دیکشنری عادی کاربرد داره، جایگزین کنیم و استفاده کنیم.

• خب، حالا چرا تغییر ترتیب روی طول مجموعه‌ای که از دیکشنری‌ها ساختیم، تاثیر گذاشت؟ جوابش همین رفتار مقایسه‌ای غیرانتقالی بین این شیءهاست. از اونجایی که set ها مجموعه‌ای از عناصر غیرتکراری و بدون نظم هستند، ترتیبی که عناصر تو این مجموعه‌ها درج میشن نباید مهم باشه. ولی در این مورد، مهم هست. بیاید کمی تجزیه و تحلیلش کنیم.

    >>> some_set = set()
    >>> some_set.add(dictionary) # این شیء‌ها از قطعه‌کدهای بالا هستند.
    >>> ordered_dict in some_set
    True
    >>> some_set.add(ordered_dict)
    >>> len(some_set)
    1
    >>> another_ordered_dict in some_set
    True
    >>> some_set.add(another_ordered_dict)
    >>> len(some_set)
    1
  
    >>> another_set = set()
    >>> another_set.add(ordered_dict)
    >>> another_ordered_dict in another_set
    False
    >>> another_set.add(another_ordered_dict)
    >>> len(another_set)
    2
    >>> dictionary in another_set
    True
    >>> another_set.add(another_ordered_dict)
    >>> len(another_set)
    2

  پس بی‌ثباتی تو این رفتار به خاطر اینه که مقدار another_ordered_dict in another_set برابر با False هست چون ordered_dict از قبل داخل another_set هست و همونطور که قبلا مشاهده کردید، مقدار ordered_dict == another_ordered_dict برابر با False هست.

def some_func():
    try:
        return 'from_try'
    finally:
        return 'from_finally'

def another_func():
    for _ in range(3):
        try:
            continue
        finally:
            print("Finally!")

def one_more_func():
    try:
        for i in range(3):
            try:
                1 / i
            except ZeroDivisionError:
                # بذارید اینجا ارور بدیم و بیرون حلقه بهش
                # رسیدگی کنیم
                raise ZeroDivisionError("A trivial divide by zero error")
            finally:
                print("Iteration", i)
                break
    except ZeroDivisionError as e:
        print("Zero division error occurred", e)

خروجی:

>>> some_func()
'from_finally'

>>> another_func()
Finally!
Finally!
Finally!

>>> 1 / 0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero

>>> one_more_func()
Iteration 0

• وقتی یک عبارت return، break یا continue داخل بخش try از یک عبارت "try...finally" اجرا میشه، بخش fianlly هم هنگام خارج شدن اجرا میشه.
• مقدار بازگشتی یک تابع از طریق آخرین عبارت return که داخل تابع اجرا میشه، مشخص میشه. از اونجایی که بخش finally همیشه اجرا میشه، عبارت return که داخل بخش finally هست آخرین عبارتیه که اجرا میشه.
• نکته اینجاست که اگه بخش داخل بخش finally یک عبارت return یا break اجرا بشه، exception موقتی که ذخیره شده، رها میشه.

some_string = "wtf"
some_dict = {}
for i, some_dict[i] in enumerate(some_string):
    i = 10

خروجی:

>>> some_dict # یک دیکشنری مرتب‌شده نمایان میشه.
{0: 'w', 1: 't', 2: 'f'}

• یک حلقه for در گرامر پایتون این طور تعریف میشه:

  for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite]

  به طوری که exprlist یک هدف برای مقداردهیه. این یعنی، معادل عبارت {exprlist} = {next_value} برای هر شیء داخل testlist اجرا می‌شود. یک مثال جالب برای نشون دادن این تعریف:

  for i in range(4):
      print(i)
      i = 10

  خروجی:

  0
  1
  2
  3

  آیا انتظار داشتید که حلقه فقط یک بار اجرا بشه؟

  💡 توضیح:

  • عبارت مقداردهی i = 10 به خاطر نحوه کار کردن حلقه‌ها، هیچوقت باعث تغییر در تکرار حلقه نمیشه. قبل از شروع هر تکرار، مقدار بعدی که توسط شیء قابل تکرار (که در اینجا range(4) است) ارائه میشه، از بسته خارج میشه و به متغیرهای لیست هدف (که در اینجا i است) مقداردهی میشه.

• تابع enumerate(some_string)، یک متغیر i (که یک شمارنده افزایشی است) و یک حرف از حروف رشته some_string رو در هر تکرار برمیگردونه. و بعدش برای کلید i (تازه مقداردهی‌شده) در دیکشنری some_dict، مقدار اون حرف رو تنظیم می‌کنه. بازشده این حلقه می‌تونه مانند مثال زیر ساده بشه:

  >>> i, some_dict[i] = (0, 'w')
  >>> i, some_dict[i] = (1, 't')
  >>> i, some_dict[i] = (2, 'f')
  >>> some_dict

1.

array = [1, 8, 15]
# یک عبارت تولیدکننده عادی
gen = (x for x in array if array.count(x) > 0)
array = [2, 8, 22]

خروجی:

>>> print(list(gen)) # پس بقیه مقدارها کجا رفتن؟
[8]

2.

array_1 = [1,2,3,4]
gen_1 = (x for x in array_1)
array_1 = [1,2,3,4,5]

array_2 = [1,2,3,4]
gen_2 = (x for x in array_2)
array_2[:] = [1,2,3,4,5]

خروجی:

>>> print(list(gen_1))
[1, 2, 3, 4]

>>> print(list(gen_2))
[1, 2, 3, 4, 5]

3.

array_3 = [1, 2, 3]
array_4 = [10, 20, 30]
gen = (i + j for i in array_3 for j in array_4)

array_3 = [4, 5, 6]
array_4 = [400, 500, 600]

خروجی:

>>> print(list(gen))
[401, 501, 601, 402, 502, 602, 403, 503, 603]

• در یک عبارت تولیدکننده، عبارت بند in در هنگام تعریف محاسبه میشه ولی عبارت شرطی در زمان اجرا محاسبه میشه.

• پس قبل از زمان اجرا، array دوباره با لیست [2, 8, 22] مقداردهی میشه و از آن‌جایی که در مقدار جدید array، بین 1، 8 و 15، فقط تعداد 8 بزرگتر از 0 است، تولیدکننده فقط مقدار 8 رو برمیگردونه

• تفاوت در مقدار gen_1 و gen_2 در بخش دوم به خاطر نحوه مقداردهی دوباره array_1 و array_2 است.

• در مورد اول، متغیر array_1 به شیء جدید [1,2,3,4,5] وصله و از اون جایی که عبارت بند in در هنگام تعریف محاسبه میشه، array_1 داخل تولیدکننده هنوز به شیء قدیمی [1,2,3,4] (که هنوز حذف نشده)

• در مورد دوم، مقداردهی برشی به array_2 باعث به‌روز شدن شیء قدیمی این متغیر از [1,2,3,4] به [1,2,3,4,5] میشه و هر دو متغیر gen_2 و array_2 به یک شیء اشاره میکنند که حالا به‌روز شده.

• خیلی‌خب، حالا طبق منطقی که تا الان گفتیم، نباید مقدار list(gen) در قطعه‌کد سوم، [11, 21, 31, 12, 22, 32, 13, 23, 33] باشه؟ (چون array_3 و array_4 قراره درست مثل array_1 رفتار کنن). دلیل این که چرا (فقط) مقادیر array_4 به‌روز شدن، توی PEP-289 توضیح داده شده.

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

>>> 'something' is not None
True
>>> 'something' is (not None)
False

• عملگر is not یک عملگر باینری واحده و رفتارش متفاوت تر از استفاده is و not به صورت جداگانه‌ست.
• عملگر is not مقدار False رو برمیگردونه اگر متغیرها در هردو سمت این عملگر به شیء یکسانی اشاره کنند و درغیر این صورت، مقدار True برمیگردونه
• در مثال بالا، عبارت (not None) برابره با مقدار True از اونجایی که مقدار None در زمینه boolean به False تبدیل میشه. پس کل عبارت معادل عبارت 'something' is True میشه.

# بیاید یک سطر تشکیل بدیم

row = [""] * 3 #row i['', '', '']

# حالا بیاید تخته بازی رو ایجاد کنیم

board = [row] * 3

خروجی:

>>> board
[['', '', ''], ['', '', ''], ['', '', '']]
>>> board[0]
['', '', '']
>>> board[0][0]
''
>>> board[0][0] = "X"
>>> board
[['X', '', ''], ['X', '', ''], ['X', '', '']]

ما که سه‌تا "X" نذاشتیم. گذاشتیم مگه؟

وقتی متغیر row رو تشکیل میدیم، تصویر زیر نشون میده که چه اتفاقی در حافظه دستگاه میافته.

و وقتی متغیر board رو با ضرب کردن متغیر row تشکیل میدیم، تصویر زیر به صورت کلی نشون میده که چه اتفاقی در حافظه میافته (هر کدوم از عناصر board[0]، board[1] و board[2] در حافظه به لیست یکسانی به نشانی row اشاره میکنند).

ما می‌تونیم با استفاده نکردن از متغیر row برای تولید متغیر board از این سناریو پرهیز کنیم. (در این موضوع پرسیده شده).

>>> board = [['']*3 for _ in range(3)]
>>> board[0][0] = "X"
>>> board
[['X', '', ''], ['', '', ''], ['', '', '']]

مثال اول:

funcs = []
results = []
for x in range(7):
    def some_func():
        return x
    funcs.append(some_func)
    results.append(some_func())  # به فراخوانی تابع دقت کنید.

funcs_results = [func() for func in funcs]

خروجی:

>>> results
[0, 1, 2, 3, 4, 5, 6]
>>> funcs_results
[6, 6, 6, 6, 6, 6, 6]

مقدار x در هر تکرار حلقه قبل از اضافه کردن some_func به لیست funcs متفاوت بود، ولی همه توابع در خارج از حلقه مقدار 6 رو برمیگردونند.

مثال دوم:

>>> powers_of_x = [lambda x: x**i for i in range(10)]
>>> [f(2) for f in powers_of_x]
[512, 512, 512, 512, 512, 512, 512, 512, 512, 512]

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

>>> import inspect
>>> inspect.getclosurevars(funcs[0])
ClosureVars(nonlocals={}, globals={'x': 6}, builtins={}, unbound=set())

از اونجایی که x یک متغیر سراسریه (گلوبال)، ما می‌تونیم مقداری که توابع داخل funcs دنبالشون می‌گردند و برمیگردونند رو با به‌روز کردن x تغییر بدیم:

>>> x = 42
>>> [func() for func in funcs]
[42, 42, 42, 42, 42, 42, 42]

• برای رسیدن به رفتار موردنظر شما می‌تونید متغیر حلقه رو به عنوان یک متغیر اسم‌دار به تابع بدید. چرا در این صورت کار می‌کنه؟ چون اینجوری یک متغیر در دامنه خود تابع تعریف میشه. تابع دیگه دنبال مقدار x در دامنه اطراف (سراسری) نمی‌گرده ولی یک متغیر محلی برای ذخیره کردن مقدار x در اون لحظه می‌سازه.

funcs = []
for x in range(7):
    def some_func(x=x):
        return x
    funcs.append(some_func)

خروجی:

>>> funcs_results = [func() for func in funcs]
>>> funcs_results
[0, 1, 2, 3, 4, 5, 6]

دیگه از متغیر x در دامنه سراسری استفاده نمی‌کنه:

>>> inspect.getclosurevars(funcs[0])
ClosureVars(nonlocals={}, globals={}, builtins={}, unbound=set())

1.

>>> isinstance(3, int)
True
>>> isinstance(type, object)
True
>>> isinstance(object, type)
True

پس کدوم کلاس پایه "نهایی" هست؟ راستی سردرگمی بیشتری هم تو راهه.

2.

>>> class A: pass
>>> isinstance(A, A)
False
>>> isinstance(type, type)
True
>>> isinstance(object, object)
True

3.

>>> issubclass(int, object)
True
>>> issubclass(type, object)
True
>>> issubclass(object, type)
False

• در پایتون، type یک متاکلاس است.
• در پایتون همه چیز یک object است، که کلاس‌ها و همچنین نمونه‌هاشون (یا همان instance های کلاس‌ها) هم شامل این موضوع میشن.
• کلاس type یک متاکلاسه برای کلاس object و همه کلاس‌ها (همچنین کلاس type) به صورت مستقیم یا غیرمستقیم از کلاس object ارث بری کرده است.
• هیچ کلاس پایه واقعی بین کلاس‌های object و type وجود نداره. سردرگمی که در قطعه‌کدهای بالا به وجود اومده، به خاطر اینه که ما به این روابط (یعنی issubclass و isinstance) از دیدگاه کلاس‌های پایتون فکر می‌کنیم. رابطه بین object و type رو در پایتون خالص نمیشه بازتولید کرد. برای اینکه دقیق‌تر باشیم، رابطه‌های زیر در پایتون خالص نمی‌تونند بازتولید بشن.
  • کلاس A یک نمونه از کلاس B، و کلاس B یک نمونه از کلاس A باشه.
  • کلاس A یک نمونه از خودش باشه.
• این روابط بین object و type (که هردو نمونه یکدیگه و همچنین خودشون باشند) به خاطر "تقلب" در مرحله پیاده‌سازی، وجود دارند.

خروجی:

>>> from collections.abc import Hashable
>>> issubclass(list, object)
True
>>> issubclass(object, Hashable)
True
>>> issubclass(list, Hashable)
False

ما انتظار داشتیم که روابط بین زیرکلاس‌ها، انتقالی باشند، درسته؟ (یعنی اگه A زیرکلاس B باشه و B هم زیرکلاس C باشه، کلس A باید زیرکلاس C باشه)

• روابط بین زیرکلاس‌ها در پایتون لزوما انتقالی نیستند. همه مجازند که تابع __subclasscheck__ دلخواه خودشون رو در یک متاکلاس تعریف کنند.
• وقتی عبارت issubclass(cls, Hashable) اجرا میشه، برنامه دنبال یک تابع "غیر نادرست" (یا non-Falsy) در cls یا هرچیزی که ازش ارث‌بری می‌کنه، می‌گرده.
• از اونجایی که object قابل هش شدنه، ولی list این‌طور نیست، رابطه انتقالی شکسته میشه.
• توضیحات با جزئیات بیشتر اینجا پیدا میشه.

مثال اول

class SomeClass:
    def method(self):
        pass

    @classmethod
    def classm(cls):
        pass

    @staticmethod
    def staticm():
        pass

خروجی:

>>> print(SomeClass.method is SomeClass.method)
True
>>> print(SomeClass.classm is SomeClass.classm)
False
>>> print(SomeClass.classm == SomeClass.classm)
True
>>> print(SomeClass.staticm is SomeClass.staticm)
True

با دوبار دسترسی به classm، یک شیء برابر دریافت می‌کنیم، اما همان شیء نیست؟ بیایید ببینیم چه اتفاقی برای نمونه‌های SomeClass می‌افتد:

مثال دوم

o1 = SomeClass()
o2 = SomeClass()

خروجی:

>>> print(o1.method == o2.method)
False
>>> print(o1.method == o1.method)
True
>>> print(o1.method is o1.method)
False
>>> print(o1.classm is o1.classm)
False
>>> print(o1.classm == o1.classm == o2.classm == SomeClass.classm)
True
>>> print(o1.staticm is o1.staticm is o2.staticm is SomeClass.staticm)
True

دسترسی به classm یا method دو بار، اشیایی برابر اما نه یکسان را برای همان نمونه از SomeClass ایجاد می‌کند.

• تابع‌ها وصاف هستند. هر زمان که تابعی به عنوان یک ویژگی فراخوانی شود، وصف فعال می‌شود و یک شیء متد ایجاد می‌کند که تابع را به شیء صاحب آن ویژگی "متصل" می‌کند. اگر این متد فراخوانی شود، تابع را با ارسال ضمنی شیء متصل‌شده به عنوان اولین آرگومان صدا می‌زند (به این ترتیب است که self را به عنوان اولین آرگومان دریافت می‌کنیم، با وجود اینکه آن را به‌طور صریح ارسال نکرده‌ایم).

>>> o1.method
<bound method SomeClass.method of <__main__.SomeClass object at ...>>

• دسترسی به ویژگی چندین بار، هر بار یک شیء متد جدید ایجاد می‌کند! بنابراین عبارت o1.method is o1.method هرگز درست (truthy) نیست. با این حال، دسترسی به تابع‌ها به عنوان ویژگی‌های کلاس (و نه نمونه) متد ایجاد نمی‌کند؛ بنابراین عبارت SomeClass.method is SomeClass.method درست است.

>>> SomeClass.method
<function SomeClass.method at ...>

• classmethod توابع را به متدهای کلاس تبدیل می‌کند. متدهای کلاس وصاف‌هایی هستند که هنگام دسترسی، یک شیء متد ایجاد می‌کنند که به کلاس (نوع) شیء متصل می‌شود، نه خود شیء.

>>> o1.classm
<bound method SomeClass.classm of <class '__main__.SomeClass'>>

• برخلاف توابع، classmethod‌ها هنگام دسترسی به عنوان ویژگی‌های کلاس نیز یک شیء متد ایجاد می‌کنند (که در این حالت به خود کلاس متصل می‌شوند، نه نوع آن). بنابراین عبارت SomeClass.classm is SomeClass.classm نادرست (falsy) است.

>>> SomeClass.classm
<bound method SomeClass.classm of <class '__main__.SomeClass'>>

• یک شیء متد زمانی برابر در نظر گرفته می‌شود که هم تابع‌ها برابر باشند و هم شیءهای متصل‌شده یکسان باشند. بنابراین عبارت o1.method == o1.method درست (truthy) است، هرچند که آن‌ها در حافظه شیء یکسانی نیستند.
• staticmethod توابع را به یک وصف "بدون عملیات" (no-op) تبدیل می‌کند که تابع را به همان صورت بازمی‌گرداند. هیچ شیء متدی ایجاد نمی‌شود، بنابراین مقایسه با is نیز درست (truthy) است.

>>> o1.staticm
<function SomeClass.staticm at ...>
>>> SomeClass.staticm
<function SomeClass.staticm at ...>

• ایجاد شیءهای "متد" جدید در هر بار فراخوانی متدهای نمونه و نیاز به اصلاح آرگومان‌ها برای درج self، عملکرد را به شدت تحت تأثیر قرار می‌داد. CPython 3.7 این مشکل را حل کرد با معرفی opcodeهای جدیدی که فراخوانی متدها را بدون ایجاد شیء متد موقتی مدیریت می‌کنند. این به شرطی است که تابع دسترسی‌یافته واقعاً فراخوانی شود، بنابراین قطعه‌کدهای اینجا تحت تأثیر قرار نمی‌گیرند و همچنان متد ایجاد می‌کنند :)

>>> all([True, True, True])
True
>>> all([True, True, False])
False

>>> all([])
True
>>> all([[]])
False
>>> all([[[]]])
True

چرا این تغییر درست-نادرسته؟

• پیاده‌سازی تابع all معادل است با

• def all(iterable):
      for element in iterable:
          if not element:
              return False
      return True

• all([]) مقدار True را برمی‌گرداند چون iterable خالی است.

• all([[]]) مقدار False را برمی‌گرداند چون آرایه‌ی داده‌شده یک عنصر دارد، یعنی []، و در پایتون، لیست خالی مقدار falsy دارد.

• all([[[]]]) و نسخه‌های بازگشتی بالاتر همیشه True هستند. دلیلش این است که عنصر واحد آرایه‌ی داده‌شده ([[...]]) دیگر خالی نیست، و لیست‌هایی که دارای مقدار باشند، truthy در نظر گرفته می‌شوند.

خروجی (< 3.6):

>>> def f(x, y,):
...     print(x, y)
...
>>> def g(x=4, y=5,):
...     print(x, y)
...
>>> def h(x, **kwargs,):
  File "<stdin>", line 1
    def h(x, **kwargs,):
                     ^
SyntaxError: invalid syntax

>>> def h(*args,):
  File "<stdin>", line 1
    def h(*args,):
                ^
SyntaxError: invalid syntax

• کامای انتهایی همیشه در لیست پارامترهای رسمی یک تابع در پایتون قانونی نیست.
• در پایتون، لیست آرگومان‌ها تا حدی با کاماهای ابتدایی و تا حدی با کاماهای انتهایی تعریف می‌شود. این تضاد باعث ایجاد موقعیت‌هایی می‌شود که در آن یک کاما در وسط گیر می‌افتد و هیچ قانونی آن را نمی‌پذیرد.
• نکته: مشکل کامای انتهایی در پایتون ۳.۶ رفع شده است. توضیحات در این پست به‌طور خلاصه کاربردهای مختلف کاماهای انتهایی در پایتون را بررسی می‌کند.

خروجی:

>>> print("\"")
"

>>> print(r"\"")
\"

>>> print(r"\")
File "<stdin>", line 1
    print(r"\")
              ^
SyntaxError: EOL while scanning string literal

>>> r'\'' == "\\'"
True

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

  >>> "wt\"f"
  'wt"f'

• در یک رشته‌ی خام (raw string literal) که با پیشوند r مشخص می‌شود، بک‌اسلش‌ها خودشان به همان شکل منتقل می‌شوند، به‌همراه رفتار فرار دادن نویسه‌ی بعدی.

  >>> r'wt\"f' == 'wt\\"f'
  True
  >>> print(repr(r'wt\"f'))
  'wt\\"f'
  
  >>> print("\n")
  
  >>> print(r"\\n")
  '\\n'

• در یک رشته‌ی خام (raw string) که با پیشوند r مشخص می‌شود، بک‌اسلش‌ها خودشان به همان صورت منتقل می‌شوند، همراه با رفتاری که کاراکتر بعدی را فرار می‌دهد (escape می‌کند).

x = True
y = False

خروجی:

>>> not x == y
True
>>> x == not y
  File "<input>", line 1
    x == not y
           ^
SyntaxError: invalid syntax

• تقدم عملگرها بر نحوه‌ی ارزیابی یک عبارت تأثیر می‌گذارد، و در پایتون، عملگر == تقدم بالاتری نسبت به عملگر not دارد.
• بنابراین عبارت not x == y معادل not (x == y) است که خودش معادل not (True == False) بوده و در نهایت به True ارزیابی می‌شود.
• اما x == not y یک SyntaxError ایجاد می‌کند، چون می‌توان آن را به صورت (x == not) y تفسیر کرد، نه آن‌طور که در نگاه اول انتظار می‌رود یعنی x == (not y).
• تجزیه‌گر (parser) انتظار دارد که توکن not بخشی از عملگر not in باشد (چون هر دو عملگر == و not in تقدم یکسانی دارند)، اما پس از اینکه توکن in بعد از not پیدا نمی‌شود، خطای SyntaxError صادر می‌شود.

خروجی:

>>> print('wtfpython''')
wtfpython
>>> print("wtfpython""")
wtfpython
>>> # کد های زیر خطای سینکس دارند.
>>> # print('''wtfpython')
>>> # print("""wtfpython")
  File "<input>", line 3
    print("""wtfpython")
                        ^
SyntaxError: EOF while scanning triple-quoted string literal

• پایتون از الحاق ضمنی رشته‌های متنی پشتیبانی می‌کند. برای مثال،

  >>> print("wtf" "python")
  wtfpython
  >>> print("wtf" "") # or "wtf"""
  wtf

• ''' و """ نیز جداکننده‌های رشته‌ای در پایتون هستند که باعث ایجاد SyntaxError می‌شوند، چون مفسر پایتون هنگام اسکن رشته‌ای که با سه‌نقل‌قول آغاز شده، انتظار یک سه‌نقل‌قول پایانی به‌عنوان جداکننده را دارد.

1.

‫ یک مثال ساده برای شمردن تعداد مقادیر بولی # اعداد صحیح در یک iterable با انواع داده‌ی مخلوط.

mixed_list = [False, 1.0, "some_string", 3, True, [], False]
integers_found_so_far = 0
booleans_found_so_far = 0

for item in mixed_list:
    if isinstance(item, int):
        integers_found_so_far += 1
    elif isinstance(item, bool):
        booleans_found_so_far += 1

خروجی:

>>> integers_found_so_far
4
>>> booleans_found_so_far
0

2.

>>> some_bool = True
>>> "wtf" * some_bool
'wtf'
>>> some_bool = False
>>> "wtf" * some_bool
''

3.

def tell_truth():
    True = False
    if True == False:
        print("I have lost faith in truth!")

خروجی (< 3.x):

>>> tell_truth()
I have lost faith in truth!

• در پایتون، bool زیرکلاسی از int است

  >>> issubclass(bool, int)
  True
  >>> issubclass(int, bool)
  False

• و بنابراین، True و False نمونه‌هایی از int هستند

  >>> isinstance(True, int)
  True
  >>> isinstance(False, int)
  True

• مقدار عددی True برابر با 1 و مقدار عددی False برابر با 0 است.

  >>> int(True)
  1
  >>> int(False)
  0

• این پاسخ در StackOverflow را ببینید: answer برای توضیح منطقی پشت این موضوع.

• در ابتدا، پایتون نوع bool نداشت (کاربران از 0 برای false و مقادیر غیر صفر مثل 1 برای true استفاده می‌کردند). True، False و نوع bool در نسخه‌های 2.x اضافه شدند، اما برای سازگاری با نسخه‌های قبلی، True و False نمی‌توانستند به عنوان ثابت تعریف شوند. آن‌ها فقط متغیرهای توکار (built-in) بودند و امکان تغییر مقدارشان وجود داشت.

• پایتون ۳ با نسخه‌های قبلی ناسازگار بود، این مشکل سرانجام رفع شد، و بنابراین قطعه‌کد آخر در نسخه‌های Python 3.x کار نخواهد کرد!

1.

class A:
    x = 1

class B(A):
    pass

class C(A):
    pass

Output:

>>> A.x, B.x, C.x
(1, 1, 1)
>>> B.x = 2
>>> A.x, B.x, C.x
(1, 2, 1)
>>> A.x = 3
>>> A.x, B.x, C.x # C.x تغییر کرد, اما B.x تغییر نکرد.
(3, 2, 3)
>>> a = A()
>>> a.x, A.x
(3, 3)
>>> a.x += 1
>>> a.x, A.x
(4, 3)

2.

class SomeClass:
    some_var = 15
    some_list = [5]
    another_list = [5]
    def __init__(self, x):
        self.some_var = x + 1
        self.some_list = self.some_list + [x]
        self.another_list += [x]

خروجی:

>>> some_obj = SomeClass(420)
>>> some_obj.some_list
[5, 420]
>>> some_obj.another_list
[5, 420]
>>> another_obj = SomeClass(111)
>>> another_obj.some_list
[5, 111]
>>> another_obj.another_list
[5, 420, 111]
>>> another_obj.another_list is SomeClass.another_list
True
>>> another_obj.another_list is some_obj.another_list
True

• متغیرهای کلاس و متغیرهای نمونه‌های کلاس درونی به‌صورت دیکشنری‌هایی از شیء کلاس مدیریت می‌شوند. اگر نام متغیری در دیکشنری کلاس جاری پیدا نشود، کلاس‌های والد برای آن جست‌وجو می‌شوند.
• عملگر += شیء قابل‌تغییر (mutable) را به‌صورت درجا (in-place) تغییر می‌دهد بدون اینکه شیء جدیدی ایجاد کند. بنابراین، تغییر ویژگی یک نمونه بر نمونه‌های دیگر و همچنین ویژگی کلاس تأثیر می‌گذارد.

some_iterable = ('a', 'b')

def some_func(val):
    return "something"

خروجی (<= 3.7.x):

>>> [x for x in some_iterable]
['a', 'b']
>>> [(yield x) for x in some_iterable]
<generator object <listcomp> at 0x7f70b0a4ad58>
>>> list([(yield x) for x in some_iterable])
['a', 'b']
>>> list((yield x) for x in some_iterable)
['a', None, 'b', None]
>>> list(some_func((yield x)) for x in some_iterable)
['a', 'something', 'b', 'something']

• این یک باگ در نحوه‌ی مدیریت yield توسط CPython در ژنراتورها و درک لیستی (comprehensions) است.
• منبع و توضیحات را می‌توانید اینجا ببینید: https://stackoverflow.com/questions/32139885/yield-in-list-comprehensions-and-generator-expressions
• گزارش باگ مرتبط: https://bugs.python.org/issue10544
• از نسخه‌ی ۳.۸ به بعد، پایتون دیگر اجازه‌ی استفاده از yield در داخل درک لیستی را نمی‌دهد و خطای SyntaxError ایجاد خواهد کرد.

1.

def some_func(x):
    if x == 3:
        return ["wtf"]
    else:
        yield from range(x)

خروجی (> 3.3):

>>> list(some_func(3))
[]

چی شد که "wtf" ناپدید شد؟ آیا به خاطر اثر خاصی از yield from است؟ بیایید این موضوع را بررسی کنیم،

2.

def some_func(x):
    if x == 3:
        return ["wtf"]
    else:
        for i in range(x):
          yield i

خروجی:

>>> list(some_func(3))
[]

همان نتیجه، این یکی هم کار نکرد.

• از پایتون نسخه ۳.۳ به بعد، امکان استفاده از عبارت return همراه با مقدار در داخل ژنراتورها فراهم شد (نگاه کنید به PEP380). مستندات رسمی می‌گویند:

دلیل: "... return expr در یک ژنراتور باعث می‌شود که هنگام خروج از ژنراتور، StopIteration(expr) ایجاد شود."

• در حالت some_func(3)، استثنای StopIteration در ابتدای اجرا به دلیل وجود دستور return رخ می‌دهد. این استثنا به‌طور خودکار درون پوشش list(...) و حلقه for گرفته می‌شود. بنابراین، دو قطعه‌کد بالا منجر به یک لیست خالی می‌شوند.

• برای اینکه مقدار ["wtf"] را از ژنراتور some_func بگیریم، باید استثنای StopIteration را خودمان مدیریت کنیم،

  try:
      next(some_func(3))
  except StopIteration as e:
      some_string = e.value

  >>> some_string
  ["wtf"]

1.

a = float('inf')
b = float('nan')
c = float('-iNf')  # این رشته‌ها نسبت به حروف بزرگ و کوچک حساس نیستند
d = float('nan')

خروجی:

>>> a
inf
>>> b
nan
>>> c
-inf
>>> float('some_other_string')
ValueError: could not convert string to float: some_other_string
>>> a == -c # inf==inf
True
>>> None == None # None == None
True
>>> b == d # اما nan!=nan
False
>>> 50 / a
0.0
>>> a / a
nan
>>> 23 + b
nan

2.

>>> x = float('nan')
>>> y = x / x
>>> y is y # برابری هویتی برقرار است
True
>>> y == y #برابری در مورد y برقرار نیست
False
>>> [y] == [y] # اما برابری برای لیستی که شامل y است برقرار می‌شود
True

• در اینجا، 'inf' و 'nan' رشته‌هایی خاص هستند (نسبت به حروف بزرگ و کوچک حساس نیستند) که وقتی به‌طور صریح به نوع float تبدیل شوند، به ترتیب برای نمایش "بی‌نهایت" ریاضی و "عدد نیست" استفاده می‌شوند.

• از آنجا که طبق استاندارد IEEE، NaN != NaN، پایبندی به این قانون فرض بازتاب‌پذیری (reflexivity) یک عنصر در مجموعه‌ها را در پایتون نقض می‌کند؛ یعنی اگر x عضوی از مجموعه‌ای مثل list باشد، پیاده‌سازی‌هایی مانند مقایسه، بر اساس این فرض هستند که x == x. به دلیل همین فرض، ابتدا هویت (identity) دو عنصر مقایسه می‌شود (چون سریع‌تر است) و فقط زمانی مقادیر مقایسه می‌شوند که هویت‌ها متفاوت باشند. قطعه‌کد زیر موضوع را روشن‌تر می‌کند،

  >>> x = float('nan')
  >>> x == x, [x] == [x]
  (False, True)
  >>> y = float('nan')
  >>> y == y, [y] == [y]
  (False, True)
  >>> x == y, [x] == [y]
  (False, False)

  از آنجا که هویت‌های x و y متفاوت هستند، مقادیر آن‌ها در نظر گرفته می‌شوند که آن‌ها نیز متفاوت‌اند؛ بنابراین مقایسه این بار False را برمی‌گرداند.

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

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

some_tuple = ("A", "tuple", "with", "values")
another_tuple = ([1, 2], [3, 4], [5, 6])

خروجی:

>>> some_tuple[2] = "change this"
TypeError: 'tuple' object does not support item assignment
>>> another_tuple[2].append(1000) #This throws no error
>>> another_tuple
([1, 2], [3, 4], [5, 6, 1000])
>>> another_tuple[2] += [99, 999]
TypeError: 'tuple' object does not support item assignment
>>> another_tuple
([1, 2], [3, 4], [5, 6, 1000, 99, 999])

اما من فکر می‌کردم تاپل‌ها تغییرناپذیر هستند...

• نقل‌قول از https://docs.python.org/3/reference/datamodel.html

  دنباله‌های تغییرناپذیر

  شیئی از نوع دنباله‌ی تغییرناپذیر، پس از ایجاد دیگر قابل تغییر نیست. (اگر شیء شامل ارجاع‌هایی به اشیای دیگر باشد، این اشیای دیگر ممکن است قابل تغییر باشند و تغییر کنند؛ اما مجموعه‌ی اشیایی که مستقیماً توسط یک شیء تغییرناپذیر ارجاع داده می‌شوند، نمی‌تواند تغییر کند.)
  

• عملگر += لیست را به‌صورت درجا (in-place) تغییر می‌دهد. تخصیص به یک عضو کار نمی‌کند، اما زمانی که استثنا ایجاد می‌شود، عضو موردنظر پیش از آن به‌صورت درجا تغییر کرده است.

• همچنین توضیحی در پرسش‌های متداول رسمی پایتون وجود دارد.

e = 7
try:
    raise Exception()
except Exception as e:
    pass

Output (Python 2.x):

>>> print(e)
# چیزی چاپ نمی شود.

Output (Python 3.x):

>>> print(e)
NameError: name 'e' is not defined

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

هنگامی که یک استثنا (Exception) با استفاده از کلمه‌ی کلیدی as به متغیری تخصیص داده شود، این متغیر در انتهای بلاکِ except پاک می‌شود. این رفتار مشابه کد زیر است:

except E as N:
    foo

به این شکل ترجمه شده باشد:

except E as N:
    try:
        foo
    finally:
        del N

این بدان معناست که استثنا باید به نام دیگری انتساب داده شود تا بتوان پس از پایان بند except به آن ارجاع داد. استثناها پاک می‌شوند چون با داشتن «ردیابی» (traceback) ضمیمه‌شده، یک چرخه‌ی مرجع (reference cycle) با قاب پشته (stack frame) تشکیل می‌دهند که باعث می‌شود تمام متغیرهای محلی (locals) در آن قاب تا زمان پاکسازی حافظه (garbage collection) باقی بمانند.

• در پایتون، بندها (clauses) حوزه‌ی مستقل ندارند. در مثال بالا، همه‌چیز در یک حوزه‌ی واحد قرار دارد، و متغیر e در اثر اجرای بند except حذف می‌شود. این موضوع در مورد توابع صادق نیست، زیرا توابع حوزه‌های داخلی جداگانه‌ای دارند. مثال زیر این نکته را نشان می‌دهد:

  def f(x):
      del(x)
      print(x)
  
  x = 5
  y = [5, 4, 3]

  خروجی:

  >>> f(x)
  UnboundLocalError: local variable 'x' referenced before assignment
  >>> f(y)
  UnboundLocalError: local variable 'x' referenced before assignment
  >>> x
  5
  >>> y
  [5, 4, 3]

• در پایتون نسخه‌ی ۲.x، نام متغیر e به یک نمونه از Exception() انتساب داده می‌شود، بنابراین وقتی سعی کنید آن را چاپ کنید، چیزی نمایش داده نمی‌شود.

  خروجی (Python 2.x):

  >>> e
  Exception()
  >>> print e
  # چیزی چاپ نمی شود.

class SomeClass(str):
    pass

some_dict = {'s': 42}

خروجی:

>>> type(list(some_dict.keys())[0])
str
>>> s = SomeClass('s')
>>> some_dict[s] = 40
>>> some_dict # دو عدد کلید-مقدار توقع می رود.
{'s': 40}
>>> type(list(some_dict.keys())[0])
str

• هر دو شیء s و رشته‌ی "s" به دلیل ارث‌بری SomeClass از متد __hash__ کلاس str، هش یکسانی دارند.

• عبارت SomeClass("s") == "s" به دلیل ارث‌بری SomeClass از متد __eq__ کلاس str برابر با True ارزیابی می‌شود.

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

• برای رسیدن به رفتار دلخواه، می‌توانیم متد __eq__ را در کلاس SomeClass بازتعریف کنیم.

  class SomeClass(str):
    def __eq__(self, other):
        return (
            type(self) is SomeClass
            and type(other) is SomeClass
            and super().__eq__(other)
        )
  
    # هنگامی که متد __eq__ را به‌طور دلخواه تعریف می‌کنیم، پایتون دیگر متد __hash__ را به صورت خودکار به ارث نمی‌برد،
    # بنابراین باید متد __hash__ را نیز مجدداً تعریف کنیم.
    __hash__ = str.__hash__
  
  some_dict = {'s':42}

  خروجی:

  >>> s = SomeClass('s')
  >>> some_dict[s] = 40
  >>> some_dict
  {'s': 40, 's': 42}
  >>> keys = list(some_dict.keys())
  >>> type(keys[0]), type(keys[1])
  (__main__.SomeClass, str)

a, b = a[b] = {}, 5

خروجی:

>>> a
{5: ({...}, 5)}

• طبق مرجع زبان پایتون، دستورات انتساب فرم زیر را دارند:

  (target_list "=")+ (expression_list | yield_expression)
  

  و

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

• علامت + در (target_list "=")+ به این معناست که می‌توان یک یا چند هدف انتساب داشت. در این حالت، اهداف انتساب ما a, b و a[b] هستند (توجه کنید که عبارت ارزیابی‌شده دقیقاً یکی است، که در اینجا {} و 5 است).

• پس از ارزیابی عبارت، نتیجه از چپ به راست به اهداف انتساب داده می‌شود. در این مثال ابتدا تاپل ({}, 5) به a, b باز می‌شود، بنابراین a = {} و b = 5 خواهیم داشت.

• حالا a یک شیء قابل تغییر (mutable) است ({}).

• هدف انتساب بعدی a[b] است (شاید انتظار داشته باشید که اینجا خطا بگیریم زیرا پیش از این هیچ مقداری برای a و b مشخص نشده است؛ اما به یاد داشته باشید که در گام قبل به a مقدار {} و به b مقدار 5 دادیم).

• اکنون، کلید 5 در دیکشنری به تاپل ({}, 5) مقداردهی می‌شود و یک مرجع دوری (Circular Reference) ایجاد می‌کند (علامت {...} در خروجی به همان شیئی اشاره دارد که قبلاً توسط a به آن ارجاع داده شده است). یک مثال ساده‌تر از مرجع دوری می‌تواند به این صورت باشد:

  >>> some_list = some_list[0] = [0]
  >>> some_list
  [[...]]
  >>> some_list[0]
  [[...]]
  >>> some_list is some_list[0]
  True
  >>> some_list[0][0][0][0][0][0] == some_list
  True

  در مثال ما نیز شرایط مشابه است (a[b][0] همان شیئی است که a به آن اشاره دارد).

• بنابراین برای جمع‌بندی، می‌توانید مثال بالا را به این صورت ساده کنید:

  a, b = {}, 5
  a[b] = a, b

  و مرجع دوری به این دلیل قابل توجیه است که a[b][0] همان شیئی است که a به آن اشاره دارد.

  >>> a[b][0] is a
  True

>>> # Python 3.10.6
>>> int("2" * 5432)

>>> # Python 3.10.8
>>> int("2" * 5432)

خروجی:

>>> # Python 3.10.6
222222222222222222222222222222222222222222222222222222222222222...

>>> # Python 3.10.8
Traceback (most recent call last):
   ...
ValueError: Exceeds the limit (4300) for integer string conversion:
   value has 5432 digits; use sys.set_int_max_str_digits()
   to increase the limit.

فراخوانی تابع int() در نسخه‌ی Python 3.10.6 به‌خوبی کار می‌کند اما در نسخه‌ی Python 3.10.8 منجر به خطای ValueError می‌شود. توجه کنید که پایتون همچنان قادر به کار با اعداد صحیح بزرگ است. این خطا تنها هنگام تبدیل اعداد صحیح به رشته یا برعکس رخ می‌دهد.

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

• استفاده از فلگ خط فرمان -X int_max_str_digits
• تابع set_int_max_str_digits() از ماژول sys
• متغیر محیطی PYTHONINTMAXSTRDIGITS

برای جزئیات بیشتر درباره‌ی تغییر مقدار پیش‌فرض این حد مجاز، مستندات رسمی پایتون را مشاهده کنید.

x = {0: None}

for i in x:
    del x[i]
    x[i+1] = None
    print(i)

خروجی (پایتون 2.7تا پایتون 3.5):

0
1
2
3
4
5
6
7

بله، دقیقاً هشت مرتبه اجرا می‌شود و سپس متوقف می‌شود.

• پیمایش روی یک دیکشنری در حالی که همزمان آن را ویرایش می‌کنید پشتیبانی نمی‌شود.
• هشت بار اجرا می‌شود چون در آن لحظه دیکشنری برای نگهداری کلیدهای بیشتر تغییر اندازه می‌دهد (ما هشت ورودی حذف داریم، بنابراین تغییر اندازه لازم است). این در واقع یک جزئیات پیاده‌سازی است.
• اینکه کلیدهای حذف‌شده چگونه مدیریت می‌شوند و چه زمانی تغییر اندازه اتفاق می‌افتد ممکن است در پیاده‌سازی‌های مختلف پایتون متفاوت باشد.
• بنابراین در نسخه‌های دیگر پایتون (به جز Python 2.7 - Python 3.5)، تعداد ممکن است متفاوت از ۸ باشد (اما هر چه که باشد، در هر بار اجرا یکسان خواهد بود). می‌توانید برخی مباحث پیرامون این موضوع را اینجا یا در این رشته‌ی StackOverflow مشاهده کنید.
• از نسخه‌ی Python 3.7.6 به بعد، در صورت تلاش برای انجام این کار، خطای RuntimeError: dictionary keys changed during iteration را دریافت خواهید کرد.

class SomeClass:
    def __del__(self):
        print("Deleted!")

خروجی: 1.

>>> x = SomeClass()
>>> y = x
>>> del x # باید این عبارت را چاپ کند "Deleted!"
>>> del y
Deleted!

«خُب، بالاخره حذف شد.» احتمالاً حدس زده‌اید چه چیزی جلوی فراخوانی __del__ را در اولین تلاشی که برای حذف x داشتیم، گرفته بود. بیایید مثال را پیچیده‌تر کنیم.

2.

>>> x = SomeClass()
>>> y = x
>>> del x
>>> y # بررسی وجود y
<__main__.SomeClass instance at 0x7f98a1a67fc8>
>>> del y # مثل قبل، باید این عبارت را چاپ کند "Deleted!"
>>> globals() # اوه، چاپ نکرد. بیایید مقادیر گلوبال را بررسی کنیم.
Deleted!
{'__builtins__': <module '__builtin__' (built-in)>, 'SomeClass': <class __main__.SomeClass at 0x7f98a1a5f668>, '__package__': None, '__name__': '__main__', '__doc__': None}

«باشه، حالا حذف شد» 😕

• عبارت del x مستقیماً باعث فراخوانی x.__del__() نمی‌شود.
• وقتی به دستور del x می‌رسیم، پایتون نام x را از حوزه‌ی فعلی حذف کرده و شمارنده‌ی مراجع شیٔ‌ای که x به آن اشاره می‌کرد را یک واحد کاهش می‌دهد. فقط وقتی شمارنده‌ی مراجع شیٔ به صفر برسد، تابع __del__() فراخوانی می‌شود.
• در خروجی دوم، متد __del__() فراخوانی نشد چون دستور قبلی (>>> y) در مفسر تعاملی یک ارجاع دیگر به شیٔ ایجاد کرده بود (به صورت خاص، متغیر جادویی _ به مقدار آخرین عبارت غیر None در REPL اشاره می‌کند). بنابراین مانع از رسیدن شمارنده‌ی مراجع به صفر در هنگام اجرای del y شد.
• فراخوانی globals (یا هر چیزی که نتیجه‌اش None نباشد) باعث می‌شود که _ به نتیجه‌ی جدید اشاره کند و ارجاع قبلی از بین برود. حالا شمارنده‌ی مراجع به صفر می‌رسد و عبارت «Deleted!» (حذف شد!) نمایش داده می‌شود.

1.

a = 1
def some_func():
    return a

def another_func():
    a += 1
    return a

2.

def some_closure_func():
    a = 1
    def some_inner_func():
        return a
    return some_inner_func()

def another_closure_func():
    a = 1
    def another_inner_func():
        a += 1
        return a
    return another_inner_func()

خروجی:

>>> some_func()
1
>>> another_func()
UnboundLocalError: local variable 'a' referenced before assignment

>>> some_closure_func()
1
>>> another_closure_func()
UnboundLocalError: local variable 'a' referenced before assignment

• وقتی در محدوده (Scope) یک تابع به متغیری مقداردهی می‌کنید، آن متغیر در همان حوزه محلی تعریف می‌شود. بنابراین a در تابع another_func تبدیل به متغیر محلی می‌شود، اما پیش‌تر در همان حوزه مقداردهی نشده است، و این باعث خطا می‌شود.

• برای تغییر متغیر سراسری a در تابع another_func، باید از کلیدواژه‌ی global استفاده کنیم.

  def another_func()
      global a
      a += 1
      return a

  خروجی:

  >>> another_func()
  2

• در تابع another_closure_func، متغیر a در حوزه‌ی another_inner_func محلی می‌شود ولی پیش‌تر در آن حوزه مقداردهی نشده است. به همین دلیل خطا می‌دهد.

• برای تغییر متغیر حوزه‌ی بیرونی a در another_inner_func، باید از کلیدواژه‌ی nonlocal استفاده کنیم. دستور nonlocal به مفسر می‌گوید که متغیر را در نزدیک‌ترین حوزه‌ی بیرونی (به‌جز حوزه‌ی global) جستجو کند.

  def another_func():
      a = 1
      def another_inner_func():
          nonlocal a
          a += 1
          return a
      return another_inner_func()

  خروجی:

  >>> another_func()
  2

• کلیدواژه‌های global و nonlocal به مفسر پایتون می‌گویند که متغیر جدیدی را تعریف نکند و به جای آن در حوزه‌های بیرونی (سراسری یا میانجی) آن را بیابد.

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

list_1 = [1, 2, 3, 4]
list_2 = [1, 2, 3, 4]
list_3 = [1, 2, 3, 4]
list_4 = [1, 2, 3, 4]

for idx, item in enumerate(list_1):
    del item

for idx, item in enumerate(list_2):
    list_2.remove(item)

for idx, item in enumerate(list_3[:]):
    list_3.remove(item)

for idx, item in enumerate(list_4):
    list_4.pop(idx)

خروجی:

>>> list_1
[1, 2, 3, 4]
>>> list_2
[2, 4]
>>> list_3
[]
>>> list_4
[2, 4]

می‌توانید حدس بزنید چرا خروجی [2, 4] است؟

• هیچ‌وقت ایده‌ی خوبی نیست که شیئی را که روی آن پیمایش می‌کنید تغییر دهید. روش درست این است که روی یک کپی از آن شیء پیمایش کنید؛ در این‌جا list_3[:] دقیقاً همین کار را می‌کند.

  >>> some_list = [1, 2, 3, 4]
  >>> id(some_list)
  139798789457608
  >>> id(some_list[:]) # دقت کنید که پایتون برای اسلایس کردن، یک شی جدید میسازد
  139798779601192

تفاوت بین del، remove و pop:

• اینجا، del var_name فقط اتصال var_name را از فضای نام محلی یا سراسری حذف می‌کند (به همین دلیل است که list_1 تحت تأثیر قرار نمی‌گیرد).
• متد remove اولین مقدار مطابق را حذف می‌کند، نه یک اندیس خاص را؛ اگر مقدار مورد نظر پیدا نشود، خطای ValueError ایجاد می‌شود.
• متد pop عنصری را در یک اندیس مشخص حذف کرده و آن را برمی‌گرداند؛ اگر اندیس نامعتبری مشخص شود، خطای IndexError ایجاد می‌شود.

چرا خروجی [2, 4] است؟

• پیمایش لیست به صورت اندیس به اندیس انجام می‌شود، و هنگامی که عدد 1 را از list_2 یا list_4 حذف می‌کنیم، محتوای لیست به [2, 3, 4] تغییر می‌کند. در این حالت عناصر باقی‌مانده به سمت چپ جابه‌جا شده و جایگاهشان تغییر می‌کند؛ یعنی عدد 2 در اندیس 0 و عدد 3 در اندیس 1 قرار می‌گیرد. از آنجا که در مرحله بعدی حلقه به سراغ اندیس 1 می‌رود (که اکنون مقدار آن 3 است)، عدد 2 به طور کامل نادیده گرفته می‌شود. این اتفاق مشابه برای هر عنصر یک‌درمیان در طول پیمایش لیست رخ خواهد داد.

• برای توضیح بیشتر این مثال، این تاپیک StackOverflow را ببینید.

• همچنین برای نمونه مشابهی مربوط به دیکشنری‌ها در پایتون، این تاپیک مفید StackOverflow را ببینید.

>>> numbers = list(range(7))
>>> numbers
[0, 1, 2, 3, 4, 5, 6]
>>> first_three, remaining = numbers[:3], numbers[3:]
>>> first_three, remaining
([0, 1, 2], [3, 4, 5, 6])
>>> numbers_iter = iter(numbers)
>>> list(zip(numbers_iter, first_three))
[(0, 0), (1, 1), (2, 2)]
# تاحالا که خوب بوده، حالا روی باقی مانده های زیپ رو امتحان می کنیم.
>>> list(zip(numbers_iter, remaining))
[(4, 3), (5, 4), (6, 5)]

عنصر 3 از لیست numbers چه شد؟

• بر اساس مستندات پایتون، پیاده‌سازی تقریبی تابع zip به شکل زیر است:

  def zip(*iterables):
      sentinel = object()
      iterators = [iter(it) for it in iterables]
      while iterators:
          result = []
          for it in iterators:
              elem = next(it, sentinel)
              if elem is sentinel: return
              result.append(elem)
          yield tuple(result)

• بنابراین این تابع تعداد دلخواهی از اشیای قابل پیمایش (iterable) را دریافت می‌کند، و با فراخوانی تابع next روی آن‌ها، هر یک از عناصرشان را به لیست result اضافه می‌کند. این فرایند زمانی متوقف می‌شود که اولین پیمایشگر به انتها برسد.

• نکته مهم اینجاست که هر زمان یکی از پیمایشگرها به پایان برسد، عناصر موجود در لیست result نیز دور ریخته می‌شوند. این دقیقاً همان اتفاقی است که برای عدد 3 در numbers_iter رخ داد.

• روش صحیح برای انجام عملیات بالا با استفاده از تابع zip چنین است:

  >>> numbers = list(range(7))
  >>> numbers_iter = iter(numbers)
  >>> list(zip(first_three, numbers_iter))
  [(0, 0), (1, 1), (2, 2)]
  >>> list(zip(remaining, numbers_iter))
  [(3, 3), (4, 4), (5, 5), (6, 6)]

  اولین آرگومانِ تابع zip باید پیمایشگری باشد که کمترین تعداد عنصر را دارد.

1.

for x in range(7):
    if x == 6:
        print(x, ': for x inside loop')
print(x, ': x in global')

خروجی:

6 : for x inside loop
6 : x in global

اما متغیر x هرگز خارج از محدوده (scope) حلقه for تعریف نشده بود...

2.

# این دفعه، مقدار ایکس را در ابتدا مقداردهی اولیه میکنیم.
x = -1
for x in range(7):
    if x == 6:
        print(x, ': for x inside loop')
print(x, ': x in global')

خروجی:

6 : for x inside loop
6 : x in global

3.

خروجی (Python 2.x):

>>> x = 1
>>> print([x for x in range(5)])
[0, 1, 2, 3, 4]
>>> print(x)
4

خروجی (Python 3.x):

>>> x = 1
>>> print([x for x in range(5)])
[0, 1, 2, 3, 4]
>>> print(x)
1

• در پایتون، حلقه‌های for از حوزه (scope) فعلی که در آن قرار دارند استفاده می‌کنند و متغیرهای تعریف‌شده در حلقه حتی بعد از اتمام حلقه نیز باقی می‌مانند. این قاعده حتی در مواردی که متغیر حلقه پیش‌تر در فضای نام سراسری (global namespace) تعریف شده باشد نیز صدق می‌کند؛ در چنین حالتی، متغیر موجود مجدداً به مقدار جدید متصل می‌شود.

• تفاوت‌های موجود در خروجی مفسرهای Python 2.x و Python 3.x در مثال مربوط به «لیست‌های ادراکی» (list comprehension) به دلیل تغییراتی است که در مستند «تغییرات جدید در Python 3.0» آمده است:

  «لیست‌های ادراکی دیگر فرم نحوی [... for var in item1, item2, ...] را پشتیبانی نمی‌کنند و به جای آن باید از [... for var in (item1, item2, ...)] استفاده شود. همچنین توجه داشته باشید که لیست‌های ادراکی در Python 3.x معنای متفاوتی دارند: آن‌ها از لحاظ معنایی به بیان ساده‌تر، مشابه یک عبارت تولیدکننده (generator expression) درون تابع list() هستند و در نتیجه، متغیرهای کنترل حلقه دیگر به فضای نام بیرونی نشت نمی‌کنند.»

def some_func(default_arg=[]):
    default_arg.append("some_string")
    return default_arg

خروجی:

>>> some_func()
['some_string']
>>> some_func()
['some_string', 'some_string']
>>> some_func([])
['some_string']
>>> some_func()
['some_string', 'some_string', 'some_string']

• آرگومان‌های تغییرپذیر پیش‌فرض در توابع پایتون، هر بار که تابع فراخوانی می‌شود مقداردهی نمی‌شوند؛ بلکه مقداردهی آنها تنها یک بار در زمان تعریف تابع انجام می‌شود و مقدار اختصاص‌یافته به آن‌ها به عنوان مقدار پیش‌فرض برای فراخوانی‌های بعدی استفاده خواهد شد. هنگامی که به صراحت مقدار [] را به عنوان آرگومان به some_func ارسال کردیم، مقدار پیش‌فرض برای متغیر default_arg مورد استفاده قرار نگرفت، بنابراین تابع همان‌طور که انتظار داشتیم عمل کرد.

  def some_func(default_arg=[]):
      default_arg.append("some_string")
      return default_arg

  خروجی:

  >>> some_func.__defaults__ # مقادیر پیشفرض این تابع را نمایش می دهد.
  ([],)
  >>> some_func()
  >>> some_func.__defaults__
  (['some_string'],)
  >>> some_func()
  >>> some_func.__defaults__
  (['some_string', 'some_string'],)
  >>> some_func([])
  >>> some_func.__defaults__
  (['some_string', 'some_string'],)

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

  def some_func(default_arg=None):
      if default_arg is None:
          default_arg = []
      default_arg.append("some_string")
      return default_arg

some_list = [1, 2, 3]
try:
    # این باید یک `IndexError` ایجاد کند
    print(some_list[4])
except IndexError, ValueError:
    print("Caught!")

try:
    # این باید یک `ValueError` ایجاد کند
    some_list.remove(4)
except IndexError, ValueError:
    print("Caught again!")

خروجی (Python 2.x):

Caught!

ValueError: list.remove(x): x not in list

خروجی (Python 3.x):

  File "<input>", line 3
    except IndexError, ValueError:
                     ^
SyntaxError: invalid syntax

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

  some_list = [1, 2, 3]
  try:
     # This should raise a ``ValueError``
     some_list.remove(4)
  except (IndexError, ValueError), e:
     print("Caught again!")
     print(e)

  خروجی (Python 2.x):

  Caught again!
  list.remove(x): x not in list
  

  خروجی (Python 3.x):

    File "<input>", line 4
      except (IndexError, ValueError), e:
                                       ^
  IndentationError: unindent does not match any outer indentation level

• جدا کردن استثنا از متغیر با استفاده از ویرگول منسوخ شده و در پایتون 3 کار نمی‌کند؛ روش صحیح استفاده از as است. برای مثال:

  some_list = [1, 2, 3]
  try:
      some_list.remove(4)
  
  except (IndexError, ValueError) as e:
      print("Caught again!")
      print(e)

  خروجی:

  Caught again!
  list.remove(x): x not in list
  

1.

a = [1, 2, 3, 4]
b = a
a = a + [5, 6, 7, 8]

خروجی:

>>> a
[1, 2, 3, 4, 5, 6, 7, 8]
>>> b
[1, 2, 3, 4]

2.

a = [1, 2, 3, 4]
b = a
a += [5, 6, 7, 8]

خروجی:

>>> a
[1, 2, 3, 4, 5, 6, 7, 8]
>>> b
[1, 2, 3, 4, 5, 6, 7, 8]

• عملگر a += b همیشه همانند a = a + b رفتار نمی‌کند. کلاس‌ها ممکن است عملگرهای op= را به گونه‌ای متفاوت پیاده‌سازی کنند، و لیست‌ها نیز چنین می‌کنند.

• عبارت a = a + [5,6,7,8] یک لیست جدید ایجاد می‌کند و مرجع a را به این لیست جدید اختصاص می‌دهد، بدون آنکه b را تغییر دهد.

• عبارت a += [5,6,7,8] در واقع به تابعی معادل «extend» ترجمه می‌شود که روی لیست اصلی عمل می‌کند؛ بنابراین a و b همچنان به همان لیست اشاره می‌کنند که به‌صورت درجا (in-place) تغییر کرده است.

1.

x = 5
class SomeClass:
    x = 17
    y = (x for i in range(10))

خروجی:

>>> list(SomeClass.y)[0]
5

2.

x = 5
class SomeClass:
    x = 17
    y = [x for i in range(10)]

خروجی (Python 2.x):

>>> SomeClass.y[0]
17

خروجی (Python 3.x):

>>> SomeClass.y[0]
5

• حوزه‌هایی که درون تعریف کلاس تو در تو هستند، نام‌های تعریف‌شده در سطح کلاس را نادیده می‌گیرند.
• عبارت‌های جنراتور (generator expressions) حوزه‌ی مختص به خود دارند.
• از پایتون نسخه‌ی ۳ به بعد، لیست‌های فشرده (list comprehensions) نیز حوزه‌ی مختص به خود دارند.

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

def get_middle(some_list):
    mid_index = round(len(some_list) / 2)
    return some_list[mid_index - 1]

Python 3.x:

>>> get_middle([1])  # خوب به نظر می رسد.
1
>>> get_middle([1,2,3])  # خوب به نظر می رسد.
2
>>> get_middle([1,2,3,4,5])  # چی?
2
>>> len([1,2,3,4,5]) / 2  # خوبه
2.5
>>> round(len([1,2,3,4,5]) / 2)  # چرا?
2

به نظر می‌رسد که پایتون عدد ۲٫۵ را به ۲ گرد کرده است.

• این یک خطای مربوط به دقت اعداد اعشاری نیست؛ بلکه این رفتار عمدی است. از پایتون نسخه 3.0 به بعد، تابع round() از گرد کردن بانکی استفاده می‌کند که در آن کسرهای .5 به نزدیک‌ترین عدد زوج گرد می‌شوند:

>>> round(0.5)
0
>>> round(1.5)
2
>>> round(2.5)
2
>>> import numpy  # numpy هم همینکار را می کند.
>>> numpy.round(0.5)
0.0
>>> numpy.round(1.5)
2.0
>>> numpy.round(2.5)
2.0

• این روشِ پیشنهادی برای گرد کردن کسرهای .5 مطابق با استاندارد IEEE 754 است. با این حال، روش دیگر (گرد کردن به سمت دور از صفر) اغلب در مدارس آموزش داده می‌شود؛ بنابراین، «گرد کردن بانکی» احتمالا چندان شناخته‌شده نیست. همچنین، برخی از رایج‌ترین زبان‌های برنامه‌نویسی (مانند جاوااسکریپت، جاوا، C/C++‎، روبی و راست) نیز از گرد کردن بانکی استفاده نمی‌کنند. به همین دلیل این موضوع همچنان مختص پایتون بوده و ممکن است باعث سردرگمی هنگام گرد کردن کسرها شود.
• برای اطلاعات بیشتر به مستندات تابع round() یا این بحث در Stack Overflow مراجعه کنید.
• توجه داشته باشید که get_middle([1]) فقط به این دلیل مقدار 1 را بازگرداند که اندیس آن round(0.5) - 1 = 0 - 1 = -1 بود و در نتیجه آخرین عنصر لیست را برمی‌گرداند.

من تا به امروز حتی یک برنامه‌نویس باتجربهٔ پایتون را ندیده‌ام که حداقل با یکی از سناریوهای زیر مواجه نشده باشد:

1.

x, y = (0, 1) if True else None, None

خروجی:

>>> x, y  # چیزی که توقع داریم. (0, 1)
((0, 1), None)

2.

t = ('one', 'two')
for i in t:
    print(i)

t = ('one')
for i in t:
    print(i)

t = ()
print(t)

خروجی:

one
two
o
n
e
tuple()

3.

ten_words_list = [
    "some",
    "very",
    "big",
    "list",
    "that"
    "consists",
    "of",
    "exactly",
    "ten",
    "words"
]

خروجی

>>> len(ten_words_list)
9

4. عدم تأکید کافی

a = "python"
b = "javascript"

خروجی:

# دستور assert همراه با پیام خطای assertion
>>> assert(a == b, "Both languages are different")
# هیچ AssertionError ای رخ نمی‌دهد

5.

some_list = [1, 2, 3]
some_dict = {
  "key_1": 1,
  "key_2": 2,
  "key_3": 3
}

some_list = some_list.append(4)
some_dict = some_dict.update({"key_4": 4})

خروجی:

>>> print(some_list)
None
>>> print(some_dict)
None

6.

def some_recursive_func(a):
    if a[0] == 0:
        return
    a[0] -= 1
    some_recursive_func(a)
    return a

def similar_recursive_func(a):
    if a == 0:
        return a
    a -= 1
    similar_recursive_func(a)
    return a

خروجی:

>>> some_recursive_func([5, 0])
[0, 0]
>>> similar_recursive_func(5)
4

• برای مورد ۱، عبارت صحیح برای رفتار مورد انتظار این است:
  x, y = (0, 1) if True else (None, None)

• برای مورد ۲، عبارت صحیح برای رفتار مورد انتظار این است:
  اینجا، t = ('one',) یا t = 'one', (ویرگول از قلم افتاده است). در غیر این صورت مفسر t را به عنوان یک str در نظر گرفته و به صورت کاراکتر به کاراکتر روی آن پیمایش می‌کند.

• علامت () یک توکن خاص است و نشان‌دهنده‌ی یک tuple خالی است.

• در مورد ۳، همان‌طور که احتمالاً متوجه شدید، بعد از عنصر پنجم ("that") یک ویرگول از قلم افتاده است. بنابراین با الحاق ضمنی رشته‌ها،

  >>> ten_words_list
  ['some', 'very', 'big', 'list', 'thatconsists', 'of', 'exactly', 'ten', 'words']

• در قطعه‌ی چهارم هیچ AssertionErrorای رخ نداد؛ زیرا به جای ارزیابی عبارت تکی a == b، کل یک تاپل ارزیابی شده است. قطعه‌ی کد زیر این موضوع را روشن‌تر می‌کند:

  >>> a = "python"
  >>> b = "javascript"
  >>> assert a == b
  Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
  AssertionError
  
  >>> assert (a == b, "Values are not equal")
  <stdin>:1: SyntaxWarning: assertion is always true, perhaps remove parentheses?
  
  >>> assert a == b, "Values are not equal"
  Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
  AssertionError: Values are not equal

• در قطعه‌ی پنجم، بیشتر متدهایی که اشیای ترتیبی (Sequence) یا نگاشت‌ها (Mapping) را تغییر می‌دهند (مانند list.append، dict.update، list.sort و غیره)، شیء اصلی را به‌صورت درجا (in-place) تغییر داده و مقدار None برمی‌گردانند. منطق پشت این تصمیم، بهبود عملکرد با جلوگیری از کپی کردن شیء است (به این منبع مراجعه کنید).

• قطعه‌ی آخر نیز نسبتاً واضح است؛ شیء تغییرپذیر (mutable)، مثل list، می‌تواند در داخل تابع تغییر کند، درحالی‌که انتساب دوباره‌ی یک شیء تغییرناپذیر (مانند a -= 1) باعث تغییر مقدار اصلی آن نخواهد شد.

• آگاهی از این نکات ظریف در بلندمدت می‌تواند ساعت‌ها از زمان شما برای رفع اشکال را صرفه‌جویی کند.

>>> 'a'.split()
['a']

# معادل است با
>>> 'a'.split(' ')
['a']

# اما
>>> len(''.split())
0

# معادل نیست با
>>> len(''.split(' '))
1

• در نگاه اول ممکن است به نظر برسد جداکننده‌ی پیش‌فرض متد split یک فاصله‌ی تکی (' ') است؛ اما مطابق با مستندات رسمی:

  اگر sep مشخص نشده یا برابر با None باشد، یک الگوریتم متفاوت برای جدا کردن اعمال می‌شود: رشته‌هایی از فاصله‌های متوالی به عنوان یک جداکننده‌ی واحد در نظر گرفته شده و در نتیجه، هیچ رشته‌ی خالی‌ای در ابتدا یا انتهای لیست خروجی قرار نمی‌گیرد، حتی اگر رشته‌ی اولیه دارای فاصله‌های اضافی در ابتدا یا انتها باشد. به همین دلیل، تقسیم یک رشته‌ی خالی یا رشته‌ای که فقط شامل فضای خالی است با جداکننده‌ی None باعث بازگشت یک لیست خالی [] می‌شود. اگر sep مشخص شود، جداکننده‌های متوالی در کنار هم قرار نمی‌گیرند و هر جداکننده، یک رشته‌ی خالی جدید ایجاد می‌کند. (مثلاً '1,,2'.split(',') مقدار ['1', '', '2'] را برمی‌گرداند.) تقسیم یک رشته‌ی خالی با یک جداکننده‌ی مشخص‌شده نیز باعث بازگشت [''] می‌شود.

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

  >>> ' a '.split(' ')
  ['', 'a', '']
  >>> ' a '.split()
  ['a']
  >>> ''.split(' ')
  ['']

# File: module.py

def some_weird_name_func_():
    print("works!")

def _another_weird_name_func():
    print("works!")

خروجی

>>> from module import *
>>> some_weird_name_func_()
"works!"
>>> _another_weird_name_func()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name '_another_weird_name_func' is not defined

• اغلب توصیه می‌شود از واردسازی عمومی (wildcard imports) استفاده نکنید. اولین دلیل واضح آن این است که در این نوع واردسازی‌ها، اسامی که با زیرخط (_) شروع شوند، وارد نمی‌شوند. این مسئله ممکن است در زمان اجرا به خطا منجر شود.

• اگر از ساختار from ... import a, b, c استفاده کنیم، خطای NameError فوق اتفاق نمی‌افتاد.

  >>> from module import some_weird_name_func_, _another_weird_name_func
  >>> _another_weird_name_func()
  works!

• اگر واقعاً تمایل دارید از واردسازی عمومی استفاده کنید، لازم است فهرستی به نام __all__ را در ماژول خود تعریف کنید که شامل نام اشیاء عمومی (public) قابل‌دسترس هنگام واردسازی عمومی است.

  __all__ = ['_another_weird_name_func']
  
  def some_weird_name_func_():
      print("works!")
  
  def _another_weird_name_func():
      print("works!")

  خروجی

  >>> _another_weird_name_func()
  "works!"
  >>> some_weird_name_func_()
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  NameError: name 'some_weird_name_func_' is not defined

>>> x = 7, 8, 9
>>> sorted(x) == x
False
>>> sorted(x) == sorted(x)
True

>>> y = reversed(x)
>>> sorted(y) == sorted(y)
False

• متد sorted همیشه یک لیست (list) برمی‌گرداند، و در پایتون مقایسه‌ی لیست‌ها و تاپل‌ها (tuple) همیشه مقدار False را برمی‌گرداند.

• >>> [] == tuple()
  False
  >>> x = 7, 8, 9
  >>> type(x), type(sorted(x))
  (tuple, list)

• برخلاف متد sorted، متد reversed یک تکرارکننده (iterator) برمی‌گرداند. چرا؟ زیرا مرتب‌سازی نیاز به تغییر درجا (in-place) یا استفاده از ظرف جانبی (مانند یک لیست اضافی) دارد، در حالی که معکوس کردن می‌تواند به‌سادگی با پیمایش از اندیس آخر به اول انجام شود.

• بنابراین در مقایسه‌ی sorted(y) == sorted(y)، فراخوانی اولِ sorted() تمام عناصرِ تکرارکننده‌ی y را مصرف می‌کند، و فراخوانی بعدی یک لیست خالی برمی‌گرداند.

  >>> x = 7, 8, 9
  >>> y = reversed(x)
  >>> sorted(y), sorted(y)
  ([7, 8, 9], [])

from datetime import datetime

midnight = datetime(2018, 1, 1, 0, 0)
midnight_time = midnight.time()

noon = datetime(2018, 1, 1, 12, 0)
noon_time = noon.time()

if midnight_time:
    print("Time at midnight is", midnight_time)

if noon_time:
    print("Time at noon is", noon_time)

خروجی (< 3.5):

('Time at noon is', datetime.time(12, 0))

زمان نیمه‌شب چاپ نمی‌شود.

پیش از پایتون 3.5، مقدار بولی برای شیء datetime.time اگر نشان‌دهندهٔ نیمه‌شب به وقت UTC بود، برابر با False در نظر گرفته می‌شد. این رفتار در استفاده از دستور if obj: برای بررسی تهی بودن شیء یا برابر بودن آن با مقدار "خالی"، ممکن است باعث بروز خطا شود.

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

خب، بفرمایید

import antigravity

خروجی: Sshh... It's a super-secret.

• ماژول antigravity یکی از معدود ایستر اِگ‌هایی است که توسط توسعه‌دهندگان پایتون ارائه شده است.
• دستور import antigravity باعث می‌شود مرورگر وب به سمت کمیک کلاسیک XKCD در مورد پایتون باز شود.
• البته موضوع عمیق‌تر است؛ در واقع یک ایستر اگ دیگر داخل این ایستر اگ وجود دارد. اگر به کد منبع نگاه کنید، یک تابع تعریف شده که ادعا می‌کند الگوریتم جئوهشینگ XKCD را پیاده‌سازی کرده است.

from goto import goto, label
for i in range(9):
    for j in range(9):
        for k in range(9):
            print("I am trapped, please rescue!")
            if k == 2:
                goto .breakout # خروج از یک حلقه‌ی تودرتوی عمیق
label .breakout
print("Freedom!")

خروجی (پایتون ۲.۳):

I am trapped, please rescue!
I am trapped, please rescue!
Freedom!

• نسخه‌ی قابل استفاده‌ای از goto در پایتون به عنوان یک شوخی در اول آوریل ۲۰۰۴ معرفی شد.
• نسخه‌های فعلی پایتون فاقد این ماژول هستند.
• اگرچه این ماژول واقعاً کار می‌کند، ولی لطفاً از آن استفاده نکنید. در این صفحه می‌توانید دلیل عدم حضور دستور goto در پایتون را مطالعه کنید.

اگر جزو افرادی هستید که دوست ندارند در پایتون برای مشخص کردن محدوده‌ها از فضای خالی (whitespace) استفاده کنند، می‌توانید با ایمپورت کردن ماژول زیر از آکولاد {} به سبک زبان C استفاده کنید:

from __future__ import braces

خروجی:

  File "some_file.py", line 1
    from __future__ import braces
SyntaxError: not a chance

آکولاد؟ هرگز! اگر از این بابت ناامید شدید، بهتر است از جاوا استفاده کنید. خب، یک چیز شگفت‌آور دیگر؛ آیا می‌توانید تشخیص دهید که ارور SyntaxError در کجای کد ماژول __future__ اینجا ایجاد می‌شود؟

• ماژول __future__ معمولاً برای ارائه قابلیت‌هایی از نسخه‌های آینده پایتون به کار می‌رود. اما کلمه «future» (آینده) در این زمینه خاص، حالت طنز و کنایه دارد.
• این مورد یک «ایستر اگ» (easter egg) است که به احساسات جامعه برنامه‌نویسان پایتون در این خصوص اشاره دارد.
• کد مربوط به این موضوع در واقع اینجا در فایل future.c قرار دارد.
• زمانی که کامپایلر CPython با یک عبارت future مواجه می‌شود، ابتدا کد مرتبط در future.c را اجرا کرده و سپس آن را همانند یک دستور ایمپورت عادی در نظر می‌گیرد.

خروجی (Python 3.x)

>>> from __future__ import barry_as_FLUFL
>>> "Ruby" != "Python" # شکی در این نیست.
  File "some_file.py", line 1
    "Ruby" != "Python"
              ^
SyntaxError: invalid syntax

>>> "Ruby" <> "Python"
True

حالا می‌رسیم به اصل ماجرا.

• این مورد مربوط به PEP-401 است که در تاریخ ۱ آوریل ۲۰۰۹ منتشر شد (اکنون می‌دانید این یعنی چه!).

• نقل قولی از PEP-401:

  با توجه به اینکه عملگر نابرابری != در پایتون ۳.۰ یک اشتباه وحشتناک و انگشت‌سوز (!) بوده است، عمو زبان مهربان برای همیشه (FLUFL) عملگر الماسی‌شکل <> را مجدداً به‌عنوان تنها روش درست برای این منظور بازگردانده است.

• البته «عمو بَری» چیزهای بیشتری برای گفتن در این PEP داشت؛ می‌توانید آن‌ها را اینجا مطالعه کنید.

• این قابلیت در محیط تعاملی به خوبی عمل می‌کند، اما در زمان اجرای کد از طریق فایل پایتون، با خطای SyntaxError روبرو خواهید شد (برای اطلاعات بیشتر به این issue مراجعه کنید). با این حال، می‌توانید کد خود را درون یک eval یا compile قرار دهید تا این قابلیت فعال شود.

  from __future__ import barry_as_FLUFL
  print(eval('"Ruby" <> "Python"'))

import this

صبر کن، این چیه؟ this عشقه ❤️

خروجی:

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

این ذنِ پایتون است!

>>> love = this
>>> this is love
True
>>> love is True
False
>>> love is False
False
>>> love is not True or False
True
>>> love is not True or False; love is love  # عشق پیجیده است
True

• ماژول this در پایتون، یک ایستر اگ برای «ذنِ پایتون» (PEP 20) است.
• اگر این موضوع به‌اندازه کافی جالب است، حتماً پیاده‌سازی this.py را ببینید. نکته جالب این است که کد مربوط به ذنِ پایتون، خودش اصول ذن را نقض کرده است (و احتمالاً این تنها جایی است که چنین اتفاقی می‌افتد).
• درباره جمله love is not True or False; love is love، اگرچه طعنه‌آمیز است، اما خود گویاست. (اگر واضح نیست، لطفاً مثال‌های مربوط به عملگرهای is و is not را مشاهده کنید.)

عبارت else برای حلقه‌ها. یک مثال معمول آن می‌تواند چنین باشد:

  def does_exists_num(l, to_find):
      for num in l:
          if num == to_find:
              print("Exists!")
              break
      else:
          print("Does not exist")

خروجی:

>>> some_list = [1, 2, 3, 4, 5]
>>> does_exists_num(some_list, 4)
Exists!
>>> does_exists_num(some_list, -1)
Does not exist

عبارت else در مدیریت استثناها. مثالی از آن:

try:
    pass
except:
    print("Exception occurred!!!")
else:
    print("Try block executed successfully...")

خروجی:

Try block executed successfully...

• عبارت else بعد از حلقه‌ها تنها زمانی اجرا می‌شود که در هیچ‌کدام از تکرارها (iterations) از دستور break استفاده نشده باشد. می‌توانید آن را به عنوان یک شرط «بدون شکست» (nobreak) در نظر بگیرید.
• عبارت else پس از بلاک try به عنوان «عبارت تکمیل» (completion clause) نیز شناخته می‌شود؛ چراکه رسیدن به عبارت else در ساختار try به این معنی است که بلاک try بدون رخ دادن استثنا با موفقیت تکمیل شده است.

def some_func():
    Ellipsis

خروجی

>>> some_func()
# بدون خروجی و بدون خطا

>>> SomeRandomString
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'SomeRandomString' is not defined

>>> Ellipsis
Ellipsis

• در پایتون، Ellipsis یک شیء درونی (built-in) است که به صورت سراسری (global) در دسترس است و معادل ... است.

  >>> ...
  Ellipsis

• عملگر Ellipsis می‌تواند برای چندین منظور استفاده شود:

  • به عنوان یک نگه‌دارنده برای کدی که هنوز نوشته نشده است (مانند دستور pass)

  • در سینتکس برش (slicing) برای نمایش برش کامل در ابعاد باقی‌مانده

    >>> import numpy as np
    >>> three_dimensional_array = np.arange(8).reshape(2, 2, 2)
    array([
        [
            [0, 1],
            [2, 3]
        ],
    
        [
            [4, 5],
            [6, 7]
        ]
    ])

    بنابراین، آرایه‌ی three_dimensional_array ما، آرایه‌ای از آرایه‌ها از آرایه‌ها است. فرض کنیم می‌خواهیم عنصر دوم (اندیس 1) از تمامی آرایه‌های درونی را چاپ کنیم؛ در این حالت می‌توانیم از Ellipsis برای عبور از تمامی ابعاد قبلی استفاده کنیم:

    >>> three_dimensional_array[:,:,1]
    array([[1, 3],
       [5, 7]])
    >>> three_dimensional_array[..., 1] # با استفاده از Ellipsis.
    array([[1, 3],
       [5, 7]])

    نکته: این روش برای آرایه‌هایی با هر تعداد بُعد کار می‌کند. حتی می‌توانید از برش (slice) در بُعد اول و آخر استفاده کرده و ابعاد میانی را نادیده بگیرید (به صورت n_dimensional_array[first_dim_slice, ..., last_dim_slice]).

  • در نوع‌دهی (type hinting) برای اشاره به بخشی از نوع (مانند Callable[..., int] یا Tuple[str, ...]) استفاده می‌شود.

  • همچنین می‌توانید از Ellipsis به عنوان آرگومان پیش‌فرض تابع استفاده کنید (برای مواردی که می‌خواهید میان «آرگومانی ارسال نشده است» و «مقدار None ارسال شده است» تمایز قائل شوید).

این املای کلمه تعمداً به همین شکل نوشته شده است. لطفاً برای اصلاح آن درخواست (patch) ارسال نکنید.

خروجی (پایتون 3.x):

>>> infinity = float('infinity')
>>> hash(infinity)
314159
>>> hash(float('-inf'))
-314159