wtfpython/translations/fa-farsi

What the f*ck Python! 😱

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

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

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

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

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

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

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

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

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

فهرست مطالب

• فهرست مطالب
• ساختار مثال‌ها
• استفاده
• 👀 مثال‌ها
  • بخش: ذهن خود را به چالش بکشید!
    • ▶ اول از همه! *
      • 💡 توضیحات
    • ▶ بعضی وقت‌ها رشته‌ها می‌توانند دردسرساز شوند
      • 💡 Explanation:
    • ▶ Be careful with chained operations
      • 💡 Explanation:
    • ▶ How not to use is operator
      • 💡 Explanation:
    • ▶ Hash brownies
      • 💡 Explanation
    • ▶ Deep down, we're all the same.
      • 💡 Explanation:
    • ▶ Disorder within order *
      • 💡 Explanation:
    • ▶ Keep trying... *
      • 💡 Explanation:
    • ▶ For what?
      • 💡 Explanation:
    • ▶ Evaluation time discrepancy
      • 💡 Explanation
    • ▶ is not ... is not is (not ...)
      • 💡 Explanation
    • ▶ A tic-tac-toe where X wins in the first attempt!
      • 💡 Explanation:
    • ▶ Schrödinger's variable *
      • 💡 Explanation:
    • ▶ The chicken-egg problem *
      • 💡 Explanation
    • ▶ Subclass relationships
      • 💡 Explanation:
    • ▶ ‫ برابری و هویت متدها
      • 💡 ‫ توضیحات
    • ▶ ‫ آل-ترو-یشن *
      • 💡 Explanation:
      • 💡 ‫ توضیح:
    • ▶ ‫ رشته‌ها و بک‌اسلش‌ها
      • 💡 ‫ توضیح:
    • ▶ ‫ گره نیست، نَه!
      • 💡 Explanation:
    • ▶ رشته‌های نیمه سه‌نقل‌قولی
      • 💡 ‫ توضیح:
    • ▶ ‫ مشکل بولین ها چیست؟
      • 💡 ‫ توضیحات:
    • ▶ ‫ ویژگی‌های کلاس و ویژگی‌های نمونه
      • 💡 ‫ توضیح:
    • ▶ yielding None
      • 💡 Explanation:
    • ▶ Yielding from... return! *
      • 💡 ‫ توضیح:
    • ▶ ‫ بازتاب‌ناپذیری *
      • 💡 توضیحات:
    • ▶ ‫ تغییر دادن اشیای تغییرناپذیر!
      • 💡 ‫ توضیحات:
    • ▶ ‫ متغیری که از اسکوپ بیرونی ناپدید می‌شود
      • 💡 ‫ توضیحات:
    • ▶ ‫ تبدیل اسرارآمیز نوع کلید
      • 💡 ‫ توضیحات:
    • ▶ ‫ ببینیم می‌توانید این را حدس بزنید؟
      • 💡 ‫ توضیح:
    • ▶ ‫ از حد مجاز برای تبدیل رشته به عدد صحیح فراتر می‌رود
      • 💡 ‫ توضیح:
  • ‫ بخش: شیب‌های لغزنده
    • ▶ ‫ تغییر یک دیکشنری هنگام پیمایش روی آن
      • ‫ 💡 توضیح:
    • ▶ عملیات سرسختانه‌ی del
      • ‫ 💡 توضیح:
    • ▶ ‫ متغیری که از حوزه خارج است
      • ‫ 💡 توضیح:
    • ▶ ‫ حذف المان‌های لیست در حین پیمایش
      • 💡 Explanation:
    • ▶ ‫ زیپِ دارای اتلاف برای پیمایشگرها *
      • ‫ 💡 توضیحات:
    • ▶ ‫ نشت کردن متغیرهای حلقه!
      • 💡 ‫ توضیحات:
    • ▶ ‫ مراقب آرگومان‌های تغییرپذیر پیش‌فرض باشید!
      • 💡 ‫ توضیحات:
    • ▶ ‫ گرفتن استثناها (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") # دقت کنید که هردو ID یکی هستند.
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

Makes sense, right?

💡 Explanation:

• The behavior in first and second snippets is due to a CPython optimization (called string interning) that tries to use existing immutable objects in some cases rather than creating a new object every time.
• After being "interned," many variables may reference the same string object in memory (saving memory thereby).
• In the snippets above, strings are implicitly interned. The decision of when to implicitly intern a string is implementation-dependent. There are some rules that can be used to guess if a string will be interned or not:
  • All length 0 and length 1 strings are interned.
  • Strings are interned at compile time ('wtf' will be interned but ''.join(['w', 't', 'f']) will not be interned)
  • Strings that are not composed of ASCII letters, digits or underscores, are not interned. This explains why 'wtf!' was not interned due to !. CPython implementation of this rule can be found here

• When a and b are set to "wtf!" in the same line, the Python interpreter creates a new object, then references the second variable at the same time. If you do it on separate lines, it doesn't "know" that there's already "wtf!" as an object (because "wtf!" is not implicitly interned as per the facts mentioned above). It's a compile-time optimization. This optimization doesn't apply to 3.7.x versions of CPython (check this issue for more discussion).
• A compile unit in an interactive environment like IPython consists of a single statement, whereas it consists of the entire module in case of modules. a, b = "wtf!", "wtf!" is single statement, whereas a = "wtf!"; b = "wtf!" are two statements in a single line. This explains why the identities are different in a = "wtf!"; b = "wtf!", and also explain why they are same when invoked in some_file.py
• The abrupt change in the output of the fourth snippet is due to a peephole optimization technique known as Constant folding. This means the expression 'a'*20 is replaced by 'aaaaaaaaaaaaaaaaaaaa' during compilation to save a few clock cycles during runtime. Constant folding only occurs for strings having a length of less than 21. (Why? Imagine the size of .pyc file generated as a result of the expression 'a'*10**10). Here's the implementation source for the same.
• Note: In Python 3.7, Constant folding was moved out from peephole optimizer to the new AST optimizer with some change in logic as well, so the fourth snippet doesn't work for Python 3.7. You can read more about the change here.

---

▶ Be careful with chained operations

>>> (False == False) in [False] # makes sense
False
>>> False == (False in [False]) # makes sense
False
>>> False == False in [False] # now what?
True

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

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

💡 Explanation:

As per https://docs.python.org/3/reference/expressions.html#comparisons

Formally, if a, b, c, ..., y, z are expressions and op1, op2, ..., opN are comparison operators, then a op1 b op2 c ... y opN z is equivalent to a op1 b and b op2 c and ... y opN z, except that each expression is evaluated at most once.

While such behavior might seem silly to you in the above examples, it's fantastic with stuff like a == b == c and 0 <= x <= 100.

• False is False is False is equivalent to (False is False) and (False is False)
• True is False == False is equivalent to (True is False) and (False == False) and since the first part of the statement (True is False) evaluates to False, the overall expression evaluates to False.
• 1 > 0 < 1 is equivalent to (1 > 0) and (0 < 1) which evaluates to True.
• The expression (1 > 0) < 1 is equivalent to True < 1 and

  >>> int(True)
  1
  >>> True + 1 #not relevant for this example, but just for fun
  2
  

  So, 1 < 1 evaluates to False

---

▶ How not to use is operator

The following is a very famous example present all over the internet.

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. Output

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

Output (Python 3.7.x specifically)

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

💡 Explanation:

The difference between is and ==

• is operator checks if both the operands refer to the same object (i.e., it checks if the identity of the operands matches or not).
• == operator compares the values of both the operands and checks if they are the same.
• So is is for reference equality and == is for value equality. An example to clear things up,

  >>> class A: pass
  >>> A() is A() # These are two empty objects at two different memory locations.
  False
  

256 is an existing object but 257 isn't

When you start up python the numbers from -5 to 256 will be allocated. These numbers are used a lot, so it makes sense just to have them ready.

Quoting from https://docs.python.org/3/c-api/long.html

The current implementation keeps an array of integer objects for all integers between -5 and 256, when you create an int in that range you just get back a reference to the existing object. So it should be possible to change the value of 1. I suspect the behavior of Python, in this case, is undefined. :-)

