ترجمه‌ها: [انگلیسی English](https://github.com/satwikkansal/wtfpython) | [چینی 中文](https://github.com/leisurelicht/wtfpython-cn) | [ویتنامی Tiếng Việt](https://github.com/vuduclyunitn/wtfptyhon-vi) | [اسپانیایی Español](https://web.archive.org/web/20220511161045/https://github.com/JoseDeFreitas/wtfpython-es) | [کره‌ای 한국어](https://github.com/buttercrab/wtfpython-ko) | [روسی Русский](https://github.com/satwikkansal/wtfpython/tree/master/translations/ru-russian) | [آلمانی Deutsch](https://github.com/BenSt099/wtfpython) | [Persian فارسی](https://github.com/satwikkansal/wtfpython/tree/master/translations/fa-farsi) | [اضافه کردن ترجمه](https://github.com/satwikkansal/wtfpython/issues/new?title=Add%20translation%20for%20[LANGUAGE]&body=Expected%20time%20to%20finish:%20[X]%20weeks.%20I%27ll%20start%20working%20on%20it%20from%20[Y].)
حالت‌های دیگر: [وبسایت تعاملی](https://wtfpython-interactive.vercel.app) | [دفترچه تعاملی](https://colab.research.google.com/github/satwikkansal/wtfpython/blob/master/irrelevant/wtf.ipynb)
پایتون، یه زبان زیبا طراحی شده، سطح بالا و مبتنی بر مفسره که قابلیت‌های بسیاری برای راحتی ما برنامه‌نویس‌ها فراهم میکنه.
ولی گاهی اوقات قطعه‌کدهایی رو می‌بینیم که تو نگاه اول خروجی‌هاشون واضح نیست.
این یه پروژه باحاله که سعی داریم توش توضیح بدیم که پشت پرده یه سری قطعه‌کدهای غیرشهودی و قابلیت‌های کمتر شناخته شده پایتون
چه خبره.
درحالی که بعضی از مثال‌هایی که قراره تو این سند ببینید واقعا عجیب و غریب نیستند ولی بخش‌های جالبی از پایتون رو ظاهر میکنند که
ممکنه شما از وجودشون بی‌خبر باشید. به نظرم این شیوه جالبیه برای یادگیری جزئیات داخلی یه زبان برنامه نویسی و باور دارم که
برای شما هم جالب خواهد بود.
اگه شما یه پایتون کار سابقه‌دار هستید، می‌تونید از این فرصت به عنوان یه چالش برای خودتون استفاده کنید تا بیشتر مثالها رو
تو تلاش اول حدس بزنید. ممکنه شما بعضی از این مثالها رو قبلا تجربه کرده باشید و من خاطراتشون رو در این سند براتون زنده
کرده باشم! :sweat_smile:
پ.ن: اگه شما قبلا این سند رو خوندید، می‌تونید تغییرات جدید رو در بخش انتشار (فعلا در [اینجا](https://github.com/satwikkansal/wtfpython/releases/)) مطالعه کنید
(مثال‌هایی که کنارشون علامت ستاره دارند، در آخرین ویرایش اضافه شده‌اند).
پس، بزن بریم...
# فهرست مطالب
- [فهرست مطالب](#فهرست-مطالب)
- [ساختار مثالها](#ساختار-مثالها)
- [استفاده](#استفاده)
- [👀 مثالها](#-مثالها)
- [بخش: ذهن خود را به چالش بکشید!](#بخش-ذهن-خود-را-به-چالش-بکشید)
- [◀ اول از همه! \*](#-اول-از-همه-)
- [💡 توضیح](#-توضیح)
- [◀ بعضی وقتها رشتهها میتوانند دردسرساز شوند](#-بعضی-وقتها-رشتهها-میتوانند-دردسرساز-شوند)
- [💡 توضیح:](#-توضیح-1)
- [◀ مراقب عملیاتهای زنجیرهای باشید](#-مراقب-عملیاتهای-زنجیرهای-باشید)
- [💡 توضیح:](#-توضیح-2)
- [◀ چطور از عملگر `is` استفاده نکنیم](#-چطور-از-عملگر-is-استفاده-نکنیم)
- [💡 توضیح:](#-توضیح-3)
- [◀ کلیدهای هش](#-کلیدهای-هش)
- [💡 توضیح](#-توضیح-4)
- [◀ در عمق وجود همه ما یکسان هستیم](#-در-عمق-وجود-همه-ما-یکسان-هستیم)
- [💡 توضیح:](#-توضیح-5)
- [◀ بینظمی در خود نظم \*](#-بینظمی-در-خود-نظم-)
- [💡 توضیح:](#-توضیح-6)
- [💡 توضیح:](#-توضیح-7)
- [◀ برای چی؟](#-برای-چی)
- [💡 توضیح:](#-توضیح-8)
- [◀ اختلاف زمانی در محاسبه](#-اختلاف-زمانی-در-محاسبه)
- [💡 توضیح](#-توضیح-9)
- [◀ هر گردی، گردو نیست](#-هر-گردی-گردو-نیست)
- [💡 توضیح](#-توضیح-10)
- [◀ یک بازی دوز که توش X همون اول برنده میشه!](#-یک-بازی-دوز-که-توش-x-همون-اول-برنده-میشه)
- [💡 توضیح:](#-توضیح-11)
- [◀ متغیر شرودینگر \*](#-متغیر-شرودینگر-)
- [💡 توضیح:](#-توضیح-12)
- [◀ اول مرغ بوده یا تخم مرغ؟ \*](#-اول-مرغ-بوده-یا-تخم-مرغ-)
- [💡 توضیح](#-توضیح-13)
- [◀ روابط بین زیرمجموعه کلاسها](#-روابط-بین-زیرمجموعه-کلاسها)
- [💡 توضیح:](#-توضیح-14)
- [◀ برابری و هویت متدها](#-برابری-و-هویت-متدها)
- [💡 توضیح](#-توضیح-15)
- [◀ آل-ترو-یشن \*](#-آل-ترو-یشن-)
- [💡 توضیحات:](#-توضیحات)
- [💡 توضیح:](#-توضیح-16)
- [◀ رشتهها و بکاسلشها](#-رشتهها-و-بکاسلشها)
- [💡 توضیح:](#-توضیح-17)
- [◀ گره نیست، نَه!](#-گره-نیست-نَه)
- [💡 توضیح:](#-توضیح-18)
- [◀ رشتههای نیمه سهنقلقولی](#-رشتههای-نیمه-سهنقلقولی)
- [💡 توضیح:](#-توضیح-19)
- [◀ مشکل بولین ها چیست؟](#-مشکل-بولین-ها-چیست)
- [💡 توضیح:](#-توضیح-20)
- [◀ متغیرهای کلاس و متغیرهای نمونه](#-متغیرهای-کلاس-و-متغیرهای-نمونه)
- [💡 توضیح:](#-توضیح-21)
- [◀ واگذار کردن None](#-واگذار-کردن-none)
- [💡 توضیح:](#-توضیح-22)
- [◀ بازگرداندن با استفاده از `yield from`!](#-بازگرداندن-با-استفاده-از-yield-from)
- [💡 توضیح:](#-توضیح-23)
- [◀ بازتابناپذیری \*](#-بازتابناپذیری-)
- [💡 توضیح:](#-توضیح-24)
- [◀ تغییر دادن اشیای تغییرناپذیر!](#-تغییر-دادن-اشیای-تغییرناپذیر)
- [💡 توضیح:](#-توضیح-25)
- [◀ متغیری که از اسکوپ بیرونی ناپدید میشود](#-متغیری-که-از-اسکوپ-بیرونی-ناپدید-میشود)
- [💡 توضیح:](#-توضیح-26)
- [◀ تبدیل اسرارآمیز نوع کلید](#-تبدیل-اسرارآمیز-نوع-کلید)
- [💡 توضیح:](#-توضیح-27)
- [◀ ببینیم میتوانید این را حدس بزنید؟](#-ببینیم-میتوانید-این-را-حدس-بزنید)
- [💡 توضیح:](#-توضیح-28)
- [◀ از حد مجاز برای تبدیل رشته به عدد صحیح فراتر میرود](#-از-حد-مجاز-برای-تبدیل-رشته-به-عدد-صحیح-فراتر-میرود)
- [💡 توضیح:](#-توضیح-29)
- [بخش: شیبهای لغزنده](#بخش-شیبهای-لغزنده)
- [◀ تغییر یک دیکشنری هنگام پیمایش روی آن](#-تغییر-یک-دیکشنری-هنگام-پیمایش-روی-آن)
- [💡 توضیح:](#-توضیح-30)
- [◀ عملیات سرسختانهی `del`](#-عملیات-سرسختانهی-del)
- [💡 توضیح:](#-توضیح-31)
- [◀ متغیری که از حوزه خارج است](#-متغیری-که-از-حوزه-خارج-است)
- [💡 توضیح:](#-توضیح-32)
- [◀ حذف المانهای لیست در حین پیمایش](#-حذف-المانهای-لیست-در-حین-پیمایش)
- [💡 توضیح:](#-توضیح-33)
- [◀ زیپِ دارای اتلاف برای پیمایشگرها \*](#-زیپِ-دارای-اتلاف-برای-پیمایشگرها-)
- [💡 توضیح:](#-توضیح-34)
- [◀ نشت کردن متغیرهای حلقه!](#-نشت-کردن-متغیرهای-حلقه)
- [💡 توضیح:](#-توضیح-35)
- [◀ مراقب آرگومانهای تغییرپذیر پیشفرض باشید!](#-مراقب-آرگومانهای-تغییرپذیر-پیشفرض-باشید)
- [💡 توضیح:](#-توضیح-36)
- [◀ گرفتن استثناها (Exceptions)](#-گرفتن-استثناها-exceptions)
- [💡 توضیح](#-توضیح-37)
- [◀ عملوندهای یکسان، داستانی متفاوت!](#-عملوندهای-یکسان-داستانی-متفاوت)
- [💡 توضیح:](#-توضیح-38)
- [◀ تفکیک نامها با نادیده گرفتن حوزهی کلاس](#-تفکیک-نامها-با-نادیده-گرفتن-حوزهی-کلاس)
- [💡 توضیح](#-توضیح-39)
- [◀ گرد کردن به روش بانکدار \*](#-گرد-کردن-به-روش-بانکدار-)
- [💡 توضیح:](#-توضیح-40)
- [◀ سوزنهایی در انبار کاه \*](#-سوزنهایی-در-انبار-کاه-)
- [💡 توضیح:](#-توضیح-41)
- [◀ تقسیمها \*](#-تقسیمها-)
- [💡 توضیح:](#-توضیح-42)
- [◀ واردسازیهای عمومی \*](#-واردسازیهای-عمومی-)
- [💡 توضیح:](#-توضیح-43)
- [◀ همه چیز مرتب شده؟ \*](#-همه-چیز-مرتب-شده-)
- [💡 توضیح:](#-توضیح-44)
- [◀ زمان نیمهشب وجود ندارد؟](#-زمان-نیمهشب-وجود-ندارد)
- [💡 توضیح:](#-توضیح-45)
- [بخش: گنجینههای پنهان!](#بخش-گنجینههای-پنهان)
- [◀ خب پایتون، میتوانی کاری کنی پرواز کنم؟](#-خب-پایتون-میتوانی-کاری-کنی-پرواز-کنم)
- [💡 توضیح:](#-توضیح-46)
- [◀ `goto`، ولی چرا؟](#-goto-ولی-چرا)
- [💡 توضیح:](#-توضیح-47)
- [◀ خودتان را آماده کنید!](#-خودتان-را-آماده-کنید)
- [💡 توضیح:](#-توضیح-48)
- [◀ بیایید با «عمو زبان مهربان برای همیشه» آشنا شویم](#-بیایید-با-عمو-زبان-مهربان-برای-همیشه-آشنا-شویم)
- [💡 توضیح:](#-توضیح-49)
- [◀ حتی پایتون هم میداند که عشق پیچیده است](#-حتی-پایتون-هم-میداند-که-عشق-پیچیده-است)
- [💡 توضیح:](#-توضیح-50)
- [◀ بله، این واقعاً وجود دارد!](#-بله-این-واقعاً-وجود-دارد)
- [💡 توضیح:](#-توضیح-51)
- [◀ عملگر Ellipsis \*](#-عملگر-ellipsis-)
- [💡توضیح](#توضیح)
- [◀ بینهایت (`Inpinity`)](#-بینهایت-inpinity)
- [💡 توضیح:](#-توضیح-52)
- [◀ بیایید خرابکاری کنیم](#-بیایید-خرابکاری-کنیم)
- [💡 توضیح:](#-توضیح-53)
- [بخش: ظاهرها فریبندهاند!](#بخش-ظاهرها-فریبندهاند)
- [◀ خطوط را رد میکند؟](#-خطوط-را-رد-میکند)
- [💡 توضیح](#-توضیح-54)
- [◀ تلهپورت کردن](#-تلهپورت-کردن)
- [💡 توضیح:](#-توضیح-55)
- [◀ خب، یک جای کار مشکوک است...](#-خب-یک-جای-کار-مشکوک-است)
- [💡 توضیح](#-توضیح-56)
- [بخش: متفرقه](#بخش-متفرقه)
- [◀ `+=` سریعتر است](#--سریعتر-است)
- [💡 توضیح:](#-توضیح-57)
- [◀ بیایید یک رشتهی بزرگ بسازیم!](#-بیایید-یک-رشتهی-بزرگ-بسازیم)
- [💡 توضیح](#-توضیح-58)
- [◀ کُند کردن جستجوها در `dict` \*](#-کُند-کردن-جستجوها-در-dict-)
- [💡 توضیح:](#-توضیح-59)
- [◀ حجیم کردن دیکشنری نمونهها (`instance dicts`) \*](#-حجیم-کردن-دیکشنری-نمونهها-instance-dicts-)
- [💡 توضیح:](#-توضیح-60)
- [◀ موارد جزئی \*](#-موارد-جزئی-)
- [مشارکت](#مشارکت)
- [تقدیر و تشکر](#تقدیر-و-تشکر) - [چند لینک جالب!](#چند-لینک-جالب)
- [🎓 مجوز](#-مجوز)
- [دوستانتان را هم شگفتزده کنید!](#دوستانتان-را-هم-شگفتزده-کنید)
- [آیا به یک نسخه pdf نیاز دارید؟](#آیا-به-یک-نسخه-pdf-نیاز-دارید)
# ساختار مثالها
همه مثالها به صورت زیر ساخته می‌شوند:
> ### ◀ یه اسم خوشگل
>
> ```py
> # راه اندازی کد
> # آماده سازی برای جادو...
> ```
>
> **خروجی (نسخه(های) پایتون):**
>
> ```py
> >>> triggering_statement
> یه خروجی غیرمنتظره
> ```
>
> (دلخواه): توضیح یک‌خطی خروجی غیرمنتظره
>
> #### 💡 توضیح:
>
> - توضیح کوتاه درمورد اینکه چی داره اتفاق میافته و چرا.
>
> ```py
> # راه اندازی کد
> # مثال‌های بیشتر برای شفاف سازی (در صورت نیاز)
> ```
>
> **خروجی (نسخه(های) پایتون):**
>
> ```py
> >>> trigger # یک مثال که رونمایی از جادو رو راحت‌تر میکنه
> # یک خروجی توجیه شده و واضح
> ```
**توجه:** همه مثالها در برنامه مفسر تعاملی پایتون نسخه
۳.۵.۲ آزمایش شده‌اند و باید در همه نسخه‌های پایتون کار
کنند مگراینکه به صورت جداگانه و به طور واضح نسخه مخصوص
پایتون قبل از خروجی ذکر شده باشد.
# استفاده
یه راه خوب برای بیشتر بهره بردن، به نظرم، اینه که مثالها رو به ترتیب متوالی بخونید و برای هر مثال:
- کد ابتدایی برای راه اندازی مثال رو با دقت بخونید. اگه شما یه پایتون کار سابقه‌دار باشید، با موفقیت بیشتر اوقات اتفاق بعدی رو پیش‌بینی می‌کنید.
- قطعه خروجی رو بخونید و
- بررسی کنید که آیا خروجی‌ها همونطور که انتظار دارید هستند.
- مطمئین بشید که دقیقا دلیل اینکه خروجی اون طوری هست رو می‌دونید.
- اگه نمی‌دونید (که کاملا عادیه و اصلا بد نیست)، یک نفس عمیق بکشید و توضیحات رو بخونید (و اگه نفهمیدید، داد بزنید! و [اینجا](https://github.com/emargi/wtfpython/issues/new) درموردش حرف بزنید).
- اگه می‌دونید، به افتخار خودتون یه دست محکم بزنید و برید سراغ مثال بعدی.
---
# 👀 مثالها
## بخش: ذهن خود را به چالش بکشید!
### ◀ اول از همه! \*
به دلایلی، عملگر "Walrus" (`:=`) که در نسخه ۳.۸ پایتون معرفی شد، خیلی محبوب شده. بیاید بررسیش کنیم.
1\.
```py
# Python version 3.8+
>>> a = "wtf_walrus"
>>> a
'wtf_walrus'
>>> a := "wtf_walrus"
File "", line 1
a := "wtf_walrus"
^
SyntaxError: invalid syntax
>>> (a := "wtf_walrus") # ولی این کار میکنه
'wtf_walrus'
>>> a
'wtf_walrus'
```
2 \.
```py
# 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 "", line 1
(a, b = 16, 19)
^
SyntaxError: invalid syntax
>>> (a, b := 16, 19) # این یه تاپل ۳تایی چاپ میکنه رو صفحه
(6, 16, 19)
>>> a # هنوز تغییر نکرده؟
6
>>> b
16
```
#### 💡 توضیح
**مرور سریع بر عملگر Walrus**
عملگر Walrus همونطور که اشاره شد، در نسخه ۳.۸ پایتون معرفی
شد. این عملگر میتونه تو موقعیت‌هایی کاربردی باشه که شما می‌خواید داخل یه عبارت، مقادیری رو به متغیرها اختصاص بدید.
```py
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)
```
**خروجی (+۳.۸):**
```py
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 است)
```py
>>> (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\.
```py
>>> a = "some_string"
>>> id(a)
140420665652016
>>> id("some" + "_" + "string") # دقت کنید که هردو شناسه یکسانند.
140420665652016
```
2\.
```py
>>> a = "wtf"
>>> b = "wtf"
>>> a is b
True
>>> a = "wtf!"
>>> b = "wtf!"
>>> a is b
False
```
3\.
```py
>>> a, b = "wtf!", "wtf!"
>>> a is b # همه‌ی نسخه‌ها به جز 3.7.x
True
>>> a = "wtf!"; b = "wtf!"
>>> a is b # ممکن است True یا False باشد بسته به جایی که آن را اجرا می‌کنید (python shell / ipython / به‌صورت اسکریپت)
False
```
```py
# این بار در فایل some_file.py
a = "wtf!"
b = "wtf!"
print(a is b)
# موقع اجرای ماژول، True را چاپ میکند!
```
4\.
**خروجی (< Python3.7 )**
```py
>>> 'a' * 20 is 'aaaaaaaaaaaaaaaaaaaa'
True
>>> 'a' * 21 is 'aaaaaaaaaaaaaaaaaaaaa'
False
```
منطقیه، نه؟
#### 💡 توضیح:
- در قطعه‌کد اول و دوم، رفتار کد به دلیل یک بهینه سازی در CPython است (به نام داوطلب سازی رشتهها) که باعث میشود از برخی مقادیر غیرقابل تغییر، به جای مقداردهی مجدد، دوباره استفاده شود.
- بیشتر متغیرهایی که به‌این صورت جایگزین می‌شوند، در حافظه دستگاه به مقدار داوطلب خود اشاره میکنند (تا از حافظه کمتری استفاده شود)
- در قطعه‌کدهای بالا، رشتهها به‌صورت غیرمستقیم داوطلب می‌شوند. تصمیم اینکه رشتهها چه زمانی به صورت غیرمستقیم داوطلب شوند به نحوه پیاده‌سازی و مقداردهی آنها بستگی دارد. برخی قوانین وجود دارند تا بتوانیم داوطلب شدن یا نشدن یک رشته را حدس بزنیم:
- همه رشتهها با طول صفر یا یک داوطلب می‌شوند.
- رشتهها در زمان کامپایل داوطلب می‌شوند (`'wtf'` داوطلب میشود اما `''.join(['w', 't', 'f'])` داوطلب نمی‌شود)
- رشته‌هایی که از حروف ASCII ، اعداد صحیح و آندرلاین تشکیل نشده‌باشند داوطلب نمی‌شود. به همین دلیل `'wtf!'` به خاطر وجود `'!'` داوطلب نشد. پیاده‌سازی این قانون در CPython در [اینجا](https://github.com/python/cpython/blob/3.6/Objects/codeobject.c#L19) قرار دارد.
- زمانی که `"wtf!"` را در یک خط به `a` و `b` اختصاص می‌دهیم، مفسر پایتون شیء جدید میسازد و متغیر دوم را به آن ارجاع می‌دهد. اگر مقدار دهی در خط‌های جدا از هم انجام شود، در واقع مفسر "خبر ندارد" که یک شیء مختص به `"wtf!"` از قبل در برنامه وجود دارد (زیرا `"wtf!"` به دلایلی که در بالا گفته شد، به‌صورت غیرمستقیم داوطلب نمی‌شود). این بهینه سازی در زمان کامپایل انجام میشود. این بهینه سازی همچنین برای نسخه های (x).۳.۷ وجود ندارد (برای گفت‌وگوی بیشتر این [موضوع](https://github.com/satwikkansal/wtfpython/issues/100) را ببینید).
- یک واحد کامپایل در یک محیط تعاملی مانند IPython از یک عبارت تشکیل میشود، در حالی که برای ماژول‌ها شامل کل ماژول میشود. `a, b = "wtf!", "wtf!"` یک عبارت است. در حالی که `a = "wtf!"; b = "wtf!"` دو عبارت در یک خط است. به همین دلیل شناسه‌ها در `a = "wtf!"; b = "wtf!"` متفاوتند و همین‌طور وقتی با مفسر پایتون داخل فایل `some_file.py` اجرا می‌شوند، شناسه‌ها یکسانند.
- تغییر ناگهانی در خروجی قطعه‌کد چهارم به دلیل [بهینه‌سازی پنجره‌ای](https://en.wikipedia.org/wiki/Peephole_optimization) است که تکنیکی معروف به جمع آوری ثابت‌ها است. به همین خاطر عبارت `'a'*20` با `'aaaaaaaaaaaaaaaaaaaa'` در هنگام کامپایل جایگزین میشود تا کمی بار از دوش چرخه‌ساعتی پردازنده کم شود. تکنیک جمع آوری ثابت‌ها فقط مخصوص رشته‌هایی با طول کمتر از 21 است. (چرا؟ فرض کنید که فایل `.pyc` که توسط کامپایلر ساخته میشود چقدر بزرگ می‌شد اگر عبارت `'a'*10**10`). [این](https://github.com/python/cpython/blob/3.6/Python/peephole.c#L288) هم کد پیاده‌سازی این تکنیک در CPython.
- توجه: در پایتون ۳.۷، جمع آوری ثابت‌ها از بهینه‌ساز پنجره‌ای به بهینه‌ساز AST جدید انتقال داده شد همراه با تغییراتی در منطق آن. پس چهارمین قطعه‌کد در پایتون نسخه ۳.۷ کار نمی‌کند. شما میتوانید در [اینجا](https://bugs.python.org/issue11549) بیشتر درمورد این تغییرات بخوانید.
---
### ◀ مراقب عملیاتهای زنجیرهای باشید
```py
>>> (False == False) in [False] # منطقیه
False
>>> False == (False in [False]) # منطقیه
False
>>> False == False in [False] # حالا چی؟
True
>>> True is False == False
False
>>> False is False is False
True
>>> 1 > 0 < 1
True
>>> (1 > 0) < 1
False
>>> 1 > (0 < 1)
False
```
#### 💡 توضیح:
طبق https://docs.python.org/3/reference/expressions.html#comparisons
> اگر a، b، c، ...، y، z عبارت‌های عملیات و op1، op2، ...، opN عملگرهای عملیات باشند، آنگاه عملیات a op1 b op2 c ... y opN z معادل عملیات a op1 b and b op2 c and ... y opN z است. فقط دقت کنید که هر عبارت یک بار ارزیابی میشود.
شاید چنین رفتاری برای شما احمقانه به نظر بیاد ولی برای عملیات‌هایی مثل `a == b == c` و `0 <= x <= 100` عالی عمل میکنه.
- عبارت `False is False is False` معادل عبارت `(False is False) and (False is False)` است
- عبارت `True is False == False` معادل عبارت `(True is False) and (False == False)` است و از آنجایی که قسمت اول این عبارت (`True is False`) پس از ارزیابی برابر با `False` میشود. پس کل عبارت معادل `False` میشود.
- عبارت `1 > 0 < 1` معادل عبارت `(1 > 0) and (0 < 1)` است.
- عبارت `(1 > 0) < 1` معادل عبارت `True < 1` است و :
```py
>>> int(True)
1
>>> True + 1 # مربوط به این بخش نیست ولی همینجوری گذاشتم
2
```
پس عبارت `True < 1` معادل عبارت `1 < 1` میشود که در کل معادل `False` است.
---
### ◀ چطور از عملگر `is` استفاده نکنیم
عبارت پایین خیلی معروفه و تو کل اینترنت موجوده.
1\.
```py
>>> a = 256
>>> b = 256
>>> a is b
True
>>> a = 257
>>> b = 257
>>> a is b
False
```
2\.
```py
>>> a = []
>>> b = []
>>> a is b
False
>>> a = tuple()
>>> b = tuple()
>>> a is b
True
```
3\.
**خروجی**
```py
>>> a, b = 257, 257
>>> a is b
True
```
**خروجی (مخصوص نسخه‌های (x).۳.۷)**
```py
>>> a, b = 257, 257
>>> a is b
False
```
#### 💡 توضیح:
**فرض بین عملگرهای `is` و `==`**
- عملگر `is` بررسی میکنه که دو متغیر در حافظه دستگاه به یک شیء اشاره میکنند یا نه (یعنی شناسه متغیرها رو با هم تطبیق میده).
- عملگر `==` مقدار متغیرها رو با هم مقایسه میکنه و یکسان بودنشون رو بررسی میکنه.
- پس `is` برای معادل بودن متغیرها در حافظه دستگاه و `==` برای معادل بودن مقادیر استفاده میشه. یه مثال برای شفاف سازی بیشتر:
```py
>>> class A: pass
>>> A() is A() # این‌ها دو شیء خالی هستند که در دو جای مختلف در حافظه قرار دارند.
False
```
**عدد `256` از قبل تو حافظه قرار داده شده ولی `257` نه؟**
وقتی پایتون رو اجرا می‌کنید اعداد از `-5` تا `256` در حافظه ذخیره میشن. چون این اعداد خیلی پرکاربرد هستند پس منطقیه که اون‌ها رو در حافظه دستگاه، آماده داشته باشیم.
نقل قول از https://docs.python.org/3/c-api/long.html
> در پیاده سازی فعلی یک آرایه از اشیاء عددی صحیح برای تمام اعداد صحیح بین `-5` تا `256` نگهداری میشود. وقتی شما یک عدد صحیح در این بازه به مقداردهی می‌کنید، فقط یک ارجاع به آن عدد که از قبل در حافظه ذخیره شده است دریافت می‌کنید. پس تغییر مقدار عدد 1 باید ممکن باشد. که در این مورد من به رفتار پایتون شک دارم تعریف‌نشده است. :-)
```py
>>> id(256)
10922528
>>> a = 256
>>> b = 256
>>> id(a)
10922528
>>> id(b)
10922528
>>> id(257)
140084850247312
>>> x = 257
>>> y = 257
>>> id(x)
140084850247440
>>> id(y)
140084850247344
```
در اینجا مفسر وقتی عبارت `y = 257` رو اجرا میکنه، به اندازه کافی زیرکانه عمل نمیکنه که تشخیص بده که ما یک عدد صحیح با مقدار `257` در حافظه ذخیره کرده‌ایم، پس به ساختن یک شیء جدید در حافظه ادامه میده.
یک بهینه سازی مشابه شامل حال مقادیر **غیرقابل تغییر** دیگه مانند تاپل‌های خالی هم میشه. از اونجایی که لیست‌ها قابل تغییرند، عبارت `[] is []` مقدار `False` رو برمیگردونه و عبارت `() is ()` مقدار `True` رو برمیگردونه. به همین دلیله که قطعه کد دوم چنین رفتاری داره. بریم سراغ سومی.
**متغیرهای `a` و `b` وقتی در یک خط با مقادیر یکسانی مقداردهی میشن، هردو به یک شیء در حافظه اشاره میکنن**
**خروجی**
```py
>>> a, b = 257, 257
>>> id(a)
140640774013296
>>> id(b)
140640774013296
>>> a = 257
>>> b = 257
>>> id(a)
140640774013392
>>> id(b)
140640774013488
```
- وقتی a و b در یک خط با `257` مقداردهی میشن، مفسر پایتون یک شیء برای یکی از متغیرها در حافظه میسازه و متغیر دوم رو در حافظه به اون ارجاع میده. اگه این کار رو تو دو خط جدا از هم انجام بدید، درواقع مفسر پایتون از وجود مقدار `257` به عنوان یک شیء، "خبر نداره".
- این یک بهینه سازی توسط کامپایلر هست و مخصوصا در محیط تعاملی به کار برده میشه. وقتی شما دو خط رو در یک مفسر زنده وارد می‌کنید، اون‌ها به صورت جداگانه کامپایل میشن، به همین دلیل بهینه سازی به صورت جداگانه برای هرکدوم اعمال میشه. اگر بخواهید این مثال رو در یک فایل `.py` امتحان کنید، رفتار متفاوتی می‌بینید زیرا فایل به صورت کلی و یک‌جا کامپایل میشه. این بهینه سازی محدود به اعداد صحیح نیست و برای انواع داده‌های غیرقابل تغییر دیگه مانند رشتهها (مثال "رشتهها میتوانند دردسرساز شوند" رو ببینید) و اعداد اعشاری هم اعمال میشه.
```py
>>> a, b = 257.0, 257.0
>>> a is b
True
```
- چرا این برای پایتون ۳.۷ کار نکرد؟ دلیل انتزاعیش اینه که چنین بهینه‌سازی‌های کامپایلری وابسته به پیاده‌سازی هستن (یعنی بسته به نسخه، و نوع سیستم‌عامل و چیزهای دیگه تغییر میکنن). من هنوز پیگیرم که بدونم که کدوم تغییر تو پیاده‌سازی باعث همچین مشکلاتی میشه، می‌تونید برای خبرهای بیشتر این [موضوع](https://github.com/satwikkansal/wtfpython/issues/100) رو نگاه کنید.
---
### ◀ کلیدهای هش
1\.
```py
some_dict = {}
some_dict[5.5] = "JavaScript"
some_dict[5.0] = "Ruby"
some_dict[5] = "Python"
```
**خروجی:**
```py
>>> some_dict[5.5]
"JavaScript"
>>> some_dict[5.0] # رشته ("Python")، رشته ("Ruby") رو از بین برد؟
"Python"
>>> some_dict[5]
"Python"
>>> complex_five = 5 + 0j
>>> type(complex_five)
complex
>>> some_dict[complex_five]
"Python"
```
خب، چرا Python همه جارو گرفت؟
#### 💡 توضیح
- تو دیکشنری‌های پایتون چیزی که کلیدها رو یگانه میکنه مقدار کلیدهاست، نه شناسه اون‌ها. پس با اینکه `5`، `5.0` و `5 + 0j` شیءهای متمایزی از نوع‌های متفاوتی هستند ولی از اون جایی که مقدارشون با هم برابره، نمیتونن داخل یه `dict` به عنوان کلید جدا از هم باشن (حتی به عنوان مقادیر داخل یه `set` نمیتونن باشن). وقتی بخواید داخل یه دیکشنری جست‌وجو کنید، به محض اینکه یکی از این داده‌ها رو وارد کنید، مقدار نگاشته‌شده به کلیدی که مقدار برابر با اون داده داره ولی نوعش متفاوته، با موفقیت برگردونده میشه (به جای اینکه به ارور `KeyError` بردخورد کنید.).
```py
>>> 5 == 5.0 == 5 + 0j
True
>>> 5 is not 5.0 is not 5 + 0j
True
>>> some_dict = {}
>>> some_dict[5.0] = "Ruby"
>>> 5.0 in some_dict
True
>>> (5 in some_dict) and (5 + 0j in some_dict)
True
```
- همچنین این قانون برای مقداردهی توی دیکشنری هم اعمال میشه. وقتی شما عبارت `some_dict[5] = "Python"` رو اجرا می‌کنید، پایتون دنبال کلیدی با مقدار یکسان میگرده که اینجا ما داریم `5.0 -> "Ruby"` و مقدار نگاشته‌شده به این کلید در دیکشنری رو با مقدار جدید جایگزین میکنه و کلید رو همونجوری که هست باقی میذاره.
```py
>>> some_dict
{5.0: 'Ruby'}
>>> some_dict[5] = "Python"
>>> some_dict
{5.0: 'Python'}
```
- خب پس چطوری میتونیم مقدار خود کلید رو به `5` تغییر بدیم (جای `5.0`)؟ راستش ما نمیتونیم این کار رو درجا انجام بدیم، ولی میتونیم اول اون کلید رو پاک کنیم (`del some_dict[5.0]`) و بعد کلیدی که میخوایم رو قرار بدیم (`some_dict[5]`) تا بتونیم عدد صحیح `5` رو به جای عدد اعشاری `5.0` به عنوان کلید داخل دیکشنری داشته باشیم. درکل خیلی کم پیش میاد که بخوایم چنین کاری کنیم.
- پایتون چطوری توی دیکشنری که کلید `5.0` رو داره، کلید `5` رو پیدا کرد؟ پایتون این کار رو توی زمان ثابتی توسط توابع هش انجام میده بدون اینکه مجبور باشه همه کلیدها رو بررسی کنه. وقتی پایتون دنبال کلیدی مثل `foo` داخل یه `dict` میگرده، اول مقدار `hash(foo)` رو محاسبه میکنه (که توی زمان ثابتی انجام میشه). از اونجایی که توی پایتون برای مقایسه برابری مقدار دو شیء لازمه که هش یکسانی هم داشته باشند ([مستندات](https://docs.python.org/3/reference/datamodel.html#object.__hash__)). `5`، `5.0` و `5 + 0j` مقدار هش یکسانی دارند.
```py
>>> 5 == 5.0 == 5 + 0j
True
>>> hash(5) == hash(5.0) == hash(5 + 0j)
True
```
**توجه:** برعکس این قضیه لزوما درست نیست. شیءهای میتونن هش های یکسانی داشته باشند ولی مقادیر نابرابری داشته باشند. (این باعث به وجود اومدن پدیده‌ای معروف [تصادف هش]() میشه)، در این صورت توابع هش عملکرد خودشون رو کندتر از حالت عادی انجام می‌دهند.
---
### ◀ در عمق وجود همه ما یکسان هستیم
```py
class WTF:
pass
```
**خروجی:**
```py
>>> WTF() == WTF() # دو نمونه متفاوت از یک کلاس نمیتونند برابر هم باشند
False
>>> WTF() is WTF() # شناسه‌ها هم متفاوتند
False
>>> hash(WTF()) == hash(WTF()) # هش‌ها هم _باید_ متفاوت باشند
True
>>> id(WTF()) == id(WTF())
True
```
#### 💡 توضیح:
- وقتی `id` صدا زده شد، پایتون یک شیء با کلاس `WTF` ساخت و اون رو به تابع `id` داد. تابع `id` شناسه این شیء رو میگیره (درواقع آدرس اون شیء در حافظه دستگاه) و شیء رو حذف میکنه.
- وقتی این کار رو دو بار متوالی انجام بدیم، پایتون آدرس یکسانی رو به شیء دوم اختصاص میده. از اونجایی که (در CPython) تابع `id` از آدرس شیءها توی حافظه به عنوان شناسه برای اون‌ها استفاده میکنه، پس شناسه این دو شیء یکسانه.
- پس، شناسه یک شیء تا زمانی که اون شیء وجود داره، منحصربه‌فرده. بعد از اینکه اون شیء حذف میشه یا قبل از اینکه اون شیء به وجود بیاد، چیز دیگه‌ای میتونه اون شناسه رو داشته باشه.
- ولی چرا با عملگر `is` مقدار `False` رو دریافت کردیم؟ بیاید با یه قطعه‌کد ببینیم دلیلش رو.
```py
class WTF(object):
def __init__(self): print("I")
def __del__(self): print("D")
```
**خروجی:**
```py
>>> WTF() is WTF()
I
I
D
D
False
>>> id(WTF()) == id(WTF())
I
D
I
D
True
```
همونطور که مشاهده می‌کنید، ترتیب حذف شدن شیءها باعث تفاوت میشه.
---
### ◀ بینظمی در خود نظم \*
```py
from collections import OrderedDict
dictionary = dict()
dictionary[1] = 'a'; dictionary[2] = 'b';
ordered_dict = OrderedDict()
ordered_dict[1] = 'a'; ordered_dict[2] = 'b';
another_ordered_dict = OrderedDict()
another_ordered_dict[2] = 'b'; another_ordered_dict[1] = 'a';
class DictWithHash(dict):
"""
یک dict که تابع جادویی __hash__ هم توش پیاده شده.
"""
__hash__ = lambda self: 0
class OrderedDictWithHash(OrderedDict):
"""
یک OrderedDict که تابع جادویی __hash__ هم توش پیاده شده.
"""
__hash__ = lambda self: 0
```
**خروجی**
```py
>>> dictionary == ordered_dict # اگر مقدار اولی با دومی برابره
True
>>> dictionary == another_ordered_dict # و مقدار اولی با سومی برابره
True
>>> ordered_dict == another_ordered_dict # پس چرا مقدار دومی با سومی برابر نیست؟
False
# ما همه‌مون میدونیم که یک مجموعه فقط شامل عناصر منحصربه‌فرد و غیرتکراریه.
# بیاید یک مجموعه از این دیکشنری‌ها بسازیم ببینیم چه اتفاقی میافته...
>>> len({dictionary, ordered_dict, another_ordered_dict})
Traceback (most recent call last):
File "", line 1, in
TypeError: unhashable type: 'dict'
# منطقیه چون dict ها __hash__ توشون پیاده‌سازی نشده. پس بیاید از
# کلاس‌هایی که خودمون درست کردیم استفاده کنیم.
>>> dictionary = DictWithHash()
>>> dictionary[1] = 'a'; dictionary[2] = 'b';
>>> ordered_dict = OrderedDictWithHash()
>>> ordered_dict[1] = 'a'; ordered_dict[2] = 'b';
>>> another_ordered_dict = OrderedDictWithHash()
>>> another_ordered_dict[2] = 'b'; another_ordered_dict[1] = 'a';
>>> len({dictionary, ordered_dict, another_ordered_dict})
1
>>> len({ordered_dict, another_ordered_dict, dictionary}) # ترتیب رو عوض میکنیم
2
```
چی شد؟
#### 💡 توضیح:
- دلیل اینکه این مقایسه بین متغیرهای `dictionary`، `ordered_dict` و `another_ordered_dict` به درستی اجرا نمیشه به خاطر نحوه پیاده‌سازی تابع `__eq__` در کلاس `OrderedDict` هست. طبق [مستندات](https://docs.python.org/3/library/collections.html#ordereddict-objects)
> مقایسه برابری بین شیءهایی از نوع OrderedDict به ترتیب اعضای آنها هم بستگی دارد و به صورت `list(od1.items())==list(od2.items())` پیاده سازی شده است. مقایسه برابری بین شیءهای `OrderedDict` و شیءهای قابل نگاشت دیگر به ترتیب اعضای آنها بستگی ندارد و مقایسه همانند دیکشنری‌های عادی انجام میشود.
- این رفتار باعث میشه که بتونیم `OrderedDict` ها رو هرجایی که یک دیکشنری عادی کاربرد داره، جایگزین کنیم و استفاده کنیم.
- خب، حالا چرا تغییر ترتیب روی طول مجموعه‌ای که از دیکشنری‌ها ساختیم، تاثیر گذاشت؟ جوابش همین رفتار مقایسه‌ای غیرانتقالی بین این شیءهاست. از اونجایی که `set` ها مجموعه‌ای از عناصر غیرتکراری و بدون نظم هستند، ترتیبی که عناصر تو این مجموعه‌ها درج میشن نباید مهم باشه. ولی در این مورد، مهم هست. بیاید کمی تجزیه و تحلیلش کنیم.
```py
>>> some_set = set()
>>> some_set.add(dictionary) # این شیءها از قطعه‌کدهای بالا هستند.
>>> ordered_dict in some_set
True
>>> some_set.add(ordered_dict)
>>> len(some_set)
1
>>> another_ordered_dict in some_set
True
>>> some_set.add(another_ordered_dict)
>>> len(some_set)
1
>>> another_set = set()
>>> another_set.add(ordered_dict)
>>> another_ordered_dict in another_set
False
>>> another_set.add(another_ordered_dict)
>>> len(another_set)
2
>>> dictionary in another_set
True
>>> another_set.add(another_ordered_dict)
>>> len(another_set)
2
```
پس بی‌ثباتی تو این رفتار به خاطر اینه که مقدار `another_ordered_dict in another_set` برابر با `False` هست چون `ordered_dict` از قبل داخل `another_set` هست و همونطور که قبلا مشاهده کردید، مقدار `ordered_dict == another_ordered_dict` برابر با `False` هست.
---
### ◀ تلاش کن... \*
```py
def some_func():
try:
return 'from_try'
finally:
return 'from_finally'
def another_func():
for _ in range(3):
try:
continue
finally:
print("Finally!")
def one_more_func():
try:
for i in range(3):
try:
1 / i
except ZeroDivisionError:
# بذارید اینجا ارور بدیم و بیرون حلقه بهش
# رسیدگی کنیم
raise ZeroDivisionError("A trivial divide by zero error")
finally:
print("Iteration", i)
break
except ZeroDivisionError as e:
print("Zero division error occurred", e)
```
**خروجی:**
```py
>>> some_func()
'from_finally'
>>> another_func()
Finally!
Finally!
Finally!
>>> 1 / 0
Traceback (most recent call last):
File "", line 1, in
ZeroDivisionError: division by zero
>>> one_more_func()
Iteration 0
```
#### 💡 توضیح:
- وقتی یک عبارت `return`، `break` یا `continue` داخل بخش `try` از یک عبارت "try...finally" اجرا میشه، بخش `fianlly` هم هنگام خارج شدن اجرا میشه.
- مقدار بازگشتی یک تابع از طریق آخرین عبارت `return` که داخل تابع اجرا میشه، مشخص میشه. از اونجایی که بخش `finally` همیشه اجرا میشه، عبارت `return` که داخل بخش `finally` هست آخرین عبارتیه که اجرا میشه.
- نکته اینجاست که اگه بخش داخل بخش `finally` یک عبارت `return` یا `break` اجرا بشه، `exception` موقتی که ذخیره شده، رها میشه.
---
### ◀ برای چی؟
```py
some_string = "wtf"
some_dict = {}
for i, some_dict[i] in enumerate(some_string):
i = 10
```
**خروجی:**
```py
>>> some_dict # یک دیکشنری مرتب‌شده نمایان میشه.
{0: 'w', 1: 't', 2: 'f'}
```
#### 💡 توضیح:
- یک حلقه `for` در [گرامر پایتون](https://docs.python.org/3/reference/grammar.html) این طور تعریف میشه:
```bash
for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite]
```
به طوری که `exprlist` یک هدف برای مقداردهیه. این یعنی، معادل عبارت `{exprlist} = {next_value}` **برای هر شیء داخل `testlist` اجرا میشود**.
یک مثال جالب برای نشون دادن این تعریف:
```py
for i in range(4):
print(i)
i = 10
```
**خروجی:**
```bash
0
1
2
3
```
آیا انتظار داشتید که حلقه فقط یک بار اجرا بشه؟
**💡 توضیح:**
- عبارت مقداردهی `i = 10` به خاطر نحوه کار کردن حلقه‌ها، هیچوقت باعث تغییر در تکرار حلقه نمیشه. قبل از شروع هر تکرار، مقدار بعدی که توسط شیء قابل تکرار (که در اینجا `range(4)` است) ارائه میشه، از بسته خارج میشه و به متغیرهای لیست هدف (که در اینجا `i` است) مقداردهی میشه.
- تابع `enumerate(some_string)`، یک متغیر `i` (که یک شمارنده افزایشی است) و یک حرف از حروف رشته `some_string` رو در هر تکرار برمیگردونه. و بعدش برای کلید `i` (تازه مقداردهی‌شده) در دیکشنری `some_dict`، مقدار اون حرف رو تنظیم میکنه. بازشده این حلقه میتونه مانند مثال زیر ساده بشه:
```py
>>> i, some_dict[i] = (0, 'w')
>>> i, some_dict[i] = (1, 't')
>>> i, some_dict[i] = (2, 'f')
>>> some_dict
```
---
### ◀ اختلاف زمانی در محاسبه
1\.
```py
array = [1, 8, 15]
# یک عبارت تولیدکننده عادی
gen = (x for x in array if array.count(x) > 0)
array = [2, 8, 22]
```
**خروجی:**
```py
>>> print(list(gen)) # پس بقیه مقدارها کجا رفتن؟
[8]
```
2\.
```py
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]
```
**خروجی:**
```py
>>> print(list(gen_1))
[1, 2, 3, 4]
>>> print(list(gen_2))
[1, 2, 3, 4, 5]
```
3\.
```py
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]
```
**خروجی:**
```py
>>> print(list(gen))
[401, 501, 601, 402, 502, 602, 403, 503, 603]
```
#### 💡 توضیح
- در یک عبارت [تولیدکننده](https://wiki.python.org/moin/Generators)، عبارت بند `in` در هنگام تعریف محاسبه میشه ولی عبارت شرطی در زمان اجرا محاسبه میشه.
- پس قبل از زمان اجرا، `array` دوباره با لیست `[2, 8, 22]` مقداردهی میشه و از آنجایی که در مقدار جدید `array`، بین `1`، `8` و `15`، فقط تعداد `8` بزرگتر از `0` است، تولیدکننده فقط مقدار `8` رو برمیگردونه
- تفاوت در مقدار `gen_1` و `gen_2` در بخش دوم به خاطر نحوه مقداردهی دوباره `array_1` و `array_2` است.
- در مورد اول، متغیر `array_1` به شیء جدید `[1,2,3,4,5]` وصله و از اون جایی که عبارت بند `in` در هنگام تعریف محاسبه میشه، `array_1` داخل تولیدکننده هنوز به شیء قدیمی `[1,2,3,4]` (که هنوز حذف نشده)
- در مورد دوم، مقداردهی برشی به `array_2` باعث به‌روز شدن شیء قدیمی این متغیر از `[1,2,3,4]` به `[1,2,3,4,5]` میشه و هر دو متغیر `gen_2` و `array_2` به یک شیء اشاره میکنند که حالا به‌روز شده.
- خیلی‌خب، حالا طبق منطقی که تا الان گفتیم، نباید مقدار `list(gen)` در قطعه‌کد سوم، `[11, 21, 31, 12, 22, 32, 13, 23, 33]` باشه؟ (چون `array_3` و `array_4` قراره درست مثل `array_1` رفتار کنن). دلیل این که چرا (فقط) مقادیر `array_4` به‌روز شدن، توی [PEP-289](https://www.python.org/dev/peps/pep-0289/#the-details) توضیح داده شده.
> فقط بیرونی‌ترین عبارت حلقه `for` بلافاصله محاسبه میشه و باقی عبارت‌ها به تعویق انداخته میشن تا زمانی که تولیدکننده اجرا بشه.
---
### ◀ هر گردی، گردو نیست
```py
>>> 'something' is not None
True
>>> 'something' is (not None)
False
```
#### 💡 توضیح
- عملگر `is not` یک عملگر باینری واحده و رفتارش متفاوت تر از استفاده `is` و `not` به صورت جداگانه‌ست.
- عملگر `is not` مقدار `False` رو برمیگردونه اگر متغیرها در هردو سمت این عملگر به شیء یکسانی اشاره کنند و درغیر این صورت، مقدار `True` برمیگردونه
- در مثال بالا، عبارت `(not None)` برابره با مقدار `True` از اونجایی که مقدار `None` در زمینه boolean به `False` تبدیل میشه. پس کل عبارت معادل عبارت `'something' is True` میشه.
---
### ◀ یک بازی دوز که توش X همون اول برنده میشه!
```py
# بیاید یک سطر تشکیل بدیم
row = [""] * 3 #row i['', '', '']
# حالا بیاید تخته بازی رو ایجاد کنیم
board = [row] * 3
```
**خروجی:**
```py
>>> board
[['', '', ''], ['', '', ''], ['', '', '']]
>>> board[0]
['', '', '']
>>> board[0][0]
''
>>> board[0][0] = "X"
>>> board
[['X', '', ''], ['X', '', ''], ['X', '', '']]
```
ما که سه‌تا `"X"` نذاشتیم. گذاشتیم مگه؟
#### 💡 توضیح:
وقتی متغیر `row` رو تشکیل میدیم، تصویر زیر نشون میده که چه اتفاقی در حافظه دستگاه میافته.
و وقتی متغیر `board` رو با ضرب کردن متغیر `row` تشکیل میدیم، تصویر زیر به صورت کلی نشون میده که چه اتفاقی در حافظه میافته (هر کدوم از عناصر `board[0]`، `board[1]` و `board[2]` در حافظه به لیست یکسانی به نشانی `row` اشاره میکنند).