>>> 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

Here the interpreter isn't smart enough while executing y = 257 to recognize that we've already created an integer of the value 257, and so it goes on to create another object in the memory.

Similar optimization applies to other immutable objects like empty tuples as well. Since lists are mutable, that's why [] is [] will return False and () is () will return True. This explains our second snippet. Let's move on to the third one,

Both a and b refer to the same object when initialized with same value in the same line.

Output

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

• When a and b are set to 257 in the same line, the Python interpreter creates a new object, then references the second variable at the same time. If you do it on separate lines, it doesn't "know" that there's already 257 as an object.

• It's a compiler optimization and specifically applies to the interactive environment. When you enter two lines in a live interpreter, they're compiled separately, therefore optimized separately. If you were to try this example in a .py file, you would not see the same behavior, because the file is compiled all at once. This optimization is not limited to integers, it works for other immutable data types like strings (check the "Strings are tricky example") and floats as well,

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

• Why didn't this work for Python 3.7? The abstract reason is because such compiler optimizations are implementation specific (i.e. may change with version, OS, etc). I'm still figuring out what exact implementation change cause the issue, you can check out this issue for updates.

---

▶ Hash brownies

1.

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

Output:

>>> some_dict[5.5]
"JavaScript"
>>> some_dict[5.0] # "Python" destroyed the existence of "Ruby"?
"Python"
>>> some_dict[5] 
"Python"

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

So, why is Python all over the place?

💡 Explanation

• Uniqueness of keys in a Python dictionary is by equivalence, not identity. So even though 5, 5.0, and 5 + 0j are distinct objects of different types, since they're equal, they can't both be in the same dict (or set). As soon as you insert any one of them, attempting to look up any distinct but equivalent key will succeed with the original mapped value (rather than failing with a 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
  

• This applies when setting an item as well. So when you do some_dict[5] = "Python", Python finds the existing item with equivalent key 5.0 -> "Ruby", overwrites its value in place, and leaves the original key alone.

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

• So how can we update the key to 5 (instead of 5.0)? We can't actually do this update in place, but what we can do is first delete the key (del some_dict[5.0]), and then set it (some_dict[5]) to get the integer 5 as the key instead of floating 5.0, though this should be needed in rare cases.

• How did Python find 5 in a dictionary containing 5.0? Python does this in constant time without having to scan through every item by using hash functions. When Python looks up a key foo in a dict, it first computes hash(foo) (which runs in constant-time). Since in Python it is required that objects that compare equal also have the same hash value (docs here), 5, 5.0, and 5 + 0j have the same hash value.

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

  Note: The inverse is not necessarily true: Objects with equal hash values may themselves be unequal. (This causes what's known as a hash collision, and degrades the constant-time performance that hashing usually provides.)

---

▶ Deep down, we're all the same.

class WTF:
  pass

Output:

>>> WTF() == WTF() # two different instances can't be equal
False
>>> WTF() is WTF() # identities are also different
False
>>> hash(WTF()) == hash(WTF()) # hashes _should_ be different as well
True
>>> id(WTF()) == id(WTF())
True

💡 Explanation:

• When id was called, Python created a WTF class object and passed it to the id function. The id function takes its id (its memory location), and throws away the object. The object is destroyed.

• When we do this twice in succession, Python allocates the same memory location to this second object as well. Since (in CPython) id uses the memory location as the object id, the id of the two objects is the same.

• So, the object's id is unique only for the lifetime of the object. After the object is destroyed, or before it is created, something else can have the same id.

• But why did the is operator evaluate to False? Let's see with this snippet.

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

  Output:

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

  As you may observe, the order in which the objects are destroyed is what made all the difference here.

---

▶ Disorder within order *

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):
    """
    A dict that also implements __hash__ magic.
    """
    __hash__ = lambda self: 0

class OrderedDictWithHash(OrderedDict):
    """
    An OrderedDict that also implements __hash__ magic.
    """
    __hash__ = lambda self: 0

Output

>>> dictionary == ordered_dict # If a == b
True
>>> dictionary == another_ordered_dict # and b == c
True
>>> ordered_dict == another_ordered_dict # then why isn't c == a ??
False

# We all know that a set consists of only unique elements,
# let's try making a set of these dictionaries and see what happens...

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

# Makes sense since dict don't have __hash__ implemented, let's use
# our wrapper classes.
>>> 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}) # changing the order
2

What is going on here?

💡 Explanation:

• The reason why intransitive equality didn't hold among dictionary, ordered_dict and another_ordered_dict is because of the way __eq__ method is implemented in OrderedDict class. From the docs

  Equality tests between OrderedDict objects are order-sensitive and are implemented as list(od1.items())==list(od2.items()). Equality tests between OrderedDict objects and other Mapping objects are order-insensitive like regular dictionaries.

• The reason for this equality in behavior is that it allows OrderedDict objects to be directly substituted anywhere a regular dictionary is used.

• Okay, so why did changing the order affect the length of the generated set object? The answer is the lack of intransitive equality only. Since sets are "unordered" collections of unique elements, the order in which elements are inserted shouldn't matter. But in this case, it does matter. Let's break it down a bit,

  >>> some_set = set()
  >>> some_set.add(dictionary) # these are the mapping objects from the snippets above
  >>> 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
  

  So the inconsistency is due to another_ordered_dict in another_set being False because ordered_dict was already present in another_set and as observed before, ordered_dict == another_ordered_dict is False.

---

▶ Keep trying... *

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(): # A gotcha!
    try:
        for i in range(3):
            try:
                1 / i
            except ZeroDivisionError:
                # Let's throw it here and handle it outside for loop
                raise ZeroDivisionError("A trivial divide by zero error")
            finally:
                print("Iteration", i)
                break
    except ZeroDivisionError as e:
        print("Zero division error occurred", e)

Output:

>>> 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

💡 Explanation:

• When a return, break or continue statement is executed in the try suite of a "try…finally" statement, the finally clause is also executed on the way out.
• The return value of a function is determined by the last return statement executed. Since the finally clause always executes, a return statement executed in the finally clause will always be the last one executed.
• The caveat here is, if the finally clause executes a return or break statement, the temporarily saved exception is discarded.

---

▶ For what?

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

Output:

>>> some_dict # An indexed dict appears.
{0: 'w', 1: 't', 2: 'f'}

💡 Explanation:

• A for statement is defined in the Python grammar as:

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

  Where exprlist is the assignment target. This means that the equivalent of {exprlist} = {next_value} is executed for each item in the iterable. An interesting example that illustrates this:

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

  Output:

  0
  1
  2
  3
  

  Did you expect the loop to run just once?

  💡 Explanation:

  • The assignment statement i = 10 never affects the iterations of the loop because of the way for loops work in Python. Before the beginning of every iteration, the next item provided by the iterator (range(4) in this case) is unpacked and assigned the target list variables (i in this case).

• The enumerate(some_string) function yields a new value i (a counter going up) and a character from the some_string in each iteration. It then sets the (just assigned) i key of the dictionary some_dict to that character. The unrolling of the loop can be simplified as:

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

---

▶ Evaluation time discrepancy

1.

array = [1, 8, 15]
# A typical generator expression
gen = (x for x in array if array.count(x) > 0)
array = [2, 8, 22]

Output:

>>> print(list(gen)) # Where did the other values go?
[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]

Output:

>>> 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]

Output:

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

💡 Explanation

• In a generator expression, the in clause is evaluated at declaration time, but the conditional clause is evaluated at runtime.

• So before runtime, array is re-assigned to the list [2, 8, 22], and since out of 1, 8 and 15, only the count of 8 is greater than 0, the generator only yields 8.

• The differences in the output of g1 and g2 in the second part is due the way variables array_1 and array_2 are re-assigned values.

• In the first case, array_1 is bound to the new object [1,2,3,4,5] and since the in clause is evaluated at the declaration time it still refers to the old object [1,2,3,4] (which is not destroyed).

• In the second case, the slice assignment to array_2 updates the same old object [1,2,3,4] to [1,2,3,4,5]. Hence both the g2 and array_2 still have reference to the same object (which has now been updated to [1,2,3,4,5]).

• Okay, going by the logic discussed so far, shouldn't be the value of list(gen) in the third snippet be [11, 21, 31, 12, 22, 32, 13, 23, 33]? (because array_3 and array_4 are going to behave just like array_1). The reason why (only) array_4 values got updated is explained in PEP-289

  Only the outermost for-expression is evaluated immediately, the other expressions are deferred until the generator is run.

---

▶ is not ... is not is (not ...)

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

💡 Explanation

• is not is a single binary operator, and has behavior different than using is and not separated.
• is not evaluates to False if the variables on either side of the operator point to the same object and True otherwise.
• In the example, (not None) evaluates to True since the value None is False in a boolean context, so the expression becomes 'something' is True.

---

▶ A tic-tac-toe where X wins in the first attempt!

# Let's initialize a row
row = [""] * 3 #row i['', '', '']
# Let's make a board
board = [row] * 3

Output:

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

We didn't assign three "X"s, did we?

💡 Explanation:

When we initialize row variable, this visualization explains what happens in the memory

And when the board is initialized by multiplying the row, this is what happens inside the memory (each of the elements board[0], board[1] and board[2] is a reference to the same list referred by row)

We can avoid this scenario here by not using row variable to generate board. (Asked in this issue).

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

---

▶ Schrödinger's variable *

funcs = []
results = []
for x in range(7):
    def some_func():
        return x
    funcs.append(some_func)
    results.append(some_func())  # note the function call here

funcs_results = [func() for func in funcs]

Output (Python version):

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

The values of x were different in every iteration prior to appending some_func to funcs, but all the functions return 6 when they're evaluated after the loop completes.

>>> 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]

💡 Explanation:

• When defining a function inside a loop that uses the loop variable in its body, the loop function's closure is bound to the variable, not its value. The function looks up x in the surrounding context, rather than using the value of x at the time the function is created. So all of the functions use the latest value assigned to the variable for computation. We can see that it's using the x from the surrounding context (i.e. not a local variable) with:

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

Since x is a global value, we can change the value that the funcs will lookup and return by updating x:

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

• To get the desired behavior you can pass in the loop variable as a named variable to the function. Why does this work? Because this will define the variable inside the function's scope. It will no longer go to the surrounding (global) scope to look up the variables value but will create a local variable that stores the value of x at that point in time.

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

Output:

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

It is not longer using the x in the global scope:

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

---

▶ The chicken-egg problem *

1.

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

So which is the "ultimate" base class? There's more to the confusion by the way,

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

💡 Explanation

• type is a metaclass in Python.
• Everything is an object in Python, which includes classes as well as their objects (instances).
• class type is the metaclass of class object, and every class (including type) has inherited directly or indirectly from object.
• There is no real base class among object and type. The confusion in the above snippets is arising because we're thinking about these relationships (issubclass and isinstance) in terms of Python classes. The relationship between object and type can't be reproduced in pure python. To be more precise the following relationships can't be reproduced in pure Python,
  • class A is an instance of class B, and class B is an instance of class A.
  • class A is an instance of itself.
• These relationships between object and type (both being instances of each other as well as themselves) exist in Python because of "cheating" at the implementation level.

---

▶ Subclass relationships

Output:

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

The Subclass relationships were expected to be transitive, right? (i.e., if A is a subclass of B, and B is a subclass of C, the A should a subclass of C)

💡 Explanation:

• Subclass relationships are not necessarily transitive in Python. Anyone is allowed to define their own, arbitrary __subclasscheck__ in a metaclass.
• When issubclass(cls, Hashable) is called, it simply looks for non-Falsey "__hash__" method in cls or anything it inherits from.
• Since object is hashable, but list is non-hashable, it breaks the transitivity relation.
• More detailed explanation can be found here.

---

▶ ‫ برابری و هویت متدها

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

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

💡 Explanation:

• ‫ پیاده‌سازی تابع 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

💡 Explanation:

• ‫ تقدم عملگرها بر نحوه‌ی ارزیابی یک عبارت تأثیر می‌گذارد، و در پایتون، عملگر == تقدم بالاتری نسبت به عملگر 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
>>> # The following statements raise `SyntaxError`
>>> # 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) تغییر می‌دهد بدون اینکه شیء جدیدی ایجاد کند. بنابراین، تغییر ویژگی یک نمونه بر نمونه‌های دیگر و همچنین ویژگی کلاس تأثیر می‌گذارد.

---

▶ yielding None

some_iterable = ('a', 'b')

def some_func(val):
    return "something"

Output (<= 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']

💡 Explanation:

• This is a bug in CPython's handling of yield in generators and comprehensions.
• Source and explanation can be found here: https://stackoverflow.com/questions/32139885/yield-in-list-comprehensions-and-generator-expressions
• Related bug report: https://bugs.python.org/issue10544
• Python 3.8+ no longer allows yield inside list comprehension and will throw a SyntaxError.

---

▶ Yielding from... return! *

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 # expected: Two different keys-value pairs
{'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 را دریافت خواهید کرد.

---

▶ عملیات سرسختانه‌ی del

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] است؟

💡 Explanation:

• ‫ هیچ‌وقت ایده‌ی خوبی نیست که شیئی را که روی آن پیمایش می‌کنید تغییر دهید. روش درست این است که روی یک کپی از آن شیء پیمایش کنید؛ در این‌جا 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)]
# so far so good, let's zip the remaining
>>> 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
  

---

▶ ‫ گرفتن استثناها (Exceptions)

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

💡 ‫ توضیحات

• To add multiple Exceptions to the except clause, you need to pass them as parenthesized tuple as the first argument. The second argument is an optional name, which when supplied will bind the Exception instance that has been raised. Example,

  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
  

• Separating the exception from the variable with a comma is deprecated and does not work in Python 3; the correct way is to use as. Example,

  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']

# is same as
>>> 'a'.split(' ')
['a']

# but
>>> len(''.split())
0

# isn't the same as
>>> 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))

The midnight time is not printed.

💡 ‫ توضیحات:

Before Python 3.5, the boolean value for datetime.time object was considered to be False if it represented midnight in UTC. It is error-prone when using the if obj: syntax to check if the obj is null or some equivalent of "empty."

---

---

‫ بخش: گنجینه‌های پنهان!

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

▶ ‫ خب پایتون، می‌توانی کاری کنی پرواز کنم؟

‫ خب، بفرمایید

import antigravity

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

‫ 💡 توضیح:

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

---

▶ ‫ goto، ولی چرا؟

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

Wait, what's this? this is love ❤️

‫ خروجی:

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 بدون رخ دادن استثنا با موفقیت تکمیل شده است.

---

▶ Ellipsis *

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 ارسال شده است» تمایز قائل شوید).

---

▶ ‫ بی‌نهایت (Inpinity)

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

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

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

‫ 💡 توضیح:

• ‫ هش (hash) مقدار بی‌نهایت برابر با 10⁵ × π است.
• ‫ نکته جالب اینکه در پایتون ۳ هشِ مقدار float('-inf') برابر با «-10⁵ × π» است، در حالی که در پایتون ۲ برابر با «-10⁵ × e» است.

---

▶ ‫ بیایید خرابکاری کنیم

1.

class Yo(object):
    def __init__(self):
        self.__honey = True
        self.bro = True

‫ خروجی:

>>> Yo().bro
True
>>> Yo().__honey
AttributeError: 'Yo' object has no attribute '__honey'
>>> Yo()._Yo__honey
True

2.

class Yo(object):
    def __init__(self):
        # این بار بیایید چیزی متقارن را امتحان کنیم
        self.__honey__ = True
        self.bro = True

‫ خروجی:

>>> Yo().bro
True

>>> Yo()._Yo__honey__
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Yo' object has no attribute '_Yo__honey__'

چرا کد Yo()._Yo__honey کار کرد؟

3.

_A__variable = "Some value"

class A(object):
    def some_func(self):
        return __variable # هنوز در هیچ جا مقداردهی اولیه نشده است

‫ خروجی:

>>> A().__variable
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'A' object has no attribute '__variable'

>>> A().some_func()
'Some value'

‫ 💡 توضیح:

• ‫ تغییر نام برای جلوگیری از برخورد نام‌ها بین فضاهای نام مختلف استفاده می‌شود.
• ‫ در پایتون، مفسر نام‌های اعضای کلاس که با __ (دو آندرلاین که به عنوان "دندر" شناخته می‌شود) شروع می‌شوند و بیش از یک آندرلاین انتهایی ندارند را با اضافه کردن _NameOfTheClass در ابتدای آنها تغییر می‌دهد.
• ‫ بنابراین، برای دسترسی به ویژگی __honey در اولین قطعه کد، مجبور بودیم _Yo را به ابتدای آن اضافه کنیم، که از بروز تعارض با ویژگی با همان نام تعریف‌شده در هر کلاس دیگری جلوگیری می‌کند.
• ‫ اما چرا در دومین قطعه کد کار نکرد؟ زیرا تغییر نام، نام‌هایی که با دو آندرلاین خاتمه می‌یابند را شامل نمی‌شود.
• ‫ قطعه سوم نیز نتیجه تغییر نام بود. نام __variable در عبارت return __variable به _A__variable تغییر یافت، که همچنین همان نام متغیری است که در محدوده بیرونی تعریف کرده بودیم.
• ‫ همچنین، اگر نام تغییر یافته بیش از ۲۵۵ کاراکتر باشد، برش داده می‌شود.

---

---

‫ بخش: ظاهرها فریبنده‌اند!

▶ ‫ خطوط را رد می‌کند؟

‫ خروجی:

>>> value = 11
>>> valuе = 32
>>> value
11

‫ چی?

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

‫ 💡 توضیح

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

>>> ord('е') # حرف سیریلیک «е» (Ye)
1077
>>> ord('e') # حرف لاتین «e»، که در انگلیسی استفاده می‌شود و با صفحه‌کلید استاندارد تایپ می‌گردد
101
>>> 'е' == 'e'
False

>>> value = 42 # حرف لاتین e
>>> valuе = 23 # حرف سیریلیک «е»؛ مفسر پایتون نسخه ۲ در اینجا خطای `SyntaxError` ایجاد می‌کند
>>> value
42

‫ تابع داخلی ord()، کدپوینت یونیکد مربوط به یک نویسه را برمی‌گرداند. موقعیت‌های کدی متفاوت برای حرف سیریلیک «е» و حرف لاتین «e»، علت رفتار مثال بالا را توجیه می‌کنند.

---

▶ ‫ تله‌پورت کردن

# `pip install numpy` first.
import numpy as np

def energy_send(x):
    # مقداردهی اولیه یک آرایه numpy
    np.array([float(x)])

def energy_receive():
    # بازگرداندن یک آرایه‌ی خالی numpy
    return np.empty((), dtype=np.float).tolist()

‫ خروجی:

>>> energy_send(123.456)
>>> energy_receive()
123.456

‫ جایزه نوبل کجاست؟

‫ 💡 توضیح:

• ‫ توجه کنید که آرایه‌ی numpy ایجادشده در تابع energy_send برگردانده نشده است، بنابراین فضای حافظه‌ی آن آزاد شده و مجدداً قابل استفاده است.
• ‫ تابع numpy.empty() نزدیک‌ترین فضای حافظه‌ی آزاد را بدون مقداردهی مجدد برمی‌گرداند. این فضای حافظه معمولاً همان فضایی است که به‌تازگی آزاد شده است (البته معمولاً این اتفاق می‌افتد و نه همیشه).

---

▶ ‫ خب، یک جای کار مشکوک است...

def square(x):
    """
    یک تابع ساده برای محاسبه‌ی مربع یک عدد با استفاده از جمع.
    """
    sum_so_far = 0
    for counter in range(x):
        sum_so_far = sum_so_far + x
  return sum_so_far

‫ خروجی (پایتون 2.X):

>>> square(10)
10

‫ آیا این نباید ۱۰۰ باشد؟

‫ نکته: اگر نمی‌توانید این مشکل را بازتولید کنید، سعی کنید فایل mixed_tabs_and_spaces.py را از طریق شِل اجرا کنید.

‫ 💡 توضیح

• ‫ تب‌ها و فاصله‌ها (space) را با هم ترکیب نکنید! کاراکتری که دقیقاً قبل از دستور return آمده یک «تب» است، در حالی که در بقیۀ مثال، کد با مضربی از «۴ فاصله» تورفتگی دارد.

• ‫ نحوۀ برخورد پایتون با تب‌ها به این صورت است:

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

• ‫ بنابراین «تب» در آخرین خط تابع square با هشت فاصله جایگزین شده و به همین دلیل داخل حلقه قرار می‌گیرد.

• ‫ پایتون ۳ آنقدر هوشمند هست که چنین مواردی را به‌صورت خودکار با خطا اعلام کند.

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

  TabError: inconsistent use of tabs and spaces in indentation
  

---

---

بخش: متفرقه

‫ ▶ += سریع‌تر است

# استفاده از "+"، سه رشته:
>>> timeit.timeit("s1 = s1 + s2 + s3", setup="s1 = ' ' * 100000; s2 = ' ' * 100000; s3 = ' ' * 100000", number=100)
0.25748300552368164
# استفاده از "+="، سه رشته:
>>> timeit.timeit("s1 += s2 + s3", setup="s1 = ' ' * 100000; s2 = ' ' * 100000; s3 = ' ' * 100000", number=100)
0.012188911437988281

‫ 💡 توضیح:

• ‫ استفاده از += برای اتصال بیش از دو رشته سریع‌تر از + است، زیرا هنگام محاسبه رشته‌ی نهایی، رشته‌ی اول (به‌عنوان مثال s1 در عبارت s1 += s2 + s3) از بین نمی‌رود.

---

‫ ▶ بیایید یک رشته‌ی بزرگ بسازیم!

def add_string_with_plus(iters):
    s = ""
    for i in range(iters):
        s += "xyz"
    assert len(s) == 3*iters

def add_bytes_with_plus(iters):
    s = b""
    for i in range(iters):
        s += b"xyz"
    assert len(s) == 3*iters

def add_string_with_format(iters):
    fs = "{}"*iters
    s = fs.format(*(["xyz"]*iters))
    assert len(s) == 3*iters

def add_string_with_join(iters):
    l = []
    for i in range(iters):
        l.append("xyz")
    s = "".join(l)
    assert len(s) == 3*iters

def convert_list_to_string(l, iters):
    s = "".join(l)
    assert len(s) == 3*iters

‫ خروجی:

‫ اجرا شده در پوسته‌ی ipython با استفاده از %timeit برای خوانایی بهتر نتایج. ‫ همچنین می‌توانید از ماژول timeit در پوسته یا اسکریپت عادی پایتون استفاده کنید؛ نمونه‌ی استفاده در زیر آمده است: timeit.timeit('add_string_with_plus(10000)', number=1000, globals=globals())

>>> NUM_ITERS = 1000
>>> %timeit -n1000 add_string_with_plus(NUM_ITERS)
124 µs ± 4.73 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
>>> %timeit -n1000 add_bytes_with_plus(NUM_ITERS)
211 µs ± 10.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
>>> %timeit -n1000 add_string_with_format(NUM_ITERS)
61 µs ± 2.18 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
>>> %timeit -n1000 add_string_with_join(NUM_ITERS)
117 µs ± 3.21 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
>>> l = ["xyz"]*NUM_ITERS
>>> %timeit -n1000 convert_list_to_string(l, NUM_ITERS)
10.1 µs ± 1.06 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

‫ بیایید تعداد تکرارها را ۱۰ برابر افزایش دهیم.

>>> NUM_ITERS = 10000
>>> %timeit -n1000 add_string_with_plus(NUM_ITERS) # افزایش خطی در زمان اجرا
1.26 ms ± 76.8 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
>>> %timeit -n1000 add_bytes_with_plus(NUM_ITERS) # افزایش درجه دو (افزایش مربعی)
6.82 ms ± 134 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
>>> %timeit -n1000 add_string_with_format(NUM_ITERS) # افزایش خطی
645 µs ± 24.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
>>> %timeit -n1000 add_string_with_join(NUM_ITERS) # افزایش خطی
1.17 ms ± 7.25 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
>>> l = ["xyz"]*NUM_ITERS
>>> %timeit -n1000 convert_list_to_string(l, NUM_ITERS) # افزایش خطی
86.3 µs ± 2 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

💡 توضیحات

توضیحات

• ‫ برای اطلاعات بیشتر درباره‌ی timeit یا %timeit، می‌توانید به این لینک‌ها مراجعه کنید. این توابع برای اندازه‌گیری زمان اجرای قطعه‌کدها استفاده می‌شوند.

• ‫ برای تولید رشته‌های طولانی از + استفاده نکنید — در پایتون، نوع داده‌ی str تغییرناپذیر (immutable) است؛ بنابراین برای هر الحاق (concatenation)، رشته‌ی چپ و راست باید در رشته‌ی جدید کپی شوند. اگر چهار رشته‌ی ۱۰ حرفی را متصل کنید، به‌جای کپی ۴۰ کاراکتر، باید (10+10) + ((10+10)+10) + (((10+10)+10)+10) = 90 کاراکتر کپی کنید. این وضعیت با افزایش تعداد و طول رشته‌ها به‌صورت درجه دو (مربعی) بدتر می‌شود (که توسط زمان اجرای تابع add_bytes_with_plus تأیید شده است).

• ‫ بنابراین توصیه می‌شود از .format یا سینتکس % استفاده کنید (البته این روش‌ها برای رشته‌های بسیار کوتاه کمی کندتر از + هستند).

• ‫ اما بهتر از آن، اگر محتوای شما از قبل به‌شکل یک شیء قابل تکرار (iterable) موجود است، از دستور ''.join(iterable_object) استفاده کنید که بسیار سریع‌تر است.

• ‫ برخلاف تابع add_bytes_with_plus و به‌دلیل بهینه‌سازی‌های انجام‌شده برای عملگر += (که در مثال قبلی توضیح داده شد)، تابع add_string_with_plus افزایشی درجه دو در زمان اجرا نشان نداد. اگر دستور به‌صورت s = s + "x" + "y" + "z" بود (به‌جای s += "xyz")، افزایش زمان اجرا درجه دو می‌شد.

  def add_string_with_plus(iters):
      s = ""
      for i in range(iters):
          s = s + "x" + "y" + "z"
      assert len(s) == 3*iters
  
  >>> %timeit -n100 add_string_with_plus(1000)
  388 µs ± 22.4 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
  >>> %timeit -n100 add_string_with_plus(10000) # افزایش درجه دو در زمان اجرا
  9 ms ± 298 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
  

• ‫ وجود راه‌های متعدد برای قالب‌بندی و ایجاد رشته‌های بزرگ تا حدودی در تضاد با ذِن پایتون است که می‌گوید:

  ‫ «باید یک راه — و ترجیحاً فقط یک راه — واضح برای انجام آن وجود داشته باشد.»

---

▶ ‫ کُند کردن جستجوها در dict *

some_dict = {str(i): 1 for i in range(1_000_000)}
another_dict = {str(i): 1 for i in range(1_000_000)}

‫ خروجی:

>>> %timeit some_dict['5']
28.6 ns ± 0.115 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
>>> some_dict[1] = 1
>>> %timeit some_dict['5']
37.2 ns ± 0.265 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

>>> %timeit another_dict['5']
28.5 ns ± 0.142 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
>>> another_dict[1]  # تلاش برای دسترسی به کلیدی که وجود ندارد
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 1
>>> %timeit another_dict['5']
38.5 ns ± 0.0913 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

چرا جستجوهای یکسان کندتر می‌شوند؟

‫ 💡 توضیح:

• ‫ در CPython یک تابع عمومی برای جستجوی کلید در دیکشنری‌ها وجود دارد که از تمام انواع کلیدها (str، int و هر شیء دیگر) پشتیبانی می‌کند؛ اما برای حالت متداولی که تمام کلیدها از نوع str هستند، یک تابع بهینه‌شده‌ی اختصاصی نیز وجود دارد.
• ‫ تابع اختصاصی (که در کد منبع CPython با نام lookdict_unicode شناخته می‌شود) فرض می‌کند که تمام کلیدهای موجود در دیکشنری (از جمله کلیدی که در حال جستجوی آن هستید) رشته (str) هستند و برای مقایسه‌ی کلیدها، به‌جای فراخوانی متد __eq__، از مقایسه‌ی سریع‌تر و ساده‌تر رشته‌ای استفاده می‌کند.
• ‫ اولین باری که یک دیکشنری (dict) با کلیدی غیر از str فراخوانی شود، این حالت تغییر می‌کند و جستجوهای بعدی از تابع عمومی استفاده خواهند کرد.
• ‫ این فرایند برای آن نمونه‌ی خاص از دیکشنری غیرقابل بازگشت است و حتی لازم نیست کلید موردنظر در دیکشنری موجود باشد. به همین دلیل است که حتی تلاش ناموفق برای دسترسی به کلیدی ناموجود نیز باعث ایجاد همین تأثیر (کند شدن جستجو) می‌شود.

‫ ▶ حجیم کردن دیکشنری نمونه‌ها (instance dicts) *

import sys

class SomeClass:
    def __init__(self):
        self.some_attr1 = 1
        self.some_attr2 = 2
        self.some_attr3 = 3
        self.some_attr4 = 4


def dict_size(o):
    return sys.getsizeof(o.__dict__)

‫ خروجی: (پایتون ۳.۸؛ سایر نسخه‌های پایتون ۳ ممکن است کمی متفاوت باشند)

>>> o1 = SomeClass()
>>> o2 = SomeClass()
>>> dict_size(o1)
104
>>> dict_size(o2)
104
>>> del o1.some_attr1
>>> o3 = SomeClass()
>>> dict_size(o3)
232
>>> dict_size(o1)
232

‫ بیایید دوباره امتحان کنیم... در یک مفسر (interpreter) جدید:

>>> o1 = SomeClass()
>>> o2 = SomeClass()
>>> dict_size(o1)
104  # همان‌طور که انتظار می‌رفت
>>> o1.some_attr5 = 5
>>> o1.some_attr6 = 6
>>> dict_size(o1)
360
>>> dict_size(o2)
272
>>> o3 = SomeClass()
>>> dict_size(o3)
232

‫ چه چیزی باعث حجیم‌شدن این دیکشنری‌ها می‌شود؟ و چرا اشیاء تازه ساخته‌شده نیز حجیم هستند؟

💡 توضیح:

• ‫ در CPython، امکان استفاده‌ی مجدد از یک شیء «کلیدها» (keys) در چندین دیکشنری وجود دارد. این ویژگی در PEP 412 معرفی شد تا مصرف حافظه کاهش یابد، به‌ویژه برای دیکشنری‌هایی که به نمونه‌ها (instances) تعلق دارند و معمولاً کلیدها (نام صفات نمونه‌ها) بین آن‌ها مشترک است.
• ‫ این بهینه‌سازی برای دیکشنری‌های نمونه‌ها کاملاً شفاف و خودکار است؛ اما اگر بعضی فرضیات نقض شوند، غیرفعال می‌شود.
• ‫ دیکشنری‌هایی که کلیدهایشان به اشتراک گذاشته شده باشد، از حذف کلید پشتیبانی نمی‌کنند؛ بنابراین اگر صفتی از یک نمونه حذف شود، دیکشنریِ آن نمونه «غیر مشترک» (unshared) شده و این قابلیت اشتراک‌گذاری کلیدها برای تمام نمونه‌هایی که در آینده از آن کلاس ساخته می‌شوند، غیرفعال می‌گردد.
• ‫ همچنین اگر اندازه‌ی دیکشنری به‌علت اضافه‌شدن کلیدهای جدید تغییر کند (resize شود)، اشتراک‌گذاری کلیدها تنها زمانی ادامه می‌یابد که فقط یک دیکشنری در حال استفاده از آن‌ها باشد (این اجازه می‌دهد در متد __init__ برای اولین نمونه‌ی ساخته‌شده، صفات متعددی تعریف کنید بدون آن‌که اشتراک‌گذاری کلیدها از بین برود). اما اگر چند نمونه همزمان وجود داشته باشند و تغییر اندازه‌ی دیکشنری رخ دهد، قابلیت اشتراک‌گذاری کلیدها برای نمونه‌های بعدی همان کلاس غیرفعال خواهد شد. زیرا CPython دیگر نمی‌تواند مطمئن باشد که آیا نمونه‌های بعدی دقیقاً از مجموعه‌ی یکسانی از صفات استفاده خواهند کرد یا خیر.
• ‫ نکته‌ای کوچک برای کاهش مصرف حافظه‌ی برنامه: هرگز صفات نمونه‌ها را حذف نکنید و حتماً تمام صفات را در متد __init__ تعریف و مقداردهی اولیه کنید!

‫ ▶ موارد جزئی *

• ‫ متد join() عملیاتی مربوط به رشته (str) است، نه لیست (list). (در نگاه اول کمی برخلاف انتظار است.)

  ** ‫💡 توضیح:** اگر join() به‌عنوان متدی روی رشته پیاده‌سازی شود، می‌تواند روی هر شیء قابل پیمایش (iterable) از جمله لیست، تاپل و هر نوع تکرارشونده‌ی دیگر کار کند. اگر به‌جای آن روی لیست تعریف می‌شد، باید به‌طور جداگانه برای هر نوع دیگری نیز پیاده‌سازی می‌شد. همچنین منطقی نیست که یک متد مختص رشته روی یک شیء عمومی مانند list پیاده شود.

• ‫ تعدادی عبارت با ظاهری عجیب اما از نظر معنا صحیح:

  • ‫ عبارت [] = () از نظر معنایی صحیح است (باز کردن یا unpack کردن یک تاپل خالی درون یک لیست خالی).
  • ‫ عبارت 'a'[0][0][0][0][0] نیز از نظر معنایی صحیح است، زیرا پایتون برخلاف زبان‌هایی که از C منشعب شده‌اند، نوع داده‌ای جداگانه‌ای برای کاراکتر ندارد. بنابراین انتخاب یک کاراکتر از یک رشته، منجر به بازگشت یک رشته‌ی تک‌کاراکتری می‌شود.
  • ‫ عبارات 3 --0-- 5 == 8 و --5 == 5 هر دو از لحاظ معنایی درست بوده و مقدارشان برابر True است.

• ‫ با فرض اینکه a یک عدد باشد، عبارات ++a و --a هر دو در پایتون معتبر هستند؛ اما رفتاری مشابه با عبارات مشابه در زبان‌هایی مانند C، ++C یا جاوا ندارند.

  >>> a = 5
  >>> a
  5
  >>> ++a
  5
  >>> --a
  5
  

  ** ‫ 💡 توضیح:**

  • ‫ در گرامر پایتون عملگری به‌نام ++ وجود ندارد. در واقع ++ دو عملگر + جداگانه است.
  • ‫ عبارت ++a به‌شکل +(+a) تفسیر می‌شود که معادل a است. به‌همین ترتیب، خروجی عبارت --a نیز قابل توجیه است.
  • ‫ این تاپیک در StackOverflow دلایل نبودن عملگرهای افزایش (++) و کاهش (--) در پایتون را بررسی می‌کند.

• ‫ احتمالاً با عملگر Walrus (گراز دریایی) در پایتون آشنا هستید؛ اما تا به حال در مورد عملگر Space-invader (مهاجم فضایی) شنیده‌اید؟

  >>> a = 42
  >>> a -=- 1
  >>> a
  43
  

‫ از آن به‌عنوان جایگزینی برای عملگر افزایش (increment)، در ترکیب با یک عملگر دیگر استفاده می‌شود.

>>> a +=+ 1
>>> a
>>> 44

‫ 💡 توضیح: این شوخی از توییت Raymond Hettinger برگرفته شده است. عملگر «مهاجم فضایی» در واقع همان عبارت بدفرمت‌شده‌ی a -= (-1) است که معادل با a = a - (- 1) می‌باشد. حالت مشابهی برای عبارت a += (+ 1) نیز وجود دارد.

• ‫ پایتون یک عملگر مستندنشده برای استلزام معکوس (converse implication) دارد.

  >>> False ** False == True
  True
  >>> False ** True == False
  True
  >>> True ** False == True
  True
  >>> True ** True == True
  True
  

  ‫ 💡 توضیح: اگر مقادیر False و True را به‌ترتیب با اعداد ۰ و ۱ جایگزین کرده و محاسبات را انجام دهید، جدول درستی حاصل، معادل یک عملگر استلزام معکوس خواهد بود. (منبع)

• ‫ حالا که صحبت از عملگرها شد، عملگر @ نیز برای ضرب ماتریسی در پایتون وجود دارد (نگران نباشید، این بار واقعی است).

  >>> import numpy as np
  >>> np.array([2, 2, 2]) @ np.array([7, 8, 8])
  46
  

  ‫ 💡 توضیح: عملگر @ در پایتون ۳٫۵ با در نظر گرفتن نیازهای جامعه علمی اضافه شد. هر شی‌ای می‌تواند متد جادویی __matmul__ را بازنویسی کند تا رفتار این عملگر را مشخص نماید.

• ‫ از پایتون ۳٫۸ به بعد می‌توانید از نحو متداول f-string مانند f'{some_var=}' برای اشکال‌زدایی سریع استفاده کنید. مثال,

  >>> some_string = "wtfpython"
  >>> f'{some_string=}'
  "some_string='wtfpython'"
  

• ‫ پایتون برای ذخیره‌سازی متغیرهای محلی در توابع از ۲ بایت استفاده می‌کند. از نظر تئوری، این به معنای امکان تعریف حداکثر ۶۵۵۳۶ متغیر در یک تابع است. با این حال، پایتون راهکار مفیدی ارائه می‌کند که می‌توان با استفاده از آن بیش از ۲^۱۶ نام متغیر را ذخیره کرد. کد زیر نشان می‌دهد وقتی بیش از ۶۵۵۳۶ متغیر محلی تعریف شود، در پشته (stack) چه اتفاقی رخ می‌دهد (هشدار: این کد تقریباً ۲^۱۸ خط متن چاپ می‌کند، بنابراین آماده باشید!):

  import dis
  exec("""
  def f():
     """ + """
     """.join(["X" + str(x) + "=" + str(x) for x in range(65539)]))
  
  f()
  
  print(dis.dis(f))
  

• ‫ چندین رشته (Thread) در پایتون، کدِ پایتونی شما را به‌صورت همزمان اجرا نمی‌کنند (بله، درست شنیدید!). شاید به نظر برسد که ایجاد چندین رشته و اجرای همزمان آن‌ها منطقی است، اما به دلیل وجود قفل مفسر سراسری (GIL) در پایتون، تمام کاری که انجام می‌دهید این است که رشته‌هایتان به‌نوبت روی یک هسته اجرا می‌شوند. رشته‌ها در پایتون برای وظایفی مناسب هستند که عملیات I/O دارند، اما برای رسیدن به موازی‌سازی واقعی در وظایف پردازشی سنگین (CPU-bound)، بهتر است از ماژول multiprocessing در پایتون استفاده کنید.

• ‫ گاهی اوقات، متد print ممکن است مقادیر را فوراً چاپ نکند. برای مثال،

  # File some_file.py
  import time
  
  print("wtfpython", end="_")
  time.sleep(3)
  

  ‫ این کد عبارت wtfpython را به دلیل آرگومان end پس از ۳ ثانیه چاپ می‌کند؛ چرا که بافر خروجی تنها پس از رسیدن به کاراکتر \n یا در زمان اتمام اجرای برنامه تخلیه می‌شود. برای تخلیه‌ی اجباری بافر می‌توانید از آرگومان flush=True استفاده کنید.

• ‫ برش لیست‌ها (List slicing) با اندیس‌های خارج از محدوده، خطایی ایجاد نمی‌کند.

  >>> some_list = [1, 2, 3, 4, 5]
  >>> some_list[111:]
  []
  

• ‫ برش زدن (slicing) یک شئ قابل پیمایش (iterable) همیشه یک شئ جدید ایجاد نمی‌کند. به‌عنوان مثال،

  >>> some_str = "wtfpython"
  >>> some_list = ['w', 't', 'f', 'p', 'y', 't', 'h', 'o', 'n']
  >>> some_list is some_list[:] # False expected because a new object is created.
  False
  >>> some_str is some_str[:] # True because strings are immutable, so making a new object is of not much use.
  True
  

• ‫ در پایتون ۳، فراخوانی int('١٢٣٤٥٦٧٨٩') مقدار 123456789 را برمی‌گرداند. در پایتون، نویسه‌های ده‌دهی (Decimal characters) شامل تمام ارقامی هستند که می‌توانند برای تشکیل اعداد در مبنای ده استفاده شوند؛ به‌عنوان مثال نویسه‌ی U+0660 که همان رقم صفر عربی-هندی است. اینجا داستان جالبی درباره این رفتار پایتون آمده است.

• ‫ از پایتون ۳ به بعد، می‌توانید برای افزایش خوانایی، اعداد را با استفاده از زیرخط (_) جدا کنید.

  >>> six_million = 6_000_000
  >>> six_million
  6000000
  >>> hex_address = 0xF00D_CAFE
  >>> hex_address
  4027435774
  

• ‫ عبارت 'abc'.count('') == 4 مقدار True برمی‌گرداند. در اینجا یک پیاده‌سازی تقریبی از متد count آورده شده که این موضوع را شفاف‌تر می‌کند:

  def count(s, sub):
      result = 0
      for i in range(len(s) + 1 - len(sub)):
          result += (s[i:i + len(sub)] == sub)
      return result
  

‫ این رفتار به این دلیل است که زیررشته‌ی خالی ('') با برش‌هایی (slices) به طول صفر در رشته‌ی اصلی مطابقت پیدا می‌کند.

---

---

‫ مشارکت

‫چند روشی که می‌توانید در wtfpython مشارکت داشته باشید:

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

‫ برای اطلاعات بیشتر CONTRIBUTING.md را مشاهده کنید. برای بحث درباره موارد مختلف می‌توانید یک مشکل جدید ایجاد کنید.

‫ نکته: لطفاً برای درخواست بک‌لینک (backlink) تماس نگیرید. هیچ لینکی اضافه نمی‌شود مگر اینکه ارتباط بسیار زیادی با پروژه داشته باشد.

‫ تقدیر و تشکر

‫ ایده و طراحی این مجموعه ابتدا از پروژه عالی wtfjs توسط Denys Dovhan الهام گرفته شد. حمایت فوق‌العاده‌ جامعه پایتون باعث شد پروژه به شکل امروزی خود درآید.

‫ چند لینک جالب!

• https://www.youtube.com/watch?v=sH4XF6pKKmk
• https://www.reddit.com/r/Python/comments/3cu6ej/what_are_some_wtf_things_about_python
• https://sopython.com/wiki/Common_Gotchas_In_Python
• https://stackoverflow.com/questions/530530/python-2-x-gotchas-and-landmines
• https://stackoverflow.com/questions/1011431/common-pitfalls-in-python
• https://www.python.org/doc/humor/
• https://github.com/cosmologicon/pywat#the-undocumented-converse-implication-operator
• https://github.com/wemake-services/wemake-python-styleguide/search?q=wtfpython&type=Issues
• WFTPython discussion threads on Hacker News and Reddit.

‫ 🎓 مجوز

© Satwik Kansal

‫ دوستانتان را هم شگفت‌زده کنید!

‫ اگر از wtfpython خوشتان آمد، می‌توانید با این لینک‌های سریع آن را با دوستانتان به اشتراک بگذارید:

‫ توییتر | لینکدین | فیسبوک

‫ آیا به یک نسخه pdf نیاز دارید؟

‫ من چند درخواست برای نسخه PDF (و epub) کتاب wtfpython دریافت کرده‌ام. برای دریافت این نسخه‌ها به محض آماده شدن، می‌توانید اطلاعات خود را اینجا وارد کنید.

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