From b7184bc2113ce1f4de5bbfc0bff042d242948b89 Mon Sep 17 00:00:00 2001 From: Leo Alavi Date: Thu, 27 Feb 2025 11:20:10 +0100 Subject: [PATCH 01/33] Add persian translations boilerplate --- translations/fa-farsi/README.md | 3932 +++++++++++++++++++++++++++++++ 1 file changed, 3932 insertions(+) create mode 100644 translations/fa-farsi/README.md diff --git a/translations/fa-farsi/README.md b/translations/fa-farsi/README.md new file mode 100644 index 0000000..6d89f3b --- /dev/null +++ b/translations/fa-farsi/README.md @@ -0,0 +1,3932 @@ +

+ + + + Shows a wtfpython logo. + +

+

What the f*ck Python! 😱

+

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

+ + +ترجمه‌ها: [Chinese 中文](https://github.com/leisurelicht/wtfpython-cn) | [Vietnamese Tiếng Việt](https://github.com/vuduclyunitn/wtfptyhon-vi) | [Spanish Español](https://web.archive.org/web/20220511161045/https://github.com/JoseDeFreitas/wtfpython-es) | [Korean 한국어](https://github.com/buttercrab/wtfpython-ko) | [Russian Русский](https://github.com/satwikkansal/wtfpython/tree/master/translations/ru-russian) | [German Deutsch](https://github.com/BenSt099/wtfpython) | [Add translation](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].) + +Other modes: [Interactive Website](https://wtfpython-interactive.vercel.app) | [Interactive Notebook](https://colab.research.google.com/github/satwikkansal/wtfpython/blob/master/irrelevant/wtf.ipynb) + +Python, being a beautifully designed high-level and interpreter-based programming language, provides us with many features for the programmer's comfort. But sometimes, the outcomes of a Python snippet may not seem obvious at first sight. + +Here's a fun project attempting to explain what exactly is happening under the hood for some counter-intuitive snippets and lesser-known features in Python. + +While some of the examples you see below may not be WTFs in the truest sense, but they'll reveal some of the interesting parts of Python that you might be unaware of. I find it a nice way to learn the internals of a programming language, and I believe that you'll find it interesting too! + +If you're an experienced Python programmer, you can take it as a challenge to get most of them right in the first attempt. You may have already experienced some of them before, and I might be able to revive sweet old memories of yours! :sweat_smile: + +PS: If you're a returning reader, you can learn about the new modifications [here](https://github.com/satwikkansal/wtfpython/releases/) (the examples marked with asterisk are the ones added in the latest major revision). + +So, here we go... + +# Table of Contents + + + + + +- [Table of Contents](#table-of-contents) +- [Structure of the Examples](#structure-of-the-examples) +- [Usage](#usage) +- [👀 Examples](#-examples) + - [Section: Strain your brain!](#section-strain-your-brain) + - [▶ First things first! \*](#-first-things-first-) + - [💡 Explanation](#-explanation) + - [▶ بعضی وقت‌ها رشته‌ها می‌توانند دردسرساز شوند](#-بعضی-وقتها-رشتهها-میتوانند-دردسرساز-شوند) + - [💡 Explanation:](#-explanation-1) + - [▶ Be careful with chained operations](#-be-careful-with-chained-operations) + - [💡 Explanation:](#-explanation-2) + - [▶ How not to use `is` operator](#-how-not-to-use-is-operator) + - [💡 Explanation:](#-explanation-3) + - [▶ Hash brownies](#-hash-brownies) + - [💡 Explanation](#-explanation-4) + - [▶ Deep down, we're all the same.](#-deep-down-were-all-the-same) + - [💡 Explanation:](#-explanation-5) + - [▶ Disorder within order \*](#-disorder-within-order-) + - [💡 Explanation:](#-explanation-6) + - [▶ Keep trying... \*](#-keep-trying-) + - [💡 Explanation:](#-explanation-7) + - [▶ For what?](#-for-what) + - [💡 Explanation:](#-explanation-8) + - [▶ Evaluation time discrepancy](#-evaluation-time-discrepancy) + - [💡 Explanation](#-explanation-9) + - [▶ `is not ...` is not `is (not ...)`](#-is-not--is-not-is-not-) + - [💡 Explanation](#-explanation-10) + - [▶ A tic-tac-toe where X wins in the first attempt!](#-a-tic-tac-toe-where-x-wins-in-the-first-attempt) + - [💡 Explanation:](#-explanation-11) + - [▶ Schrödinger's variable \*](#-schrödingers-variable-) + - [💡 Explanation:](#-explanation-12) + - [▶ The chicken-egg problem \*](#-the-chicken-egg-problem-) + - [💡 Explanation](#-explanation-13) + - [▶ Subclass relationships](#-subclass-relationships) + - [💡 Explanation:](#-explanation-14) + - [▶ Methods equality and identity](#-methods-equality-and-identity) + - [💡 Explanation](#-explanation-15) + - [▶ All-true-ation \*](#-all-true-ation-) + - [💡 Explanation:](#-explanation-16) + - [💡 Explanation:](#-explanation-17) + - [▶ Strings and the backslashes](#-strings-and-the-backslashes) + - [💡 Explanation](#-explanation-18) + - [▶ not knot!](#-not-knot) + - [💡 Explanation:](#-explanation-19) + - [▶ Half triple-quoted strings](#-half-triple-quoted-strings) + - [💡 Explanation:](#-explanation-20) + - [▶ What's wrong with booleans?](#-whats-wrong-with-booleans) + - [💡 Explanation:](#-explanation-21) + - [▶ Class attributes and instance attributes](#-class-attributes-and-instance-attributes) + - [💡 Explanation:](#-explanation-22) + - [▶ yielding None](#-yielding-none) + - [💡 Explanation:](#-explanation-23) + - [▶ Yielding from... return! \*](#-yielding-from-return-) + - [💡 Explanation:](#-explanation-24) + - [▶ Nan-reflexivity \*](#-nan-reflexivity-) + - [💡 Explanation:](#-explanation-25) + - [▶ Mutating the immutable!](#-mutating-the-immutable) + - [💡 Explanation:](#-explanation-26) + - [▶ The disappearing variable from outer scope](#-the-disappearing-variable-from-outer-scope) + - [💡 Explanation:](#-explanation-27) + - [▶ The mysterious key type conversion](#-the-mysterious-key-type-conversion) + - [💡 Explanation:](#-explanation-28) + - [▶ Let's see if you can guess this?](#-lets-see-if-you-can-guess-this) + - [💡 Explanation:](#-explanation-29) + - [▶ Exceeds the limit for integer string conversion](#-exceeds-the-limit-for-integer-string-conversion) + - [💡 Explanation:](#-explanation-30) + - [Section: Slippery Slopes](#section-slippery-slopes) + - [▶ Modifying a dictionary while iterating over it](#-modifying-a-dictionary-while-iterating-over-it) + - [💡 Explanation:](#-explanation-31) + - [▶ Stubborn `del` operation](#-stubborn-del-operation) + - [💡 Explanation:](#-explanation-32) + - [▶ The out of scope variable](#-the-out-of-scope-variable) + - [💡 Explanation:](#-explanation-33) + - [▶ Deleting a list item while iterating](#-deleting-a-list-item-while-iterating) + - [💡 Explanation:](#-explanation-34) + - [▶ Lossy zip of iterators \*](#-lossy-zip-of-iterators-) + - [💡 Explanation:](#-explanation-35) + - [▶ Loop variables leaking out!](#-loop-variables-leaking-out) + - [💡 Explanation:](#-explanation-36) + - [▶ Beware of default mutable arguments!](#-beware-of-default-mutable-arguments) + - [💡 Explanation:](#-explanation-37) + - [▶ Catching the Exceptions](#-catching-the-exceptions) + - [💡 Explanation](#-explanation-38) + - [▶ Same operands, different story!](#-same-operands-different-story) + - [💡 Explanation:](#-explanation-39) + - [▶ Name resolution ignoring class scope](#-name-resolution-ignoring-class-scope) + - [💡 Explanation](#-explanation-40) + - [▶ Rounding like a banker \*](#-rounding-like-a-banker-) + - [💡 Explanation:](#-explanation-41) + - [▶ Needles in a Haystack \*](#-needles-in-a-haystack-) + - [💡 Explanation:](#-explanation-42) + - [▶ Splitsies \*](#-splitsies-) + - [💡 Explanation:](#-explanation-43) + - [▶ Wild imports \*](#-wild-imports-) + - [💡 Explanation:](#-explanation-44) + - [▶ All sorted? \*](#-all-sorted-) + - [💡 Explanation:](#-explanation-45) + - [▶ Midnight time doesn't exist?](#-midnight-time-doesnt-exist) + - [💡 Explanation:](#-explanation-46) + - [Section: The Hidden treasures!](#section-the-hidden-treasures) + - [▶ Okay Python, Can you make me fly?](#-okay-python-can-you-make-me-fly) + - [💡 Explanation:](#-explanation-47) + - [▶ `goto`, but why?](#-goto-but-why) + - [💡 Explanation:](#-explanation-48) + - [▶ Brace yourself!](#-brace-yourself) + - [💡 Explanation:](#-explanation-49) + - [▶ Let's meet Friendly Language Uncle For Life](#-lets-meet-friendly-language-uncle-for-life) + - [💡 Explanation:](#-explanation-50) + - [▶ Even Python understands that love is complicated](#-even-python-understands-that-love-is-complicated) + - [💡 Explanation:](#-explanation-51) + - [▶ Yes, it exists!](#-yes-it-exists) + - [💡 Explanation:](#-explanation-52) + - [▶ Ellipsis \*](#-ellipsis-) + - [💡 Explanation](#-explanation-53) + - [▶ Inpinity](#-inpinity) + - [💡 Explanation:](#-explanation-54) + - [▶ Let's mangle](#-lets-mangle) + - [💡 Explanation:](#-explanation-55) + - [Section: Appearances are deceptive!](#section-appearances-are-deceptive) + - [▶ Skipping lines?](#-skipping-lines) + - [💡 Explanation](#-explanation-56) + - [▶ Teleportation](#-teleportation) + - [💡 Explanation:](#-explanation-57) + - [▶ Well, something is fishy...](#-well-something-is-fishy) + - [💡 Explanation](#-explanation-58) + - [Section: Miscellaneous](#section-miscellaneous) + - [▶ `+=` is faster](#--is-faster) + - [💡 Explanation:](#-explanation-59) + - [▶ Let's make a giant string!](#-lets-make-a-giant-string) + - [💡 Explanation](#-explanation-60) + - [▶ Slowing down `dict` lookups \*](#-slowing-down-dict-lookups-) + - [💡 Explanation:](#-explanation-61) + - [▶ Bloating instance `dict`s \*](#-bloating-instance-dicts-) + - [💡 Explanation:](#-explanation-62) + - [▶ Minor Ones \*](#-minor-ones-) +- [Contributing](#contributing) +- [Acknowledgements](#acknowledgements) + - [Some nice Links!](#some-nice-links) +- [🎓 License](#-license) + - [Surprise your friends as well!](#surprise-your-friends-as-well) + - [Need a pdf version?](#need-a-pdf-version) + + + +# Structure of the Examples + +All the examples are structured like below: + +> ### ▶ Some fancy Title +> +> ```py +> # Set up the code. +> # Preparation for the magic... +> ``` +> +> **Output (Python version(s)):** +> +> ```py +> >>> triggering_statement +> Some unexpected output +> ``` +> (Optional): One line describing the unexpected output. +> +> +> #### 💡 Explanation: +> +> * Brief explanation of what's happening and why is it happening. +> ```py +> # Set up code +> # More examples for further clarification (if necessary) +> ``` +> **Output (Python version(s)):** +> +> ```py +> >>> trigger # some example that makes it easy to unveil the magic +> # some justified output +> ``` + +**Note:** All the examples are tested on Python 3.5.2 interactive interpreter, and they should work for all the Python versions unless explicitly specified before the output. + +# Usage + +A nice way to get the most out of these examples, in my opinion, is to read them in sequential order, and for every example: +- Carefully read the initial code for setting up the example. If you're an experienced Python programmer, you'll successfully anticipate what's going to happen next most of the time. +- Read the output snippets and, + + Check if the outputs are the same as you'd expect. + + Make sure if you know the exact reason behind the output being the way it is. + - If the answer is no (which is perfectly okay), take a deep breath, and read the explanation (and if you still don't understand, shout out! and create an issue [here](https://github.com/satwikkansal/wtfpython/issues/new)). + - If yes, give a gentle pat on your back, and you may skip to the next example. + +--- + +# 👀 Examples + +## Section: Strain your brain! + +### ▶ First things first! * + + + + +For some reason, the Python 3.8's "Walrus" operator (`:=`) has become quite popular. Let's check it out, + +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") # This works though +'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 # Typical unpacking +>>> a, b +(6, 9) +>>> (a, b = 16, 19) # Oops + File "", line 1 + (a, b = 16, 19) + ^ +SyntaxError: invalid syntax + +>>> (a, b := 16, 19) # This prints out a weird 3-tuple +(6, 16, 19) + +>>> a # a is still unchanged? +6 + +>>> b +16 +``` + + + +#### 💡 Explanation + +**Quick walrus operator refresher** + +The Walrus operator (`:=`) was introduced in Python 3.8, it can be useful in situations where you'd want to assign values to variables within an expression. + +```py +def some_func(): + # Assume some expensive computation here + # time.sleep(1000) + return 5 + +# So instead of, +if some_func(): + print(some_func()) # Which is bad practice since computation is happening twice + +# or +a = some_func() +if a: + print(a) + +# Now you can concisely write +if a := some_func(): + print(a) +``` + +**Output (> 3.8):** + +```py +5 +5 +5 +``` + +This saved one line of code, and implicitly prevented invoking `some_func` twice. + +- Unparenthesized "assignment expression" (use of walrus operator), is restricted at the top level, hence the `SyntaxError` in the `a := "wtf_walrus"` statement of the first snippet. Parenthesizing it worked as expected and assigned `a`. + +- As usual, parenthesizing of an expression containing `=` operator is not allowed. Hence the syntax error in `(a, b = 6, 9)`. + +- The syntax of the Walrus operator is of the form `NAME:= expr`, where `NAME` is a valid identifier, and `expr` is a valid expression. Hence, iterable packing and unpacking are not supported which means, + + - `(a := 6, 9)` is equivalent to `((a := 6), 9)` and ultimately `(a, 9) ` (where `a`'s value is 6') + + ```py + >>> (a := 6, 9) == ((a := 6), 9) + True + >>> x = (a := 696, 9) + >>> x + (696, 9) + >>> x[0] is a # Both reference same memory location + True + ``` + + - Similarly, `(a, b := 16, 19)` is equivalent to `(a, (b := 16), 19)` which is nothing but a 3-tuple. + +--- + +### ▶ بعضی وقت‌ها رشته‌ها می‌توانند دردسرساز شوند + + +1\. + +```py +>>> a = "some_string" +>>> id(a) +140420665652016 +>>> id("some" + "_" + "string") # دقت کنید که هردو ID یکی هستند. +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 +``` + +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](https://github.com/python/cpython/blob/3.6/Objects/codeobject.c#L19) +

+ + + + Shows a string interning process. + +

+ ++ 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](https://github.com/satwikkansal/wtfpython/issues/100) 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](https://en.wikipedia.org/wiki/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](https://github.com/python/cpython/blob/3.6/Python/peephole.c#L288) 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](https://bugs.python.org/issue11549). + +--- + + +### ▶ Be careful with chained operations + +```py +>>> (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 + ```py + >>> 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\. + +```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\. +**Output** + +```py +>>> a, b = 257, 257 +>>> a is b +True +``` + +**Output (Python 3.7.x specifically)** + +```py +>>> 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, + ```py + >>> 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. :-) + +```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 +``` + +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** + +```py +>>> 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, + + ```py + >>> 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](https://github.com/satwikkansal/wtfpython/issues/100) for updates. + +--- + + +### ▶ Hash brownies + +1\. +```py +some_dict = {} +some_dict[5.5] = "JavaScript" +some_dict[5.0] = "Ruby" +some_dict[5] = "Python" +``` + +**Output:** + +```py +>>> 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`): + ```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 + ``` +* 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. + ```py + >>> 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](https://docs.python.org/3/reference/datamodel.html#object.__hash__) here), `5`, `5.0`, and `5 + 0j` have the same hash value. + ```py + >>> 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](https://en.wikipedia.org/wiki/Collision_(computer_science)), and degrades the constant-time performance that hashing usually provides.) + +--- + +### ▶ Deep down, we're all the same. + +```py +class WTF: + pass +``` + +**Output:** +```py +>>> 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. + ```py + class WTF(object): + def __init__(self): print("I") + def __del__(self): print("D") + ``` + + **Output:** + ```py + >>> 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 * + +```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): + """ + 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** +```py +>>> 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 "", line 1, in +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](https://docs.python.org/3/library/collections.html#ordereddict-objects) + + > 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, + ```py + >>> 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... * + +```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(): # 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:** + +```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 + +``` + +#### 💡 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? + +```py +some_string = "wtf" +some_dict = {} +for i, some_dict[i] in enumerate(some_string): + i = 10 +``` + +**Output:** +```py +>>> some_dict # An indexed dict appears. +{0: 'w', 1: 't', 2: 'f'} +``` + +#### 💡 Explanation: + +* A `for` statement is defined in the [Python grammar](https://docs.python.org/3/reference/grammar.html) 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: + ```py + 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: + ```py + >>> i, some_dict[i] = (0, 'w') + >>> i, some_dict[i] = (1, 't') + >>> i, some_dict[i] = (2, 'f') + >>> some_dict + ``` + +--- + +### ▶ Evaluation time discrepancy + +1\. +```py +array = [1, 8, 15] +# A typical generator expression +gen = (x for x in array if array.count(x) > 0) +array = [2, 8, 22] +``` + +**Output:** + +```py +>>> print(list(gen)) # Where did the other values go? +[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] +``` + +**Output:** +```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] +``` + +**Output:** +```py +>>> print(list(gen)) +[401, 501, 601, 402, 502, 602, 403, 503, 603] +``` + +#### 💡 Explanation + +- In a [generator](https://wiki.python.org/moin/Generators) 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](https://www.python.org/dev/peps/pep-0289/#the-details) + + > Only the outermost for-expression is evaluated immediately, the other expressions are deferred until the generator is run. + +--- + + +### ▶ `is not ...` is not `is (not ...)` + +```py +>>> '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! + + +```py +# Let's initialize a row +row = [""] * 3 #row i['', '', ''] +# Let's make a board +board = [row] * 3 +``` + +**Output:** + +```py +>>> 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 + +

+ + + + Shows a memory segment after row is initialized. + +

+ +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`) + +

+ + + + Shows a memory segment after board is initialized. + +

+ +We can avoid this scenario here by not using `row` variable to generate `board`. (Asked in [this](https://github.com/satwikkansal/wtfpython/issues/68) issue). + +```py +>>> board = [['']*3 for _ in range(3)] +>>> board[0][0] = "X" +>>> board +[['X', '', ''], ['', '', ''], ['', '', '']] +``` + +--- + +### ▶ Schrödinger's variable * + + + +```py +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):** +```py +>>> 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. + +2. + +```py +>>> 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: +```py +>>> 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`: + +```py +>>> 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. + +```py +funcs = [] +for x in range(7): + def some_func(x=x): + return x + funcs.append(some_func) +``` + +**Output:** + +```py +>>> 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: + +```py +>>> inspect.getclosurevars(funcs[0]) +ClosureVars(nonlocals={}, globals={}, builtins={}, unbound=set()) +``` + +--- + +### ▶ The chicken-egg problem * + +1\. +```py +>>> 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\. + +```py +>>> class A: pass +>>> isinstance(A, A) +False +>>> isinstance(type, type) +True +>>> isinstance(object, object) +True +``` + +3\. + +```py +>>> issubclass(int, object) +True +>>> issubclass(type, object) +True +>>> issubclass(object, type) +False +``` + + +#### 💡 Explanation + +- `type` is a [metaclass](https://realpython.com/python-metaclasses/) 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:** +```py +>>> 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](https://www.naftaliharris.com/blog/python-subclass-intransitivity/). + +--- + +### ▶ Methods equality and identity + + +1. +```py +class SomeClass: + def method(self): + pass + + @classmethod + def classm(cls): + pass + + @staticmethod + def staticm(): + pass +``` + +**Output:** +```py +>>> 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 +``` + +Accessing `classm` twice, we get an equal object, but not the *same* one? Let's see what happens +with instances of `SomeClass`: + +2. +```py +o1 = SomeClass() +o2 = SomeClass() +``` + +**Output:** +```py +>>> 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 +``` + +Accessing `classm` or `method` twice, creates equal but not *same* objects for the same instance of `SomeClass`. + +#### 💡 Explanation +* Functions are [descriptors](https://docs.python.org/3/howto/descriptor.html). Whenever a function is accessed as an +attribute, the descriptor is invoked, creating a method object which "binds" the function with the object owning the +attribute. If called, the method calls the function, implicitly passing the bound object as the first argument +(this is how we get `self` as the first argument, despite not passing it explicitly). +```py +>>> o1.method +> +``` +* Accessing the attribute multiple times creates a method object every time! Therefore `o1.method is o1.method` is +never truthy. Accessing functions as class attributes (as opposed to instance) does not create methods, however; so +`SomeClass.method is SomeClass.method` is truthy. +```py +>>> SomeClass.method + +``` +* `classmethod` transforms functions into class methods. Class methods are descriptors that, when accessed, create +a method object which binds the *class* (type) of the object, instead of the object itself. +```py +>>> o1.classm +> +``` +* Unlike functions, `classmethod`s will create a method also when accessed as class attributes (in which case they +bind the class, not to the type of it). So `SomeClass.classm is SomeClass.classm` is falsy. +```py +>>> SomeClass.classm +> +``` +* A method object compares equal when both the functions are equal, and the bound objects are the same. So +`o1.method == o1.method` is truthy, although not the same object in memory. +* `staticmethod` transforms functions into a "no-op" descriptor, which returns the function as-is. No method +objects are ever created, so comparison with `is` is truthy. +```py +>>> o1.staticm + +>>> SomeClass.staticm + +``` +* Having to create new "method" objects every time Python calls instance methods and having to modify the arguments +every time in order to insert `self` affected performance badly. +CPython 3.7 [solved it](https://bugs.python.org/issue26110) by introducing new opcodes that deal with calling methods +without creating the temporary method objects. This is used only when the accessed function is actually called, so the +snippets here are not affected, and still generate methods :) + +### ▶ All-true-ation * + + + +```py +>>> all([True, True, True]) +True +>>> all([True, True, False]) +False + +>>> all([]) +True +>>> all([[]]) +False +>>> all([[[]]]) +True +``` + +Why's this True-False alteration? + +#### 💡 Explanation: + +- The implementation of `all` function is equivalent to + +- ```py + def all(iterable): + for element in iterable: + if not element: + return False + return True + ``` + +- `all([])` returns `True` since the iterable is empty. +- `all([[]])` returns `False` because the passed array has one element, `[]`, and in python, an empty list is falsy. +- `all([[[]]])` and higher recursive variants are always `True`. This is because the passed array's single element (`[[...]]`) is no longer empty, and lists with values are truthy. + +--- + +### ▶ The surprising comma + +**Output (< 3.6):** + +```py +>>> def f(x, y,): +... print(x, y) +... +>>> def g(x=4, y=5,): +... print(x, y) +... +>>> def h(x, **kwargs,): + File "", line 1 + def h(x, **kwargs,): + ^ +SyntaxError: invalid syntax + +>>> def h(*args,): + File "", line 1 + def h(*args,): + ^ +SyntaxError: invalid syntax +``` + +#### 💡 Explanation: + +- Trailing comma is not always legal in formal parameters list of a Python function. +- In Python, the argument list is defined partially with leading commas and partially with trailing commas. This conflict causes situations where a comma is trapped in the middle, and no rule accepts it. +- **Note:** The trailing comma problem is [fixed in Python 3.6](https://bugs.python.org/issue9232). The remarks in [this](https://bugs.python.org/issue9232#msg248399) post discuss in brief different usages of trailing commas in Python. + +--- + +### ▶ Strings and the backslashes + +**Output:** +```py +>>> print("\"") +" + +>>> print(r"\"") +\" + +>>> print(r"\") +File "", line 1 + print(r"\") + ^ +SyntaxError: EOL while scanning string literal + +>>> r'\'' == "\\'" +True +``` + +#### 💡 Explanation + +- In a usual python string, the backslash is used to escape characters that may have a special meaning (like single-quote, double-quote, and the backslash itself). + ```py + >>> "wt\"f" + 'wt"f' + ``` +- In a raw string literal (as indicated by the prefix `r`), the backslashes pass themselves as is along with the behavior of escaping the following character. + ```py + >>> r'wt\"f' == 'wt\\"f' + True + >>> print(repr(r'wt\"f')) + 'wt\\"f' + + >>> print("\n") + + >>> print(r"\\n") + '\\n' + ``` +- This means when a parser encounters a backslash in a raw string, it expects another character following it. And in our case (`print(r"\")`), the backslash escaped the trailing quote, leaving the parser without a terminating quote (hence the `SyntaxError`). That's why backslashes don't work at the end of a raw string. + +--- + +### ▶ not knot! + +```py +x = True +y = False +``` + +**Output:** +```py +>>> not x == y +True +>>> x == not y + File "", line 1 + x == not y + ^ +SyntaxError: invalid syntax +``` + +#### 💡 Explanation: + +* Operator precedence affects how an expression is evaluated, and `==` operator has higher precedence than `not` operator in Python. +* So `not x == y` is equivalent to `not (x == y)` which is equivalent to `not (True == False)` finally evaluating to `True`. +* But `x == not y` raises a `SyntaxError` because it can be thought of being equivalent to `(x == not) y` and not `x == (not y)` which you might have expected at first sight. +* The parser expected the `not` token to be a part of the `not in` operator (because both `==` and `not in` operators have the same precedence), but after not being able to find an `in` token following the `not` token, it raises a `SyntaxError`. + +--- + +### ▶ Half triple-quoted strings + +**Output:** +```py +>>> print('wtfpython''') +wtfpython +>>> print("wtfpython""") +wtfpython +>>> # The following statements raise `SyntaxError` +>>> # print('''wtfpython') +>>> # print("""wtfpython") + File "", line 3 + print("""wtfpython") + ^ +SyntaxError: EOF while scanning triple-quoted string literal +``` + +#### 💡 Explanation: ++ Python supports implicit [string literal concatenation](https://docs.python.org/3/reference/lexical_analysis.html#string-literal-concatenation), Example, + ``` + >>> print("wtf" "python") + wtfpython + >>> print("wtf" "") # or "wtf""" + wtf + ``` ++ `'''` and `"""` are also string delimiters in Python which causes a SyntaxError because the Python interpreter was expecting a terminating triple quote as delimiter while scanning the currently encountered triple quoted string literal. + +--- + +### ▶ What's wrong with booleans? + +1\. + +```py +# A simple example to count the number of booleans and +# integers in an iterable of mixed data types. +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 +``` + +**Output:** +```py +>>> integers_found_so_far +4 +>>> booleans_found_so_far +0 +``` + + +2\. +```py +>>> some_bool = True +>>> "wtf" * some_bool +'wtf' +>>> some_bool = False +>>> "wtf" * some_bool +'' +``` + +3\. + +```py +def tell_truth(): + True = False + if True == False: + print("I have lost faith in truth!") +``` + +**Output (< 3.x):** + +```py +>>> tell_truth() +I have lost faith in truth! +``` + + + +#### 💡 Explanation: + +* `bool` is a subclass of `int` in Python + + ```py + >>> issubclass(bool, int) + True + >>> issubclass(int, bool) + False + ``` + +* And thus, `True` and `False` are instances of `int` + ```py + >>> isinstance(True, int) + True + >>> isinstance(False, int) + True + ``` + +* The integer value of `True` is `1` and that of `False` is `0`. + ```py + >>> int(True) + 1 + >>> int(False) + 0 + ``` + +* See this StackOverflow [answer](https://stackoverflow.com/a/8169049/4354153) for the rationale behind it. + +* Initially, Python used to have no `bool` type (people used 0 for false and non-zero value like 1 for true). `True`, `False`, and a `bool` type was added in 2.x versions, but, for backward compatibility, `True` and `False` couldn't be made constants. They just were built-in variables, and it was possible to reassign them + +* Python 3 was backward-incompatible, the issue was finally fixed, and thus the last snippet won't work with Python 3.x! + +--- + +### ▶ Class attributes and instance attributes + +1\. +```py +class A: + x = 1 + +class B(A): + pass + +class C(A): + pass +``` + +**Output:** +```py +>>> 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 changed, but B.x didn't +(3, 2, 3) +>>> a = A() +>>> a.x, A.x +(3, 3) +>>> a.x += 1 +>>> a.x, A.x +(4, 3) +``` + +2\. +```py +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] +``` + +**Output:** + +```py +>>> 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 +``` + +#### 💡 Explanation: + +* Class variables and variables in class instances are internally handled as dictionaries of a class object. If a variable name is not found in the dictionary of the current class, the parent classes are searched for it. +* The `+=` operator modifies the mutable object in-place without creating a new object. So changing the attribute of one instance affects the other instances and the class attribute as well. + +--- + +### ▶ yielding None + +```py +some_iterable = ('a', 'b') + +def some_func(val): + return "something" +``` + +**Output (<= 3.7.x):** + +```py +>>> [x for x in some_iterable] +['a', 'b'] +>>> [(yield x) for x in some_iterable] + 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\. + +```py +def some_func(x): + if x == 3: + return ["wtf"] + else: + yield from range(x) +``` + +**Output (> 3.3):** + +```py +>>> list(some_func(3)) +[] +``` + +Where did the `"wtf"` go? Is it due to some special effect of `yield from`? Let's validate that, + +2\. + +```py +def some_func(x): + if x == 3: + return ["wtf"] + else: + for i in range(x): + yield i +``` + +**Output:** + +```py +>>> list(some_func(3)) +[] +``` + +The same result, this didn't work either. + +#### 💡 Explanation: + ++ From Python 3.3 onwards, it became possible to use `return` statement with values inside generators (See [PEP380](https://www.python.org/dev/peps/pep-0380/)). The [official docs](https://www.python.org/dev/peps/pep-0380/#enhancements-to-stopiteration) say that, + +> "... `return expr` in a generator causes `StopIteration(expr)` to be raised upon exit from the generator." + ++ In the case of `some_func(3)`, `StopIteration` is raised at the beginning because of `return` statement. The `StopIteration` exception is automatically caught inside the `list(...)` wrapper and the `for` loop. Therefore, the above two snippets result in an empty list. + ++ To get `["wtf"]` from the generator `some_func` we need to catch the `StopIteration` exception, + + ```py + try: + next(some_func(3)) + except StopIteration as e: + some_string = e.value + ``` + + ```py + >>> some_string + ["wtf"] + ``` + +--- + +### ▶ Nan-reflexivity * + + + +1\. + +```py +a = float('inf') +b = float('nan') +c = float('-iNf') # These strings are case-insensitive +d = float('nan') +``` + +**Output:** + +```py +>>> 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 # but nan!=nan +False +>>> 50 / a +0.0 +>>> a / a +nan +>>> 23 + b +nan +``` + +2\. + +```py +>>> x = float('nan') +>>> y = x / x +>>> y is y # identity holds +True +>>> y == y # equality fails of y +False +>>> [y] == [y] # but the equality succeeds for the list containing y +True +``` + + + +#### 💡 Explanation: + +- `'inf'` and `'nan'` are special strings (case-insensitive), which, when explicitly typecast-ed to `float` type, are used to represent mathematical "infinity" and "not a number" respectively. + +- Since according to IEEE standards ` NaN != NaN`, obeying this rule breaks the reflexivity assumption of a collection element in Python i.e. if `x` is a part of a collection like `list`, the implementations like comparison are based on the assumption that `x == x`. Because of this assumption, the identity is compared first (since it's faster) while comparing two elements, and the values are compared only when the identities mismatch. The following snippet will make things clearer, + + ```py + >>> x = float('nan') + >>> x == x, [x] == [x] + (False, True) + >>> y = float('nan') + >>> y == y, [y] == [y] + (False, True) + >>> x == y, [x] == [y] + (False, False) + ``` + + Since the identities of `x` and `y` are different, the values are considered, which are also different; hence the comparison returns `False` this time. + +- Interesting read: [Reflexivity, and other pillars of civilization](https://bertrandmeyer.com/2010/02/06/reflexivity-and-other-pillars-of-civilization/) + +--- + +### ▶ Mutating the immutable! + + + +This might seem trivial if you know how references work in Python. + +```py +some_tuple = ("A", "tuple", "with", "values") +another_tuple = ([1, 2], [3, 4], [5, 6]) +``` + +**Output:** +```py +>>> 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]) +``` + +But I thought tuples were immutable... + +#### 💡 Explanation: + +* Quoting from https://docs.python.org/3/reference/datamodel.html + + > Immutable sequences + An object of an immutable sequence type cannot change once it is created. (If the object contains references to other objects, these other objects may be mutable and may be modified; however, the collection of objects directly referenced by an immutable object cannot change.) + +* `+=` operator changes the list in-place. The item assignment doesn't work, but when the exception occurs, the item has already been changed in place. +* There's also an explanation in [official Python FAQ](https://docs.python.org/3/faq/programming.html#why-does-a-tuple-i-item-raise-an-exception-when-the-addition-works). + +--- + +### ▶ The disappearing variable from outer scope + + +```py +e = 7 +try: + raise Exception() +except Exception as e: + pass +``` + +**Output (Python 2.x):** +```py +>>> print(e) +# prints nothing +``` + +**Output (Python 3.x):** +```py +>>> print(e) +NameError: name 'e' is not defined +``` + +#### 💡 Explanation: + +* Source: https://docs.python.org/3/reference/compound_stmts.html#except + + When an exception has been assigned using `as` target, it is cleared at the end of the `except` clause. This is as if + + ```py + except E as N: + foo + ``` + + was translated into + + ```py + except E as N: + try: + foo + finally: + del N + ``` + + This means the exception must be assigned to a different name to be able to refer to it after the except clause. Exceptions are cleared because, with the traceback attached to them, they form a reference cycle with the stack frame, keeping all locals in that frame alive until the next garbage collection occurs. + +* The clauses are not scoped in Python. Everything in the example is present in the same scope, and the variable `e` got removed due to the execution of the `except` clause. The same is not the case with functions that have their separate inner-scopes. The example below illustrates this: + + ```py + def f(x): + del(x) + print(x) + + x = 5 + y = [5, 4, 3] + ``` + + **Output:** + ```py + >>> f(x) + UnboundLocalError: local variable 'x' referenced before assignment + >>> f(y) + UnboundLocalError: local variable 'x' referenced before assignment + >>> x + 5 + >>> y + [5, 4, 3] + ``` + +* In Python 2.x, the variable name `e` gets assigned to `Exception()` instance, so when you try to print, it prints nothing. + + **Output (Python 2.x):** + ```py + >>> e + Exception() + >>> print e + # Nothing is printed! + ``` + +--- + + +### ▶ The mysterious key type conversion + +```py +class SomeClass(str): + pass + +some_dict = {'s': 42} +``` + +**Output:** +```py +>>> 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 +``` + +#### 💡 Explanation: + +* Both the object `s` and the string `"s"` hash to the same value because `SomeClass` inherits the `__hash__` method of `str` class. +* `SomeClass("s") == "s"` evaluates to `True` because `SomeClass` also inherits `__eq__` method from `str` class. +* Since both the objects hash to the same value and are equal, they are represented by the same key in the dictionary. +* For the desired behavior, we can redefine the `__eq__` method in `SomeClass` + ```py + class SomeClass(str): + def __eq__(self, other): + return ( + type(self) is SomeClass + and type(other) is SomeClass + and super().__eq__(other) + ) + + # When we define a custom __eq__, Python stops automatically inheriting the + # __hash__ method, so we need to define it as well + __hash__ = str.__hash__ + + some_dict = {'s':42} + ``` + + **Output:** + ```py + >>> 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) + ``` + +--- + +### ▶ Let's see if you can guess this? + +```py +a, b = a[b] = {}, 5 +``` + +**Output:** +```py +>>> a +{5: ({...}, 5)} +``` + +#### 💡 Explanation: + +* According to [Python language reference](https://docs.python.org/3/reference/simple_stmts.html#assignment-statements), assignment statements have the form + ``` + (target_list "=")+ (expression_list | yield_expression) + ``` + and + +> An assignment statement evaluates the expression list (remember that this can be a single expression or a comma-separated list, the latter yielding a tuple) and assigns the single resulting object to each of the target lists, from left to right. + +* The `+` in `(target_list "=")+` means there can be **one or more** target lists. In this case, target lists are `a, b` and `a[b]` (note the expression list is exactly one, which in our case is `{}, 5`). + +* After the expression list is evaluated, its value is unpacked to the target lists from **left to right**. So, in our case, first the `{}, 5` tuple is unpacked to `a, b` and we now have `a = {}` and `b = 5`. + +* `a` is now assigned to `{}`, which is a mutable object. + +* The second target list is `a[b]` (you may expect this to throw an error because both `a` and `b` have not been defined in the statements before. But remember, we just assigned `a` to `{}` and `b` to `5`). + +* Now, we are setting the key `5` in the dictionary to the tuple `({}, 5)` creating a circular reference (the `{...}` in the output refers to the same object that `a` is already referencing). Another simpler example of circular reference could be + ```py + >>> 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 + ``` + Similar is the case in our example (`a[b][0]` is the same object as `a`) + +* So to sum it up, you can break the example down to + ```py + a, b = {}, 5 + a[b] = a, b + ``` + And the circular reference can be justified by the fact that `a[b][0]` is the same object as `a` + ```py + >>> a[b][0] is a + True + ``` + + +--- + +### ▶ Exceeds the limit for integer string conversion +```py +>>> # Python 3.10.6 +>>> int("2" * 5432) + +>>> # Python 3.10.8 +>>> int("2" * 5432) +``` + +**Output:** +```py +>>> # 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. +``` + +#### 💡 Explanation: +This call to `int()` works fine in Python 3.10.6 and raises a ValueError in Python 3.10.8. Note that Python can still work with large integers. The error is only raised when converting between integers and strings. + +Fortunately, you can increase the limit for the allowed number of digits when you expect an operation to exceed it. To do this, you can use one of the following: +- The -X int_max_str_digits command-line flag +- The set_int_max_str_digits() function from the sys module +- The PYTHONINTMAXSTRDIGITS environment variable + +[Check the documentation](https://docs.python.org/3/library/stdtypes.html#int-max-str-digits) for more details on changing the default limit if you expect your code to exceed this value. + + +--- + + +## Section: Slippery Slopes + +### ▶ Modifying a dictionary while iterating over it + +```py +x = {0: None} + +for i in x: + del x[i] + x[i+1] = None + print(i) +``` + +**Output (Python 2.7- Python 3.5):** + +``` +0 +1 +2 +3 +4 +5 +6 +7 +``` + +Yes, it runs for exactly **eight** times and stops. + +#### 💡 Explanation: + +* Iteration over a dictionary that you edit at the same time is not supported. +* It runs eight times because that's the point at which the dictionary resizes to hold more keys (we have eight deletion entries, so a resize is needed). This is actually an implementation detail. +* How deleted keys are handled and when the resize occurs might be different for different Python implementations. +* So for Python versions other than Python 2.7 - Python 3.5, the count might be different from 8 (but whatever the count is, it's going to be the same every time you run it). You can find some discussion around this [here](https://github.com/satwikkansal/wtfpython/issues/53) or in [this](https://stackoverflow.com/questions/44763802/bug-in-python-dict) StackOverflow thread. +* Python 3.7.6 onwards, you'll see `RuntimeError: dictionary keys changed during iteration` exception if you try to do this. + +--- + +### ▶ Stubborn `del` operation + + + +```py +class SomeClass: + def __del__(self): + print("Deleted!") +``` + +**Output:** +1\. +```py +>>> x = SomeClass() +>>> y = x +>>> del x # this should print "Deleted!" +>>> del y +Deleted! +``` + +Phew, deleted at last. You might have guessed what saved `__del__` from being called in our first attempt to delete `x`. Let's add more twists to the example. + +2\. +```py +>>> x = SomeClass() +>>> y = x +>>> del x +>>> y # check if y exists +<__main__.SomeClass instance at 0x7f98a1a67fc8> +>>> del y # Like previously, this should print "Deleted!" +>>> globals() # oh, it didn't. Let's check all our global variables and confirm +Deleted! +{'__builtins__': , 'SomeClass': , '__package__': None, '__name__': '__main__', '__doc__': None} +``` + +Okay, now it's deleted :confused: + +#### 💡 Explanation: ++ `del x` doesn’t directly call `x.__del__()`. ++ When `del x` is encountered, Python deletes the name `x` from current scope and decrements by 1 the reference count of the object `x` referenced. `__del__()` is called only when the object's reference count reaches zero. ++ In the second output snippet, `__del__()` was not called because the previous statement (`>>> y`) in the interactive interpreter created another reference to the same object (specifically, the `_` magic variable which references the result value of the last non `None` expression on the REPL), thus preventing the reference count from reaching zero when `del y` was encountered. ++ Calling `globals` (or really, executing anything that will have a non `None` result) caused `_` to reference the new result, dropping the existing reference. Now the reference count reached 0 and we can see "Deleted!" being printed (finally!). + +--- + +### ▶ The out of scope variable + + +1\. +```py +a = 1 +def some_func(): + return a + +def another_func(): + a += 1 + return a +``` + +2\. +```py +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() +``` + +**Output:** +```py +>>> 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 +``` + +#### 💡 Explanation: +* When you make an assignment to a variable in scope, it becomes local to that scope. So `a` becomes local to the scope of `another_func`, but it has not been initialized previously in the same scope, which throws an error. +* To modify the outer scope variable `a` in `another_func`, we have to use the `global` keyword. + ```py + def another_func() + global a + a += 1 + return a + ``` + + **Output:** + ```py + >>> another_func() + 2 + ``` +* In `another_closure_func`, `a` becomes local to the scope of `another_inner_func`, but it has not been initialized previously in the same scope, which is why it throws an error. +* To modify the outer scope variable `a` in `another_inner_func`, use the `nonlocal` keyword. The nonlocal statement is used to refer to variables defined in the nearest outer (excluding the global) scope. + ```py + def another_func(): + a = 1 + def another_inner_func(): + nonlocal a + a += 1 + return a + return another_inner_func() + ``` + + **Output:** + ```py + >>> another_func() + 2 + ``` +* The keywords `global` and `nonlocal` tell the python interpreter to not declare new variables and look them up in the corresponding outer scopes. +* Read [this](https://sebastianraschka.com/Articles/2014_python_scope_and_namespaces.html) short but an awesome guide to learn more about how namespaces and scope resolution works in Python. + +--- + +### ▶ Deleting a list item while iterating + +```py +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) +``` + +**Output:** +```py +>>> list_1 +[1, 2, 3, 4] +>>> list_2 +[2, 4] +>>> list_3 +[] +>>> list_4 +[2, 4] +``` + +Can you guess why the output is `[2, 4]`? + +#### 💡 Explanation: + +* It's never a good idea to change the object you're iterating over. The correct way to do so is to iterate over a copy of the object instead, and `list_3[:]` does just that. + + ```py + >>> some_list = [1, 2, 3, 4] + >>> id(some_list) + 139798789457608 + >>> id(some_list[:]) # Notice that python creates new object for sliced list. + 139798779601192 + ``` + +**Difference between `del`, `remove`, and `pop`:** +* `del var_name` just removes the binding of the `var_name` from the local or global namespace (That's why the `list_1` is unaffected). +* `remove` removes the first matching value, not a specific index, raises `ValueError` if the value is not found. +* `pop` removes the element at a specific index and returns it, raises `IndexError` if an invalid index is specified. + +**Why the output is `[2, 4]`?** +- The list iteration is done index by index, and when we remove `1` from `list_2` or `list_4`, the contents of the lists are now `[2, 3, 4]`. The remaining elements are shifted down, i.e., `2` is at index 0, and `3` is at index 1. Since the next iteration is going to look at index 1 (which is the `3`), the `2` gets skipped entirely. A similar thing will happen with every alternate element in the list sequence. + +* Refer to this StackOverflow [thread](https://stackoverflow.com/questions/45946228/what-happens-when-you-try-to-delete-a-list-element-while-iterating-over-it) explaining the example +* See also this nice StackOverflow [thread](https://stackoverflow.com/questions/45877614/how-to-change-all-the-dictionary-keys-in-a-for-loop-with-d-items) for a similar example related to dictionaries in Python. + +--- + + +### ▶ Lossy zip of iterators * + + +```py +>>> 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)] +``` +Where did element `3` go from the `numbers` list? + +#### 💡 Explanation: + +- From Python [docs](https://docs.python.org/3.3/library/functions.html#zip), here's an approximate implementation of zip function, + ```py + 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) + ``` +- So the function takes in arbitrary number of iterable objects, adds each of their items to the `result` list by calling the `next` function on them, and stops whenever any of the iterable is exhausted. +- The caveat here is when any iterable is exhausted, the existing elements in the `result` list are discarded. That's what happened with `3` in the `numbers_iter`. +- The correct way to do the above using `zip` would be, + ```py + >>> 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)] + ``` + The first argument of zip should be the one with fewest elements. + +--- + +### ▶ Loop variables leaking out! + +1\. +```py +for x in range(7): + if x == 6: + print(x, ': for x inside loop') +print(x, ': x in global') +``` + +**Output:** +```py +6 : for x inside loop +6 : x in global +``` + +But `x` was never defined outside the scope of for loop... + +2\. +```py +# This time let's initialize x first +x = -1 +for x in range(7): + if x == 6: + print(x, ': for x inside loop') +print(x, ': x in global') +``` + +**Output:** +```py +6 : for x inside loop +6 : x in global +``` + +3\. + +**Output (Python 2.x):** +```py +>>> x = 1 +>>> print([x for x in range(5)]) +[0, 1, 2, 3, 4] +>>> print(x) +4 +``` + +**Output (Python 3.x):** +```py +>>> x = 1 +>>> print([x for x in range(5)]) +[0, 1, 2, 3, 4] +>>> print(x) +1 +``` + +#### 💡 Explanation: + +- In Python, for-loops use the scope they exist in and leave their defined loop-variable behind. This also applies if we explicitly defined the for-loop variable in the global namespace before. In this case, it will rebind the existing variable. + +- The differences in the output of Python 2.x and Python 3.x interpreters for list comprehension example can be explained by following change documented in [What’s New In Python 3.0](https://docs.python.org/3/whatsnew/3.0.html) changelog: + + > "List comprehensions no longer support the syntactic form `[... for var in item1, item2, ...]`. Use `[... for var in (item1, item2, ...)]` instead. Also, note that list comprehensions have different semantics: they are closer to syntactic sugar for a generator expression inside a `list()` constructor, and in particular, the loop control variables are no longer leaked into the surrounding scope." + +--- + +### ▶ Beware of default mutable arguments! + + +```py +def some_func(default_arg=[]): + default_arg.append("some_string") + return default_arg +``` + +**Output:** +```py +>>> some_func() +['some_string'] +>>> some_func() +['some_string', 'some_string'] +>>> some_func([]) +['some_string'] +>>> some_func() +['some_string', 'some_string', 'some_string'] +``` + +#### 💡 Explanation: + +- The default mutable arguments of functions in Python aren't really initialized every time you call the function. Instead, the recently assigned value to them is used as the default value. When we explicitly passed `[]` to `some_func` as the argument, the default value of the `default_arg` variable was not used, so the function returned as expected. + + ```py + def some_func(default_arg=[]): + default_arg.append("some_string") + return default_arg + ``` + + **Output:** + ```py + >>> some_func.__defaults__ #This will show the default argument values for the function + ([],) + >>> 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'],) + ``` + +- A common practice to avoid bugs due to mutable arguments is to assign `None` as the default value and later check if any value is passed to the function corresponding to that argument. Example: + + ```py + def some_func(default_arg=None): + if default_arg is None: + default_arg = [] + default_arg.append("some_string") + return default_arg + ``` + +--- + +### ▶ Catching the Exceptions + +```py +some_list = [1, 2, 3] +try: + # This should raise an ``IndexError`` + print(some_list[4]) +except IndexError, ValueError: + print("Caught!") + +try: + # This should raise a ``ValueError`` + some_list.remove(4) +except IndexError, ValueError: + print("Caught again!") +``` + +**Output (Python 2.x):** +```py +Caught! + +ValueError: list.remove(x): x not in list +``` + +**Output (Python 3.x):** +```py + File "", line 3 + except IndexError, ValueError: + ^ +SyntaxError: invalid syntax +``` + +#### 💡 Explanation + +* 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, + ```py + some_list = [1, 2, 3] + try: + # This should raise a ``ValueError`` + some_list.remove(4) + except (IndexError, ValueError), e: + print("Caught again!") + print(e) + ``` + **Output (Python 2.x):** + ``` + Caught again! + list.remove(x): x not in list + ``` + **Output (Python 3.x):** + ```py + File "", 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, + ```py + some_list = [1, 2, 3] + try: + some_list.remove(4) + + except (IndexError, ValueError) as e: + print("Caught again!") + print(e) + ``` + **Output:** + ``` + Caught again! + list.remove(x): x not in list + ``` + +--- + +### ▶ Same operands, different story! + +1\. +```py +a = [1, 2, 3, 4] +b = a +a = a + [5, 6, 7, 8] +``` + +**Output:** +```py +>>> a +[1, 2, 3, 4, 5, 6, 7, 8] +>>> b +[1, 2, 3, 4] +``` + +2\. +```py +a = [1, 2, 3, 4] +b = a +a += [5, 6, 7, 8] +``` + +**Output:** +```py +>>> a +[1, 2, 3, 4, 5, 6, 7, 8] +>>> b +[1, 2, 3, 4, 5, 6, 7, 8] +``` + +#### 💡 Explanation: + +* `a += b` doesn't always behave the same way as `a = a + b`. Classes *may* implement the *`op=`* operators differently, and lists do this. + +* The expression `a = a + [5,6,7,8]` generates a new list and sets `a`'s reference to that new list, leaving `b` unchanged. + +* The expression `a += [5,6,7,8]` is actually mapped to an "extend" function that operates on the list such that `a` and `b` still point to the same list that has been modified in-place. + +--- + +### ▶ Name resolution ignoring class scope + +1\. +```py +x = 5 +class SomeClass: + x = 17 + y = (x for i in range(10)) +``` + +**Output:** +```py +>>> list(SomeClass.y)[0] +5 +``` + +2\. +```py +x = 5 +class SomeClass: + x = 17 + y = [x for i in range(10)] +``` + +**Output (Python 2.x):** +```py +>>> SomeClass.y[0] +17 +``` + +**Output (Python 3.x):** +```py +>>> SomeClass.y[0] +5 +``` + +#### 💡 Explanation +- Scopes nested inside class definition ignore names bound at the class level. +- A generator expression has its own scope. +- Starting from Python 3.X, list comprehensions also have their own scope. + +--- + +### ▶ Rounding like a banker * + +Let's implement a naive function to get the middle element of a list: +```py +def get_middle(some_list): + mid_index = round(len(some_list) / 2) + return some_list[mid_index - 1] +``` + +**Python 3.x:** +```py +>>> get_middle([1]) # looks good +1 +>>> get_middle([1,2,3]) # looks good +2 +>>> get_middle([1,2,3,4,5]) # huh? +2 +>>> len([1,2,3,4,5]) / 2 # good +2.5 +>>> round(len([1,2,3,4,5]) / 2) # why? +2 +``` +It seems as though Python rounded 2.5 to 2. + +#### 💡 Explanation: + +- This is not a float precision error, in fact, this behavior is intentional. Since Python 3.0, `round()` uses [banker's rounding](https://en.wikipedia.org/wiki/Rounding#Rounding_half_to_even) where .5 fractions are rounded to the nearest **even** number: + +```py +>>> round(0.5) +0 +>>> round(1.5) +2 +>>> round(2.5) +2 +>>> import numpy # numpy does the same +>>> numpy.round(0.5) +0.0 +>>> numpy.round(1.5) +2.0 +>>> numpy.round(2.5) +2.0 +``` + +- This is the recommended way to round .5 fractions as described in [IEEE 754](https://en.wikipedia.org/wiki/IEEE_754#Rounding_rules). However, the other way (round away from zero) is taught in school most of the time, so banker's rounding is likely not that well known. Furthermore, some of the most popular programming languages (for example: JavaScript, Java, C/C++, Ruby, Rust) do not use banker's rounding either. Therefore, this is still quite special to Python and may result in confusion when rounding fractions. +- See the [round() docs](https://docs.python.org/3/library/functions.html#round) or [this stackoverflow thread](https://stackoverflow.com/questions/10825926/python-3-x-rounding-behavior) for more information. +- Note that `get_middle([1])` only returned 1 because the index was `round(0.5) - 1 = 0 - 1 = -1`, returning the last element in the list. + +--- + +### ▶ Needles in a Haystack * + + + +I haven't met even a single experience Pythonist till date who has not come across one or more of the following scenarios, + +1\. + +```py +x, y = (0, 1) if True else None, None +``` + +**Output:** + +```py +>>> x, y # expected (0, 1) +((0, 1), None) +``` + +2\. + +```py +t = ('one', 'two') +for i in t: + print(i) + +t = ('one') +for i in t: + print(i) + +t = () +print(t) +``` + +**Output:** + +```py +one +two +o +n +e +tuple() +``` + +3\. + +``` +ten_words_list = [ + "some", + "very", + "big", + "list", + "that" + "consists", + "of", + "exactly", + "ten", + "words" +] +``` + +**Output** + +```py +>>> len(ten_words_list) +9 +``` + +4\. Not asserting strongly enough + +```py +a = "python" +b = "javascript" +``` + +**Output:** + +```py +# An assert statement with an assertion failure message. +>>> assert(a == b, "Both languages are different") +# No AssertionError is raised +``` + +5\. + +```py +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}) +``` + +**Output:** + +```py +>>> print(some_list) +None +>>> print(some_dict) +None +``` + +6\. + +```py +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 +``` + +**Output:** + +```py +>>> some_recursive_func([5, 0]) +[0, 0] +>>> similar_recursive_func(5) +4 +``` + +#### 💡 Explanation: + +* For 1, the correct statement for expected behavior is `x, y = (0, 1) if True else (None, None)`. + +* For 2, the correct statement for expected behavior is `t = ('one',)` or `t = 'one',` (missing comma) otherwise the interpreter considers `t` to be a `str` and iterates over it character by character. + +* `()` is a special token and denotes empty `tuple`. + +* In 3, as you might have already figured out, there's a missing comma after 5th element (`"that"`) in the list. So by implicit string literal concatenation, + + ```py + >>> ten_words_list + ['some', 'very', 'big', 'list', 'thatconsists', 'of', 'exactly', 'ten', 'words'] + ``` + +* No `AssertionError` was raised in 4th snippet because instead of asserting the individual expression `a == b`, we're asserting entire tuple. The following snippet will clear things up, + + ```py + >>> a = "python" + >>> b = "javascript" + >>> assert a == b + Traceback (most recent call last): + File "", line 1, in + AssertionError + + >>> assert (a == b, "Values are not equal") + :1: SyntaxWarning: assertion is always true, perhaps remove parentheses? + + >>> assert a == b, "Values are not equal" + Traceback (most recent call last): + File "", line 1, in + AssertionError: Values are not equal + ``` + +* As for the fifth snippet, most methods that modify the items of sequence/mapping objects like `list.append`, `dict.update`, `list.sort`, etc. modify the objects in-place and return `None`. The rationale behind this is to improve performance by avoiding making a copy of the object if the operation can be done in-place (Referred from [here](https://docs.python.org/3/faq/design.html#why-doesn-t-list-sort-return-the-sorted-list)). + +* Last one should be fairly obvious, mutable object (like `list`) can be altered in the function, and the reassignment of an immutable (`a -= 1`) is not an alteration of the value. + +* Being aware of these nitpicks can save you hours of debugging effort in the long run. + +--- + + +### ▶ Splitsies * + +```py +>>> 'a'.split() +['a'] + +# is same as +>>> 'a'.split(' ') +['a'] + +# but +>>> len(''.split()) +0 + +# isn't the same as +>>> len(''.split(' ')) +1 +``` + +#### 💡 Explanation: + +- It might appear at first that the default separator for split is a single space `' '`, but as per the [docs](https://docs.python.org/3/library/stdtypes.html#str.split) + > If sep is not specified or is `None`, a different splitting algorithm is applied: runs of consecutive whitespace are regarded as a single separator, and the result will contain no empty strings at the start or end if the string has leading or trailing whitespace. Consequently, splitting an empty string or a string consisting of just whitespace with a None separator returns `[]`. + > If sep is given, consecutive delimiters are not grouped together and are deemed to delimit empty strings (for example, `'1,,2'.split(',')` returns `['1', '', '2']`). Splitting an empty string with a specified separator returns `['']`. +- Noticing how the leading and trailing whitespaces are handled in the following snippet will make things clear, + ```py + >>> ' a '.split(' ') + ['', 'a', ''] + >>> ' a '.split() + ['a'] + >>> ''.split(' ') + [''] + ``` + +--- + +### ▶ Wild imports * + + + +```py +# File: module.py + +def some_weird_name_func_(): + print("works!") + +def _another_weird_name_func(): + print("works!") + +``` + +**Output** + +```py +>>> from module import * +>>> some_weird_name_func_() +"works!" +>>> _another_weird_name_func() +Traceback (most recent call last): + File "", line 1, in +NameError: name '_another_weird_name_func' is not defined +``` + +#### 💡 Explanation: + +- It is often advisable to not use wildcard imports. The first obvious reason for this is, in wildcard imports, the names with a leading underscore don't get imported. This may lead to errors during runtime. +- Had we used `from ... import a, b, c` syntax, the above `NameError` wouldn't have occurred. + ```py + >>> from module import some_weird_name_func_, _another_weird_name_func + >>> _another_weird_name_func() + works! + ``` +- If you really want to use wildcard imports, then you'd have to define the list `__all__` in your module that will contain a list of public objects that'll be available when we do wildcard imports. + ```py + __all__ = ['_another_weird_name_func'] + + def some_weird_name_func_(): + print("works!") + + def _another_weird_name_func(): + print("works!") + ``` + **Output** + + ```py + >>> _another_weird_name_func() + "works!" + >>> some_weird_name_func_() + Traceback (most recent call last): + File "", line 1, in + NameError: name 'some_weird_name_func_' is not defined + ``` + +--- + +### ▶ All sorted? * + + + +```py +>>> x = 7, 8, 9 +>>> sorted(x) == x +False +>>> sorted(x) == sorted(x) +True + +>>> y = reversed(x) +>>> sorted(y) == sorted(y) +False +``` + +#### 💡 Explanation: + +- The `sorted` method always returns a list, and comparing lists and tuples always returns `False` in Python. + +- ```py + >>> [] == tuple() + False + >>> x = 7, 8, 9 + >>> type(x), type(sorted(x)) + (tuple, list) + ``` + +- Unlike `sorted`, the `reversed` method returns an iterator. Why? Because sorting requires the iterator to be either modified in-place or use an extra container (a list), whereas reversing can simply work by iterating from the last index to the first. + +- So during comparison `sorted(y) == sorted(y)`, the first call to `sorted()` will consume the iterator `y`, and the next call will just return an empty list. + + ```py + >>> x = 7, 8, 9 + >>> y = reversed(x) + >>> sorted(y), sorted(y) + ([7, 8, 9], []) + ``` + +--- + +### ▶ Midnight time doesn't exist? + +```py +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) +``` + +**Output (< 3.5):** + +```py +('Time at noon is', datetime.time(12, 0)) +``` +The midnight time is not printed. + +#### 💡 Explanation: + +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." + +--- +--- + + + +## Section: The Hidden treasures! + +This section contains a few lesser-known and interesting things about Python that most beginners like me are unaware of (well, not anymore). + +### ▶ Okay Python, Can you make me fly? + +Well, here you go + +```py +import antigravity +``` + +**Output:** +Sshh... It's a super-secret. + +#### 💡 Explanation: ++ `antigravity` module is one of the few easter eggs released by Python developers. ++ `import antigravity` opens up a web browser pointing to the [classic XKCD comic](https://xkcd.com/353/) about Python. ++ Well, there's more to it. There's **another easter egg inside the easter egg**. If you look at the [code](https://github.com/python/cpython/blob/master/Lib/antigravity.py#L7-L17), there's a function defined that purports to implement the [XKCD's geohashing algorithm](https://xkcd.com/426/). + +--- + +### ▶ `goto`, but why? + + +```py +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 # breaking out from a deeply nested loop +label .breakout +print("Freedom!") +``` + +**Output (Python 2.3):** +```py +I am trapped, please rescue! +I am trapped, please rescue! +Freedom! +``` + +#### 💡 Explanation: +- A working version of `goto` in Python was [announced](https://mail.python.org/pipermail/python-announce-list/2004-April/002982.html) as an April Fool's joke on 1st April 2004. +- Current versions of Python do not have this module. +- Although it works, but please don't use it. Here's the [reason](https://docs.python.org/3/faq/design.html#why-is-there-no-goto) to why `goto` is not present in Python. + +--- + +### ▶ Brace yourself! + +If you are one of the people who doesn't like using whitespace in Python to denote scopes, you can use the C-style {} by importing, + +```py +from __future__ import braces +``` + +**Output:** +```py + File "some_file.py", line 1 + from __future__ import braces +SyntaxError: not a chance +``` + +Braces? No way! If you think that's disappointing, use Java. Okay, another surprising thing, can you find where's the `SyntaxError` raised in `__future__` module [code](https://github.com/python/cpython/blob/master/Lib/__future__.py)? + +#### 💡 Explanation: ++ The `__future__` module is normally used to provide features from future versions of Python. The "future" in this specific context is however, ironic. ++ This is an easter egg concerned with the community's feelings on this issue. ++ The code is actually present [here](https://github.com/python/cpython/blob/025eb98dc0c1dc27404df6c544fc2944e0fa9f3a/Python/future.c#L49) in `future.c` file. ++ When the CPython compiler encounters a [future statement](https://docs.python.org/3.3/reference/simple_stmts.html#future-statements), it first runs the appropriate code in `future.c` before treating it as a normal import statement. + +--- + +### ▶ Let's meet Friendly Language Uncle For Life + +**Output (Python 3.x)** +```py +>>> from __future__ import barry_as_FLUFL +>>> "Ruby" != "Python" # there's no doubt about it + File "some_file.py", line 1 + "Ruby" != "Python" + ^ +SyntaxError: invalid syntax + +>>> "Ruby" <> "Python" +True +``` + +There we go. + +#### 💡 Explanation: +- This is relevant to [PEP-401](https://www.python.org/dev/peps/pep-0401/) released on April 1, 2009 (now you know, what it means). +- Quoting from the PEP-401 + + > Recognized that the != inequality operator in Python 3.0 was a horrible, finger-pain inducing mistake, the FLUFL reinstates the <> diamond operator as the sole spelling. +- There were more things that Uncle Barry had to share in the PEP; you can read them [here](https://www.python.org/dev/peps/pep-0401/). +- It works well in an interactive environment, but it will raise a `SyntaxError` when you run via python file (see this [issue](https://github.com/satwikkansal/wtfpython/issues/94)). However, you can wrap the statement inside an `eval` or `compile` to get it working, + ```py + from __future__ import barry_as_FLUFL + print(eval('"Ruby" <> "Python"')) + ``` + +--- + +### ▶ Even Python understands that love is complicated + +```py +import this +``` + +Wait, what's **this**? `this` is love :heart: + +**Output:** +``` +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! +``` + +It's the Zen of Python! + +```py +>>> 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 # Love is complicated +True +``` + +#### 💡 Explanation: + +* `this` module in Python is an easter egg for The Zen Of Python ([PEP 20](https://www.python.org/dev/peps/pep-0020)). +* And if you think that's already interesting enough, check out the implementation of [this.py](https://hg.python.org/cpython/file/c3896275c0f6/Lib/this.py). Interestingly, **the code for the Zen violates itself** (and that's probably the only place where this happens). +* Regarding the statement `love is not True or False; love is love`, ironic but it's self-explanatory (if not, please see the examples related to `is` and `is not` operators). + +--- + +### ▶ Yes, it exists! + +**The `else` clause for loops.** One typical example might be: + +```py + def does_exists_num(l, to_find): + for num in l: + if num == to_find: + print("Exists!") + break + else: + print("Does not exist") +``` + +**Output:** +```py +>>> some_list = [1, 2, 3, 4, 5] +>>> does_exists_num(some_list, 4) +Exists! +>>> does_exists_num(some_list, -1) +Does not exist +``` + +**The `else` clause in exception handling.** An example, + +```py +try: + pass +except: + print("Exception occurred!!!") +else: + print("Try block executed successfully...") +``` + +**Output:** +```py +Try block executed successfully... +``` + +#### 💡 Explanation: +- The `else` clause after a loop is executed only when there's no explicit `break` after all the iterations. You can think of it as a "nobreak" clause. +- `else` clause after a try block is also called "completion clause" as reaching the `else` clause in a `try` statement means that the try block actually completed successfully. + +--- +### ▶ Ellipsis * + +```py +def some_func(): + Ellipsis +``` + +**Output** +```py +>>> some_func() +# No output, No Error + +>>> SomeRandomString +Traceback (most recent call last): + File "", line 1, in +NameError: name 'SomeRandomString' is not defined + +>>> Ellipsis +Ellipsis +``` + +#### 💡 Explanation +- In Python, `Ellipsis` is a globally available built-in object which is equivalent to `...`. + ```py + >>> ... + Ellipsis + ``` +- Ellipsis can be used for several purposes, + + As a placeholder for code that hasn't been written yet (just like `pass` statement) + + In slicing syntax to represent the full slices in remaining direction + ```py + >>> import numpy as np + >>> three_dimensional_array = np.arange(8).reshape(2, 2, 2) + array([ + [ + [0, 1], + [2, 3] + ], + + [ + [4, 5], + [6, 7] + ] + ]) + ``` + So our `three_dimensional_array` is an array of array of arrays. Let's say we want to print the second element (index `1`) of all the innermost arrays, we can use Ellipsis to bypass all the preceding dimensions + ```py + >>> three_dimensional_array[:,:,1] + array([[1, 3], + [5, 7]]) + >>> three_dimensional_array[..., 1] # using Ellipsis. + array([[1, 3], + [5, 7]]) + ``` + Note: this will work for any number of dimensions. You can even select slice in first and last dimension and ignore the middle ones this way (`n_dimensional_array[firs_dim_slice, ..., last_dim_slice]`) + + In [type hinting](https://docs.python.org/3/library/typing.html) to indicate only a part of the type (like `(Callable[..., int]` or `Tuple[str, ...]`)) + + You may also use Ellipsis as a default function argument (in the cases when you want to differentiate between the "no argument passed" and "None value passed" scenarios). + +--- + +### ▶ Inpinity + +The spelling is intended. Please, don't submit a patch for this. + +**Output (Python 3.x):** +```py +>>> infinity = float('infinity') +>>> hash(infinity) +314159 +>>> hash(float('-inf')) +-314159 +``` + +#### 💡 Explanation: +- Hash of infinity is 10⁵ x π. +- Interestingly, the hash of `float('-inf')` is "-10⁵ x π" in Python 3, whereas "-10⁵ x e" in Python 2. + +--- + +### ▶ Let's mangle + +1\. +```py +class Yo(object): + def __init__(self): + self.__honey = True + self.bro = True +``` + +**Output:** +```py +>>> Yo().bro +True +>>> Yo().__honey +AttributeError: 'Yo' object has no attribute '__honey' +>>> Yo()._Yo__honey +True +``` + +2\. +```py +class Yo(object): + def __init__(self): + # Let's try something symmetrical this time + self.__honey__ = True + self.bro = True +``` + +**Output:** +```py +>>> Yo().bro +True + +>>> Yo()._Yo__honey__ +Traceback (most recent call last): + File "", line 1, in +AttributeError: 'Yo' object has no attribute '_Yo__honey__' +``` + +Why did `Yo()._Yo__honey` work? + +3\. + +```py +_A__variable = "Some value" + +class A(object): + def some_func(self): + return __variable # not initialized anywhere yet +``` + +**Output:** +```py +>>> A().__variable +Traceback (most recent call last): + File "", line 1, in +AttributeError: 'A' object has no attribute '__variable' + +>>> A().some_func() +'Some value' +``` + + +#### 💡 Explanation: + +* [Name Mangling](https://en.wikipedia.org/wiki/Name_mangling) is used to avoid naming collisions between different namespaces. +* In Python, the interpreter modifies (mangles) the class member names starting with `__` (double underscore a.k.a "dunder") and not ending with more than one trailing underscore by adding `_NameOfTheClass` in front. +* So, to access `__honey` attribute in the first snippet, we had to append `_Yo` to the front, which would prevent conflicts with the same name attribute defined in any other class. +* But then why didn't it work in the second snippet? Because name mangling excludes the names ending with double underscores. +* The third snippet was also a consequence of name mangling. The name `__variable` in the statement `return __variable` was mangled to `_A__variable`, which also happens to be the name of the variable we declared in the outer scope. +* Also, if the mangled name is longer than 255 characters, truncation will happen. + +--- +--- + +## Section: Appearances are deceptive! + +### ▶ Skipping lines? + +**Output:** +```py +>>> value = 11 +>>> valuе = 32 +>>> value +11 +``` + +Wut? + +**Note:** The easiest way to reproduce this is to simply copy the statements from the above snippet and paste them into your file/shell. + +#### 💡 Explanation + +Some non-Western characters look identical to letters in the English alphabet but are considered distinct by the interpreter. + +```py +>>> ord('е') # cyrillic 'e' (Ye) +1077 +>>> ord('e') # latin 'e', as used in English and typed using standard keyboard +101 +>>> 'е' == 'e' +False + +>>> value = 42 # latin e +>>> valuе = 23 # cyrillic 'e', Python 2.x interpreter would raise a `SyntaxError` here +>>> value +42 +``` + +The built-in `ord()` function returns a character's Unicode [code point](https://en.wikipedia.org/wiki/Code_point), and different code positions of Cyrillic 'e' and Latin 'e' justify the behavior of the above example. + +--- + +### ▶ Teleportation + + + +```py +# `pip install numpy` first. +import numpy as np + +def energy_send(x): + # Initializing a numpy array + np.array([float(x)]) + +def energy_receive(): + # Return an empty numpy array + return np.empty((), dtype=np.float).tolist() +``` + +**Output:** +```py +>>> energy_send(123.456) +>>> energy_receive() +123.456 +``` + +Where's the Nobel Prize? + +#### 💡 Explanation: + +* Notice that the numpy array created in the `energy_send` function is not returned, so that memory space is free to reallocate. +* `numpy.empty()` returns the next free memory slot without reinitializing it. This memory spot just happens to be the same one that was just freed (usually, but not always). + +--- + +### ▶ Well, something is fishy... + +```py +def square(x): + """ + A simple function to calculate the square of a number by addition. + """ + sum_so_far = 0 + for counter in range(x): + sum_so_far = sum_so_far + x + return sum_so_far +``` + +**Output (Python 2.x):** + +```py +>>> square(10) +10 +``` + +Shouldn't that be 100? + +**Note:** If you're not able to reproduce this, try running the file [mixed_tabs_and_spaces.py](/mixed_tabs_and_spaces.py) via the shell. + +#### 💡 Explanation + +* **Don't mix tabs and spaces!** The character just preceding return is a "tab", and the code is indented by multiple of "4 spaces" elsewhere in the example. +* This is how Python handles tabs: + + > First, tabs are replaced (from left to right) by one to eight spaces such that the total number of characters up to and including the replacement is a multiple of eight <...> +* So the "tab" at the last line of `square` function is replaced with eight spaces, and it gets into the loop. +* Python 3 is kind enough to throw an error for such cases automatically. + + **Output (Python 3.x):** + ```py + TabError: inconsistent use of tabs and spaces in indentation + ``` + +--- +--- + +## Section: Miscellaneous + + +### ▶ `+=` is faster + + +```py +# using "+", three strings: +>>> timeit.timeit("s1 = s1 + s2 + s3", setup="s1 = ' ' * 100000; s2 = ' ' * 100000; s3 = ' ' * 100000", number=100) +0.25748300552368164 +# using "+=", three strings: +>>> timeit.timeit("s1 += s2 + s3", setup="s1 = ' ' * 100000; s2 = ' ' * 100000; s3 = ' ' * 100000", number=100) +0.012188911437988281 +``` + +#### 💡 Explanation: ++ `+=` is faster than `+` for concatenating more than two strings because the first string (example, `s1` for `s1 += s2 + s3`) is not destroyed while calculating the complete string. + +--- + +### ▶ Let's make a giant string! + +```py +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 +``` + +**Output:** + +```py +# Executed in ipython shell using %timeit for better readability of results. +# You can also use the timeit module in normal python shell/scriptm=, example usage below +# 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) +``` + +Let's increase the number of iterations by a factor of 10. + +```py +>>> NUM_ITERS = 10000 +>>> %timeit -n1000 add_string_with_plus(NUM_ITERS) # Linear increase in execution time +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) # Quadratic increase +6.82 ms ± 134 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) +>>> %timeit -n1000 add_string_with_format(NUM_ITERS) # Linear increase +645 µs ± 24.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) +>>> %timeit -n1000 add_string_with_join(NUM_ITERS) # Linear increase +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) # Linear increase +86.3 µs ± 2 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) +``` + +#### 💡 Explanation +- You can read more about [timeit](https://docs.python.org/3/library/timeit.html) or [%timeit](https://ipython.org/ipython-doc/dev/interactive/magics.html#magic-timeit) on these links. They are used to measure the execution time of code pieces. +- Don't use `+` for generating long strings — In Python, `str` is immutable, so the left and right strings have to be copied into the new string for every pair of concatenations. If you concatenate four strings of length 10, you'll be copying (10+10) + ((10+10)+10) + (((10+10)+10)+10) = 90 characters instead of just 40 characters. Things get quadratically worse as the number and size of the string increases (justified with the execution times of `add_bytes_with_plus` function) +- Therefore, it's advised to use `.format.` or `%` syntax (however, they are slightly slower than `+` for very short strings). +- Or better, if already you've contents available in the form of an iterable object, then use `''.join(iterable_object)` which is much faster. +- Unlike `add_bytes_with_plus` because of the `+=` optimizations discussed in the previous example, `add_string_with_plus` didn't show a quadratic increase in execution time. Had the statement been `s = s + "x" + "y" + "z"` instead of `s += "xyz"`, the increase would have been quadratic. + ```py + 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) # Quadratic increase in execution time + 9 ms ± 298 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) + ``` +- So many ways to format and create a giant string are somewhat in contrast to the [Zen of Python](https://www.python.org/dev/peps/pep-0020/), according to which, + + > There should be one-- and preferably only one --obvious way to do it. + +--- + +### ▶ Slowing down `dict` lookups * + +```py +some_dict = {str(i): 1 for i in range(1_000_000)} +another_dict = {str(i): 1 for i in range(1_000_000)} +``` + +**Output:** +```py +>>> %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] # Trying to access a key that doesn't exist +Traceback (most recent call last): + File "", line 1, in +KeyError: 1 +>>> %timeit another_dict['5'] +38.5 ns ± 0.0913 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each) +``` +Why are same lookups becoming slower? + +#### 💡 Explanation: ++ CPython has a generic dictionary lookup function that handles all types of keys (`str`, `int`, any object ...), and a specialized one for the common case of dictionaries composed of `str`-only keys. ++ The specialized function (named `lookdict_unicode` in CPython's [source](https://github.com/python/cpython/blob/522691c46e2ae51faaad5bbbce7d959dd61770df/Objects/dictobject.c#L841)) knows all existing keys (including the looked-up key) are strings, and uses the faster & simpler string comparison to compare keys, instead of calling the `__eq__` method. ++ The first time a `dict` instance is accessed with a non-`str` key, it's modified so future lookups use the generic function. ++ This process is not reversible for the particular `dict` instance, and the key doesn't even have to exist in the dictionary. That's why attempting a failed lookup has the same effect. + + +### ▶ Bloating instance `dict`s * + +```py +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__) + +``` + +**Output:** (Python 3.8, other Python 3 versions may vary a little) +```py +>>> 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 +``` + +Let's try again... In a new interpreter: + +```py +>>> o1 = SomeClass() +>>> o2 = SomeClass() +>>> dict_size(o1) +104 # as expected +>>> o1.some_attr5 = 5 +>>> o1.some_attr6 = 6 +>>> dict_size(o1) +360 +>>> dict_size(o2) +272 +>>> o3 = SomeClass() +>>> dict_size(o3) +232 +``` + +What makes those dictionaries become bloated? And why are newly created objects bloated as well? + +#### 💡 Explanation: ++ CPython is able to reuse the same "keys" object in multiple dictionaries. This was added in [PEP 412](https://www.python.org/dev/peps/pep-0412/) with the motivation to reduce memory usage, specifically in dictionaries of instances - where keys (instance attributes) tend to be common to all instances. ++ This optimization is entirely seamless for instance dictionaries, but it is disabled if certain assumptions are broken. ++ Key-sharing dictionaries do not support deletion; if an instance attribute is deleted, the dictionary is "unshared", and key-sharing is disabled for all future instances of the same class. ++ Additionally, if the dictionary keys have been resized (because new keys are inserted), they are kept shared *only* if they are used by a exactly single dictionary (this allows adding many attributes in the `__init__` of the very first created instance, without causing an "unshare"). If multiple instances exist when a resize happens, key-sharing is disabled for all future instances of the same class: CPython can't tell if your instances are using the same set of attributes anymore, and decides to bail out on attempting to share their keys. ++ A small tip, if you aim to lower your program's memory footprint: don't delete instance attributes, and make sure to initialize all attributes in your `__init__`! + + +### ▶ Minor Ones * + +* `join()` is a string operation instead of list operation. (sort of counter-intuitive at first usage) + + **💡 Explanation:** If `join()` is a method on a string, then it can operate on any iterable (list, tuple, iterators). If it were a method on a list, it'd have to be implemented separately by every type. Also, it doesn't make much sense to put a string-specific method on a generic `list` object API. + +* Few weird looking but semantically correct statements: + + `[] = ()` is a semantically correct statement (unpacking an empty `tuple` into an empty `list`) + + `'a'[0][0][0][0][0]` is also semantically correct, because Python doesn't have a character data type like other languages branched from C. So selecting a single character from a string returns a single-character string. + + `3 --0-- 5 == 8` and `--5 == 5` are both semantically correct statements and evaluate to `True`. + +* Given that `a` is a number, `++a` and `--a` are both valid Python statements but don't behave the same way as compared with similar statements in languages like C, C++, or Java. + ```py + >>> a = 5 + >>> a + 5 + >>> ++a + 5 + >>> --a + 5 + ``` + + **💡 Explanation:** + + There is no `++` operator in Python grammar. It is actually two `+` operators. + + `++a` parses as `+(+a)` which translates to `a`. Similarly, the output of the statement `--a` can be justified. + + This StackOverflow [thread](https://stackoverflow.com/questions/3654830/why-are-there-no-and-operators-in-python) discusses the rationale behind the absence of increment and decrement operators in Python. + +* You must be aware of the Walrus operator in Python. But have you ever heard about *the space-invader operator*? + ```py + >>> a = 42 + >>> a -=- 1 + >>> a + 43 + ``` + It is used as an alternative incrementation operator, together with another one + ```py + >>> a +=+ 1 + >>> a + >>> 44 + ``` + **💡 Explanation:** This prank comes from [Raymond Hettinger's tweet](https://twitter.com/raymondh/status/1131103570856632321?lang=en). The space invader operator is actually just a malformatted `a -= (-1)`. Which is equivalent to `a = a - (- 1)`. Similar for the `a += (+ 1)` case. + +* Python has an undocumented [converse implication](https://en.wikipedia.org/wiki/Converse_implication) operator. + + ```py + >>> False ** False == True + True + >>> False ** True == False + True + >>> True ** False == True + True + >>> True ** True == True + True + ``` + + **💡 Explanation:** If you replace `False` and `True` by 0 and 1 and do the maths, the truth table is equivalent to a converse implication operator. ([Source](https://github.com/cosmologicon/pywat/blob/master/explanation.md#the-undocumented-converse-implication-operator)) + +* Since we are talking operators, there's also `@` operator for matrix multiplication (don't worry, this time it's for real). + + ```py + >>> import numpy as np + >>> np.array([2, 2, 2]) @ np.array([7, 8, 8]) + 46 + ``` + + **💡 Explanation:** The `@` operator was added in Python 3.5 keeping the scientific community in mind. Any object can overload `__matmul__` magic method to define behavior for this operator. + +* From Python 3.8 onwards you can use a typical f-string syntax like `f'{some_var=}` for quick debugging. Example, + ```py + >>> some_string = "wtfpython" + >>> f'{some_string=}' + "some_string='wtfpython'" + ``` + +* Python uses 2 bytes for local variable storage in functions. In theory, this means that only 65536 variables can be defined in a function. However, python has a handy solution built in that can be used to store more than 2^16 variable names. The following code demonstrates what happens in the stack when more than 65536 local variables are defined (Warning: This code prints around 2^18 lines of text, so be prepared!): + + ```py + import dis + exec(""" + def f(): + """ + """ + """.join(["X" + str(x) + "=" + str(x) for x in range(65539)])) + + f() + + print(dis.dis(f)) + ``` + +* Multiple Python threads won't run your *Python code* concurrently (yes, you heard it right!). It may seem intuitive to spawn several threads and let them execute your Python code concurrently, but, because of the [Global Interpreter Lock](https://wiki.python.org/moin/GlobalInterpreterLock) in Python, all you're doing is making your threads execute on the same core turn by turn. Python threads are good for IO-bound tasks, but to achieve actual parallelization in Python for CPU-bound tasks, you might want to use the Python [multiprocessing](https://docs.python.org/3/library/multiprocessing.html) module. + +* Sometimes, the `print` method might not print values immediately. For example, + + ```py + # File some_file.py + import time + + print("wtfpython", end="_") + time.sleep(3) + ``` + + This will print the `wtfpython` after 3 seconds due to the `end` argument because the output buffer is flushed either after encountering `\n` or when the program finishes execution. We can force the buffer to flush by passing `flush=True` argument. + +* List slicing with out of the bounds indices throws no errors + ```py + >>> some_list = [1, 2, 3, 4, 5] + >>> some_list[111:] + [] + ``` + +* Slicing an iterable not always creates a new object. For example, + ```py + >>> 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('١٢٣٤٥٦٧٨٩')` returns `123456789` in Python 3. In Python, Decimal characters include digit characters, and all characters that can be used to form decimal-radix numbers, e.g. U+0660, ARABIC-INDIC DIGIT ZERO. Here's an [interesting story](https://chris.improbable.org/2014/8/25/adventures-in-unicode-digits/) related to this behavior of Python. + +* You can separate numeric literals with underscores (for better readability) from Python 3 onwards. + + ```py + >>> six_million = 6_000_000 + >>> six_million + 6000000 + >>> hex_address = 0xF00D_CAFE + >>> hex_address + 4027435774 + ``` + +* `'abc'.count('') == 4`. Here's an approximate implementation of `count` method, which would make the things more clear + ```py + def count(s, sub): + result = 0 + for i in range(len(s) + 1 - len(sub)): + result += (s[i:i + len(sub)] == sub) + return result + ``` + The behavior is due to the matching of empty substring(`''`) with slices of length 0 in the original string. + +--- +--- + +# Contributing + +A few ways in which you can contribute to wtfpython, + +- Suggesting new examples +- Helping with translation (See [issues labeled translation](https://github.com/satwikkansal/wtfpython/issues?q=is%3Aissue+is%3Aopen+label%3Atranslation)) +- Minor corrections like pointing out outdated snippets, typos, formatting errors, etc. +- Identifying gaps (things like inadequate explanation, redundant examples, etc.) +- Any creative suggestions to make this project more fun and useful + +Please see [CONTRIBUTING.md](/CONTRIBUTING.md) for more details. Feel free to create a new [issue](https://github.com/satwikkansal/wtfpython/issues/new) to discuss things. + +PS: Please don't reach out with backlinking requests, no links will be added unless they're highly relevant to the project. + +# Acknowledgements + +The idea and design for this collection were initially inspired by Denys Dovhan's awesome project [wtfjs](https://github.com/denysdovhan/wtfjs). The overwhelming support by Pythonistas gave it the shape it is in right now. + +#### Some nice Links! +* 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](https://news.ycombinator.com/item?id=21862073) and [Reddit](https://www.reddit.com/r/programming/comments/edsh3q/what_the_fck_python_30_exploring_and/). + +# 🎓 License + +[![WTFPL 2.0][license-image]][license-url] + +© [Satwik Kansal](https://satwikkansal.xyz) + +[license-url]: http://www.wtfpl.net +[license-image]: https://img.shields.io/badge/License-WTFPL%202.0-lightgrey.svg?style=flat-square + +## Surprise your friends as well! + +If you like wtfpython, you can use these quick links to share it with your friends, + +[Twitter](https://twitter.com/intent/tweet?url=https://github.com/satwikkansal/wtfpython&text=If%20you%20really%20think%20you%20know%20Python,%20think%20once%20more!%20Check%20out%20wtfpython&hashtags=python,wtfpython) | [Linkedin](https://www.linkedin.com/shareArticle?url=https://github.com/satwikkansal&title=What%20the%20f*ck%20Python!&summary=If%20you%20really%20thing%20you%20know%20Python,%20think%20once%20more!) | [Facebook](https://www.facebook.com/dialog/share?app_id=536779657179021&display=page&href=https%3A%2F%2Fgithub.com%2Fsatwikkansal%2Fwtfpython"e=If%20you%20really%20think%20you%20know%20Python%2C%20think%20once%20more!) + +## Need a pdf version? + +I've received a few requests for the pdf (and epub) version of wtfpython. You can add your details [here](https://form.jotform.com/221593245656057) to get them as soon as they are finished. + + +**That's all folks!** For upcoming content like this, you can add your email [here](https://form.jotform.com/221593598380062). From ed79efdb4ea7b41ae40565df6cbd2f462d566702 Mon Sep 17 00:00:00 2001 From: Mohamad Reza Date: Thu, 27 Feb 2025 15:03:20 +0330 Subject: [PATCH 02/33] add farsi introduction --- translations/fa-farsi/README.md | 83 +++++++++++++++++++-------------- 1 file changed, 47 insertions(+), 36 deletions(-) diff --git a/translations/fa-farsi/README.md b/translations/fa-farsi/README.md index 6d89f3b..e20363a 100644 --- a/translations/fa-farsi/README.md +++ b/translations/fa-farsi/README.md @@ -9,31 +9,39 @@

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

-ترجمه‌ها: [Chinese 中文](https://github.com/leisurelicht/wtfpython-cn) | [Vietnamese Tiếng Việt](https://github.com/vuduclyunitn/wtfptyhon-vi) | [Spanish Español](https://web.archive.org/web/20220511161045/https://github.com/JoseDeFreitas/wtfpython-es) | [Korean 한국어](https://github.com/buttercrab/wtfpython-ko) | [Russian Русский](https://github.com/satwikkansal/wtfpython/tree/master/translations/ru-russian) | [German Deutsch](https://github.com/BenSt099/wtfpython) | [Add translation](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].) +ترجمه‌ها: [انگلیسی 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) | [اضافه کردن ترجمه](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].) -Other modes: [Interactive Website](https://wtfpython-interactive.vercel.app) | [Interactive Notebook](https://colab.research.google.com/github/satwikkansal/wtfpython/blob/master/irrelevant/wtf.ipynb) +حالت‌های دیگر: [وبسایت تعاملی](https://wtfpython-interactive.vercel.app) | [دفترچه تعاملی](https://colab.research.google.com/github/satwikkansal/wtfpython/blob/master/irrelevant/wtf.ipynb) -Python, being a beautifully designed high-level and interpreter-based programming language, provides us with many features for the programmer's comfort. But sometimes, the outcomes of a Python snippet may not seem obvious at first sight. -Here's a fun project attempting to explain what exactly is happening under the hood for some counter-intuitive snippets and lesser-known features in Python. +پایتون، یه زبان زیبا طراحی شده، سطح بالا و مبتنی بر مفسره که قابلیت‌های بسیاری برای راحتی ما برنامه‌نویس‌ها فراهم می‌کنه. +ولی گاهی اوقات قطعه‌کدهایی رو می‌بینیم که تو نگاه اول خروجی‌هاشون واضح نیست. -While some of the examples you see below may not be WTFs in the truest sense, but they'll reveal some of the interesting parts of Python that you might be unaware of. I find it a nice way to learn the internals of a programming language, and I believe that you'll find it interesting too! +این یه پروژه باحاله که سعی داریم توش توضیح بدیم که پشت پرده یه سری قطعه‌کدهای غیرشهودی و فابلیت‌های کمتر شناخته شده پایتون +چه خبره. -If you're an experienced Python programmer, you can take it as a challenge to get most of them right in the first attempt. You may have already experienced some of them before, and I might be able to revive sweet old memories of yours! :sweat_smile: +درحالی که بعضی از مثال‌هایی که قراره تو این سند ببینید واقعا پشم‌ریزون نیستند ولی بخش‌های جالبی از پایتون رو ظاهر می‌کنند که +ممکنه شما از وجودشون بی‌خبر باشید. به نظرم این شیوه جالبیه برای یادگیری جزئیات داخلی یه زبان برنامه نویسی و باور دارم که +برای شما هم جالب خواهد بود. -PS: If you're a returning reader, you can learn about the new modifications [here](https://github.com/satwikkansal/wtfpython/releases/) (the examples marked with asterisk are the ones added in the latest major revision). +اگه شما یه پایتون کار سابقه‌دار هستید، می‌تونید از این فرصت به عنوان یه چالش برای خودتون استفاده کنید تا بیشتر مثال‌ها رو +تو تلاش اول حدس بزنید. ممکنه شما بعضی از این مثال‌ها رو قبلا تجربه کرده باشید و من خاطراتشون رو در این سند براتون زنده +کرده باشم! :sweat_smile: -So, here we go... +پ.ن: اگه شما قبلا این سند رو خوندید، می‌تونید تغییرات جدید رو در بخش انتشار (فعلا در [اینجا](https://github.com/satwikkansal/wtfpython/)) مطالعه کنید +(مثال‌هایی که کنارشون علامت ستاره دارند، در آخرین ویرایش اضافه شده‌اند). -# Table of Contents +پس، بزن بریم... + +# فهرست مطالب -- [Table of Contents](#table-of-contents) -- [Structure of the Examples](#structure-of-the-examples) -- [Usage](#usage) +- [فهرست مطالب](#فهرست-مطالب) +- [ساختار مثال‌ها](#structure-of-the-examples) +- [استفاده](#استفاده) - [👀 Examples](#-examples) - [Section: Strain your brain!](#section-strain-your-brain) - [▶ First things first! \*](#-first-things-first-) @@ -175,52 +183,55 @@ So, here we go... -# Structure of the Examples +# ساختار مثال‌ها -All the examples are structured like below: +همه مثال‌ها به صورت زیر ساخته می‌شوند: -> ### ▶ Some fancy Title +> ### ▶ یه اسم خوشگل > > ```py -> # Set up the code. -> # Preparation for the magic... +> # راه اندازی کد +> # آماده سازی برای جادو... > ``` > -> **Output (Python version(s)):** +> **خروجی (نسخه(های) پایتون):** > > ```py > >>> triggering_statement -> Some unexpected output +> یه خروجی غیرمنتظره > ``` -> (Optional): One line describing the unexpected output. +> (دلخواه): توضیح یک‌خطی خروجی غیرمنتظره > > -> #### 💡 Explanation: +> #### 💡 توضیح: > -> * Brief explanation of what's happening and why is it happening. +> * توضیح کوتاه درمورد این‌که چی داره اتفاق میافته و چرا. > ```py -> # Set up code -> # More examples for further clarification (if necessary) +> # راه اندازی کد +> # مثال‌های بیشتر برای شفاف سازی (در صورت نیاز) > ``` -> **Output (Python version(s)):** +> **خروجی (نسخه(های) پایتون):** > > ```py -> >>> trigger # some example that makes it easy to unveil the magic -> # some justified output +> >>> trigger # یک مثال که رونمایی از جادو رو راحت‌تر می‌کنه +> # یک خروجی توجیه شده و واضح > ``` -**Note:** All the examples are tested on Python 3.5.2 interactive interpreter, and they should work for all the Python versions unless explicitly specified before the output. +**توجه:** همه مثال‌ها در برنامه مفسر تعاملی پایتون نسخه +۳.۵.۲ آزمایش شده‌اند و باید در همه نسخه‌های پایتون کار +کنند مگراینکه به صورت جداگانه و به طور واضح نسخه مخصوص +پایتون قبل از خروجی ذکر شده باشد. -# Usage -A nice way to get the most out of these examples, in my opinion, is to read them in sequential order, and for every example: -- Carefully read the initial code for setting up the example. If you're an experienced Python programmer, you'll successfully anticipate what's going to happen next most of the time. -- Read the output snippets and, - + Check if the outputs are the same as you'd expect. - + Make sure if you know the exact reason behind the output being the way it is. - - If the answer is no (which is perfectly okay), take a deep breath, and read the explanation (and if you still don't understand, shout out! and create an issue [here](https://github.com/satwikkansal/wtfpython/issues/new)). - - If yes, give a gentle pat on your back, and you may skip to the next example. +# استفاده +یه راه خوب برای بیشتر بهره بردن، به نظرم، اینه که مثال‌ها رو به ترتیب متوالی بخونید و برای هر مثال: +- کد ابتدایی برای راه اندازی مثال رو با دقت بخونید. اگه شما یه پایتون کار سابقه‌دار باشید، با موفقیت بیشتر اوقات اتفاق بعدی رو پیش‌بینی می‌کنید. +- قطعه خروجی رو بخونید و + + بررسی کنید که آیا خروجی‌ها همونطور که انتظار دارید هستند. + + مطمئین بشید که دقیقا دلیل اینکه خروجی اون طوری هست رو می‌دونید. + - اگه نمی‌دونید (که کاملا عادیه و اصلا بد نیست)، یک نفس عمیق بکشید و توضیحات رو بخونید (و اگه نفهمیدید، داد بزنید! و [اینجا](https://github.com/emargi/wtfpython/issues/new) درموردش حرف بزنید). + - اگه می‌دونید، به افتخار خودتون یه دست محکم بزنید و برید سراغ مثال بعدی. --- # 👀 Examples From 1280f9c6709f1834fb531eedc9bc87a6f34ff509 Mon Sep 17 00:00:00 2001 From: Mohamad Reza Date: Thu, 27 Feb 2025 15:25:36 +0330 Subject: [PATCH 03/33] add first example in farsi --- translations/fa-farsi/README.md | 60 +++++++++++++++++---------------- 1 file changed, 31 insertions(+), 29 deletions(-) diff --git a/translations/fa-farsi/README.md b/translations/fa-farsi/README.md index e20363a..efcbb85 100644 --- a/translations/fa-farsi/README.md +++ b/translations/fa-farsi/README.md @@ -42,10 +42,10 @@ - [فهرست مطالب](#فهرست-مطالب) - [ساختار مثال‌ها](#structure-of-the-examples) - [استفاده](#استفاده) -- [👀 Examples](#-examples) - - [Section: Strain your brain!](#section-strain-your-brain) - - [▶ First things first! \*](#-first-things-first-) - - [💡 Explanation](#-explanation) +- [👀 مثال‌ها](#-مثال‌ها) + - [بخش: ذهن خود را به چالش بکشید!](#بخش-ذهن-خود-را-به-چالش-بکشید) + - [▶ اول از همه! \*](#-اول-از-همه-) + - [💡 توضیحات](#-توضیحات) - [▶ بعضی وقت‌ها رشته‌ها می‌توانند دردسرساز شوند](#-بعضی-وقتها-رشتهها-میتوانند-دردسرساز-شوند) - [💡 Explanation:](#-explanation-1) - [▶ Be careful with chained operations](#-be-careful-with-chained-operations) @@ -234,16 +234,16 @@ - اگه می‌دونید، به افتخار خودتون یه دست محکم بزنید و برید سراغ مثال بعدی. --- -# 👀 Examples +# 👀 مثال‌ها -## Section: Strain your brain! +## بخش: ذهن خود را به چالش بکشید! -### ▶ First things first! * +### ▶ اول از همه! * -For some reason, the Python 3.8's "Walrus" operator (`:=`) has become quite popular. Let's check it out, +به دلایلی، عملگر "Walrus" (`:=`) که در نسخه ۳.۸ پایتون معرفی شد، خیلی محبوب شده. بیاید بررسیش کنیم. 1\. @@ -260,7 +260,7 @@ File "", line 1 ^ SyntaxError: invalid syntax ->>> (a := "wtf_walrus") # This works though +>>> (a := "wtf_walrus") # ولی این کار می‌کنه 'wtf_walrus' >>> a 'wtf_walrus' @@ -280,19 +280,19 @@ SyntaxError: invalid syntax >>> a 6 ->>> a, b = 6, 9 # Typical unpacking +>>> a, b = 6, 9 # باز کردن معمولی >>> a, b (6, 9) ->>> (a, b = 16, 19) # Oops +>>> (a, b = 16, 19) # آخ آخ File "", line 1 (a, b = 16, 19) ^ SyntaxError: invalid syntax ->>> (a, b := 16, 19) # This prints out a weird 3-tuple +>>> (a, b := 16, 19) # این یه تاپل ۳تایی چاپ می‌کنه رو صفحه (6, 16, 19) ->>> a # a is still unchanged? +>>> a # هنوز تغییر نکرده؟ 6 >>> b @@ -301,33 +301,35 @@ SyntaxError: invalid syntax -#### 💡 Explanation +#### 💡 توضیحات -**Quick walrus operator refresher** +**مرور سریع بر عملگر Walrus** -The Walrus operator (`:=`) was introduced in Python 3.8, it can be useful in situations where you'd want to assign values to variables within an expression. +عملگر Walrus همونطور که اشاره شد، در نسخه ۳.۸ پایتون معرفی +شد. این عملگر می‌تونه تو مقعیت‌هایی کاربردی باشه که شما می‌خواید داخل یه عبارت، مقادیری رو به متغیرها اختصاص بدید ```py def some_func(): - # Assume some expensive computation here + # فرض کنید اینجا یک سری محاسبه سنگین انجام میشه # time.sleep(1000) return 5 -# So instead of, +# پس به جای اینکه این کارو بکنید: if some_func(): - print(some_func()) # Which is bad practice since computation is happening twice + print(some_func()) # که خیلی راه نادرستیه چون محاسبه دوبار انجام میشه -# or +# یا حتی این کارو کنید (که کار بدی هم نیست) a = some_func() if a: print(a) -# Now you can concisely write +# می‌تونید از این به بعد به طور مختصر بنویسید: if a := some_func(): print(a) + ``` -**Output (> 3.8):** +**خروجی (+۳.۸):** ```py 5 @@ -335,15 +337,15 @@ if a := some_func(): 5 ``` -This saved one line of code, and implicitly prevented invoking `some_func` twice. +این باعث میشه که یک خط کمتر کد بزنیم و از دوبار فراخوندن `some_func` جلوگیری کرد. -- Unparenthesized "assignment expression" (use of walrus operator), is restricted at the top level, hence the `SyntaxError` in the `a := "wtf_walrus"` statement of the first snippet. Parenthesizing it worked as expected and assigned `a`. +- "عبارت اختصاص‌دادن مقدار" بدون پرانتز (نحوه استفاده عملگر Walrus)، در سطح بالا محدود است، `SyntaxError` در عبارت `a := "wtf_walrus"` در قطعه‌کد اول به همین دلیل است. قرار دادن آن داخل پرانتز، همانطور که می‌خواستیم کار کرد و مقدار را به `a` اختصاص داد. -- As usual, parenthesizing of an expression containing `=` operator is not allowed. Hence the syntax error in `(a, b = 6, 9)`. +- به طور معمول، قرار دادن عبارتی که دارای `=` است داخل پرانتز مجاز نیست. به همین دلیل ‍عبارت `(a, b = 6, 9)` به ما خطای سینتکس داد. -- The syntax of the Walrus operator is of the form `NAME:= expr`, where `NAME` is a valid identifier, and `expr` is a valid expression. Hence, iterable packing and unpacking are not supported which means, +- قائده استفاده از عملگر Walrus به صورت `NAME:= expr` است، به طوری که `NAME` یک شناسه صحیح و `expr` یک عبارت صحیح است. به همین دلیل باز و بسته کردن با تکرار (iterable) پشتیبانی نمی‌شوند. پس، - - `(a := 6, 9)` is equivalent to `((a := 6), 9)` and ultimately `(a, 9) ` (where `a`'s value is 6') + - عبارت `(a := 6, 9)` معادل عبارت `((a := 6), 9)` و در نهایت `(a, 9)` است. (که مقدار `a` عدد 6 است) ```py >>> (a := 6, 9) == ((a := 6), 9) @@ -351,11 +353,11 @@ This saved one line of code, and implicitly prevented invoking `some_func` twice >>> x = (a := 696, 9) >>> x (696, 9) - >>> x[0] is a # Both reference same memory location + >>> x[0] is a # هر دو به یک مکان در حافظه دستگاه اشاره می‌کنند True ``` - - Similarly, `(a, b := 16, 19)` is equivalent to `(a, (b := 16), 19)` which is nothing but a 3-tuple. + - به طور مشابه، عبارت `(a, b := 16, 19)` معادل عبارت `(a, (b := 16), 19)` است که چیزی جز یک تاپل ۳تایی نیست. --- From 6592360507af3faa32f2f795f75cb438932ebcf0 Mon Sep 17 00:00:00 2001 From: Mohamad Reza Date: Tue, 4 Mar 2025 17:14:28 +0330 Subject: [PATCH 04/33] update farsi translation - first section --- translations/fa-farsi/section1-temp.md | 492 +++++++++++++++++++++++++ 1 file changed, 492 insertions(+) create mode 100644 translations/fa-farsi/section1-temp.md diff --git a/translations/fa-farsi/section1-temp.md b/translations/fa-farsi/section1-temp.md new file mode 100644 index 0000000..eca01fa --- /dev/null +++ b/translations/fa-farsi/section1-temp.md @@ -0,0 +1,492 @@ +## بخش: ذهن خود را به چالش بکشید! + +### ▶ اول از همه! * + + + + +به دلایلی، عملگر "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) قرار دارد. + +

+ + + + Shows a string interning process. + +

+ ++ زمانی که `"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" +``` + +**Output:** + +```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 +``` + +**Output:** +```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 + ``` + همونطور که مشاهده می‌کنید، ترتیب حذف شدن شیءها باعث تفاوت میشه. + +--- From 4d8e193d654c5ad90df0e65eca276b3434230c18 Mon Sep 17 00:00:00 2001 From: Mohamad Reza Date: Tue, 11 Mar 2025 00:41:07 +0330 Subject: [PATCH 05/33] update farsi translation - section 1 --- translations/fa-farsi/section1-temp.md | 298 +++++++++++++++++++++++++ 1 file changed, 298 insertions(+) diff --git a/translations/fa-farsi/section1-temp.md b/translations/fa-farsi/section1-temp.md index eca01fa..9d70bb4 100644 --- a/translations/fa-farsi/section1-temp.md +++ b/translations/fa-farsi/section1-temp.md @@ -490,3 +490,301 @@ 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 +``` + +**Output** +```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 + +``` + +#### 💡 Explanation: + +- وقتی یک عبارت `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 +``` + +**Output:** +```py +>>> some_dict # یک دیکشنری مرتب‌شده نمایان میشه. +{0: 'w', 1: 't', 2: 'f'} +``` + +#### 💡 توضیحات: +* یک حلقه `for` در [گرامر پایتون](https://docs.python.org/3/reference/grammar.html) این طور تعریف میشه: + ``` + for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite] + ``` + به طوری که `exprlist` یک هدف برای مقداردهیه. این یعنی، معادل عبارت `{exprlist} = {next_value}` **برای هر شیء داخل `testlist` اجرا می‌شود**. + یک مثال جالب برای نشون دادن این تعریف: + ```py + for i in range(4): + print(i) + i = 10 + ``` + + **خروجی:** + ``` + 0 + 1 + 2 + 3 + ``` + + آیا انتظار داشتید که حلقه فقط یک بار اجرا بشه؟ + + **💡 توضیحات:** + + - عبارت مقداردهی `i = 10` به خاطر نحوه کار کردن حلقه‌ها، هیچوقت باعث تغییر در تکرار حلقه نمیشه. قبل از شروع هر تکرار، مقدار بعدی که توسط شیء قابل تکرار (که در اینجا `range(4)` است) ارائه میشه، از بسته خارج میشه و به متغیرهای لیست هدف (که در اینجا `i` است) مقداردهی میشه. + +* تابع `enumerate(some_string)`، یک متغیر `i` (که یک شمارنده اقزایشی است) و یک حرف از حروف رشته `some_string` رو در هر تکرار برمیگردونه. و بعدش برای کلید `i` (تازه مقداردهی‌شده) در دیکشنری `some_dict`، مقدار اون حرف رو تنظیم می‌کنه. بازشده این حلقه می‌تونه مانند مثال زیر ساده بشه: + ```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` میشه. + +--- From 5dde16cd859354c91c8667812dc8b7648a30760f Mon Sep 17 00:00:00 2001 From: Mohamad Reza Date: Tue, 11 Mar 2025 00:48:59 +0330 Subject: [PATCH 06/33] translate missed words --- translations/fa-farsi/section1-temp.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/translations/fa-farsi/section1-temp.md b/translations/fa-farsi/section1-temp.md index 9d70bb4..f14400d 100644 --- a/translations/fa-farsi/section1-temp.md +++ b/translations/fa-farsi/section1-temp.md @@ -387,7 +387,7 @@ some_dict[5.0] = "Ruby" some_dict[5] = "Python" ``` -**Output:** +**خروجی:** ```py >>> some_dict[5.5] @@ -449,7 +449,7 @@ class WTF: pass ``` -**Output:** +**خروجی:** ```py >>> WTF() == WTF() # دو نمونه متفاوت از یک کلاس نمیتونند برابر هم باشند False @@ -519,7 +519,7 @@ class OrderedDictWithHash(OrderedDict): __hash__ = lambda self: 0 ``` -**Output** +**خروجی** ```py >>> dictionary == ordered_dict # اگر مقدار اولی با دومی برابره True @@ -643,7 +643,7 @@ Iteration 0 ``` -#### 💡 Explanation: +#### 💡 توضیحات: - وقتی یک عبارت `return`، `break` یا `continue` داخل بخش `try` از یک عبارت "try...finally" اجرا میشه، بخش `fianlly` هم هنگام خارج شدن اجرا میشه. - مقدار بازگشتی یک تابع از طریق آخرین عبارت `return` که داخل تابع اجرا میشه، مشخص میشه. از اونجایی که بخش `finally` همیشه اجرا میشه، عبارت `return` که داخل بخش `finally` هست آخرین عبارتیه که اجرا میشه. @@ -661,7 +661,7 @@ for i, some_dict[i] in enumerate(some_string): i = 10 ``` -**Output:** +**خروجی:** ```py >>> some_dict # یک دیکشنری مرتب‌شده نمایان میشه. {0: 'w', 1: 't', 2: 'f'} From bcd17d39652dc40d091834a79a7764a8dc91cefa Mon Sep 17 00:00:00 2001 From: Leo Alavi Date: Sun, 16 Mar 2025 19:25:55 +0100 Subject: [PATCH 07/33] Translate info sections at the end --- translations/fa-farsi/README.md | 182 ++++++++++++++++---------------- 1 file changed, 92 insertions(+), 90 deletions(-) diff --git a/translations/fa-farsi/README.md b/translations/fa-farsi/README.md index efcbb85..b8fbb9d 100644 --- a/translations/fa-farsi/README.md +++ b/translations/fa-farsi/README.md @@ -40,146 +40,146 @@ - [فهرست مطالب](#فهرست-مطالب) -- [ساختار مثال‌ها](#structure-of-the-examples) +- [ساختار مثال‌ها](#ساختار-مثالها) - [استفاده](#استفاده) -- [👀 مثال‌ها](#-مثال‌ها) +- [👀 مثال‌ها](#-مثالها) - [بخش: ذهن خود را به چالش بکشید!](#بخش-ذهن-خود-را-به-چالش-بکشید) - [▶ اول از همه! \*](#-اول-از-همه-) - [💡 توضیحات](#-توضیحات) - [▶ بعضی وقت‌ها رشته‌ها می‌توانند دردسرساز شوند](#-بعضی-وقتها-رشتهها-میتوانند-دردسرساز-شوند) - - [💡 Explanation:](#-explanation-1) + - [💡 Explanation:](#-explanation) - [▶ Be careful with chained operations](#-be-careful-with-chained-operations) - - [💡 Explanation:](#-explanation-2) + - [💡 Explanation:](#-explanation-1) - [▶ How not to use `is` operator](#-how-not-to-use-is-operator) - - [💡 Explanation:](#-explanation-3) + - [💡 Explanation:](#-explanation-2) - [▶ Hash brownies](#-hash-brownies) - - [💡 Explanation](#-explanation-4) + - [💡 Explanation](#-explanation-3) - [▶ Deep down, we're all the same.](#-deep-down-were-all-the-same) - - [💡 Explanation:](#-explanation-5) + - [💡 Explanation:](#-explanation-4) - [▶ Disorder within order \*](#-disorder-within-order-) - - [💡 Explanation:](#-explanation-6) + - [💡 Explanation:](#-explanation-5) - [▶ Keep trying... \*](#-keep-trying-) - - [💡 Explanation:](#-explanation-7) + - [💡 Explanation:](#-explanation-6) - [▶ For what?](#-for-what) - - [💡 Explanation:](#-explanation-8) + - [💡 Explanation:](#-explanation-7) - [▶ Evaluation time discrepancy](#-evaluation-time-discrepancy) - - [💡 Explanation](#-explanation-9) + - [💡 Explanation](#-explanation-8) - [▶ `is not ...` is not `is (not ...)`](#-is-not--is-not-is-not-) - - [💡 Explanation](#-explanation-10) + - [💡 Explanation](#-explanation-9) - [▶ A tic-tac-toe where X wins in the first attempt!](#-a-tic-tac-toe-where-x-wins-in-the-first-attempt) - - [💡 Explanation:](#-explanation-11) + - [💡 Explanation:](#-explanation-10) - [▶ Schrödinger's variable \*](#-schrödingers-variable-) - - [💡 Explanation:](#-explanation-12) + - [💡 Explanation:](#-explanation-11) - [▶ The chicken-egg problem \*](#-the-chicken-egg-problem-) - - [💡 Explanation](#-explanation-13) + - [💡 Explanation](#-explanation-12) - [▶ Subclass relationships](#-subclass-relationships) - - [💡 Explanation:](#-explanation-14) + - [💡 Explanation:](#-explanation-13) - [▶ Methods equality and identity](#-methods-equality-and-identity) - - [💡 Explanation](#-explanation-15) + - [💡 Explanation](#-explanation-14) - [▶ All-true-ation \*](#-all-true-ation-) + - [💡 Explanation:](#-explanation-15) - [💡 Explanation:](#-explanation-16) - - [💡 Explanation:](#-explanation-17) - [▶ Strings and the backslashes](#-strings-and-the-backslashes) - - [💡 Explanation](#-explanation-18) + - [💡 Explanation](#-explanation-17) - [▶ not knot!](#-not-knot) - - [💡 Explanation:](#-explanation-19) + - [💡 Explanation:](#-explanation-18) - [▶ Half triple-quoted strings](#-half-triple-quoted-strings) - - [💡 Explanation:](#-explanation-20) + - [💡 Explanation:](#-explanation-19) - [▶ What's wrong with booleans?](#-whats-wrong-with-booleans) - - [💡 Explanation:](#-explanation-21) + - [💡 Explanation:](#-explanation-20) - [▶ Class attributes and instance attributes](#-class-attributes-and-instance-attributes) - - [💡 Explanation:](#-explanation-22) + - [💡 Explanation:](#-explanation-21) - [▶ yielding None](#-yielding-none) - - [💡 Explanation:](#-explanation-23) + - [💡 Explanation:](#-explanation-22) - [▶ Yielding from... return! \*](#-yielding-from-return-) - - [💡 Explanation:](#-explanation-24) + - [💡 Explanation:](#-explanation-23) - [▶ Nan-reflexivity \*](#-nan-reflexivity-) - - [💡 Explanation:](#-explanation-25) + - [💡 Explanation:](#-explanation-24) - [▶ Mutating the immutable!](#-mutating-the-immutable) - - [💡 Explanation:](#-explanation-26) + - [💡 Explanation:](#-explanation-25) - [▶ The disappearing variable from outer scope](#-the-disappearing-variable-from-outer-scope) - - [💡 Explanation:](#-explanation-27) + - [💡 Explanation:](#-explanation-26) - [▶ The mysterious key type conversion](#-the-mysterious-key-type-conversion) - - [💡 Explanation:](#-explanation-28) + - [💡 Explanation:](#-explanation-27) - [▶ Let's see if you can guess this?](#-lets-see-if-you-can-guess-this) - - [💡 Explanation:](#-explanation-29) + - [💡 Explanation:](#-explanation-28) - [▶ Exceeds the limit for integer string conversion](#-exceeds-the-limit-for-integer-string-conversion) - - [💡 Explanation:](#-explanation-30) + - [💡 Explanation:](#-explanation-29) - [Section: Slippery Slopes](#section-slippery-slopes) - [▶ Modifying a dictionary while iterating over it](#-modifying-a-dictionary-while-iterating-over-it) - - [💡 Explanation:](#-explanation-31) + - [💡 Explanation:](#-explanation-30) - [▶ Stubborn `del` operation](#-stubborn-del-operation) - - [💡 Explanation:](#-explanation-32) + - [💡 Explanation:](#-explanation-31) - [▶ The out of scope variable](#-the-out-of-scope-variable) - - [💡 Explanation:](#-explanation-33) + - [💡 Explanation:](#-explanation-32) - [▶ Deleting a list item while iterating](#-deleting-a-list-item-while-iterating) - - [💡 Explanation:](#-explanation-34) + - [💡 Explanation:](#-explanation-33) - [▶ Lossy zip of iterators \*](#-lossy-zip-of-iterators-) - - [💡 Explanation:](#-explanation-35) + - [💡 Explanation:](#-explanation-34) - [▶ Loop variables leaking out!](#-loop-variables-leaking-out) - - [💡 Explanation:](#-explanation-36) + - [💡 Explanation:](#-explanation-35) - [▶ Beware of default mutable arguments!](#-beware-of-default-mutable-arguments) - - [💡 Explanation:](#-explanation-37) + - [💡 Explanation:](#-explanation-36) - [▶ Catching the Exceptions](#-catching-the-exceptions) - - [💡 Explanation](#-explanation-38) + - [💡 Explanation](#-explanation-37) - [▶ Same operands, different story!](#-same-operands-different-story) - - [💡 Explanation:](#-explanation-39) + - [💡 Explanation:](#-explanation-38) - [▶ Name resolution ignoring class scope](#-name-resolution-ignoring-class-scope) - - [💡 Explanation](#-explanation-40) + - [💡 Explanation](#-explanation-39) - [▶ Rounding like a banker \*](#-rounding-like-a-banker-) - - [💡 Explanation:](#-explanation-41) + - [💡 Explanation:](#-explanation-40) - [▶ Needles in a Haystack \*](#-needles-in-a-haystack-) - - [💡 Explanation:](#-explanation-42) + - [💡 Explanation:](#-explanation-41) - [▶ Splitsies \*](#-splitsies-) - - [💡 Explanation:](#-explanation-43) + - [💡 Explanation:](#-explanation-42) - [▶ Wild imports \*](#-wild-imports-) - - [💡 Explanation:](#-explanation-44) + - [💡 Explanation:](#-explanation-43) - [▶ All sorted? \*](#-all-sorted-) - - [💡 Explanation:](#-explanation-45) + - [💡 Explanation:](#-explanation-44) - [▶ Midnight time doesn't exist?](#-midnight-time-doesnt-exist) - - [💡 Explanation:](#-explanation-46) + - [💡 Explanation:](#-explanation-45) - [Section: The Hidden treasures!](#section-the-hidden-treasures) - [▶ Okay Python, Can you make me fly?](#-okay-python-can-you-make-me-fly) - - [💡 Explanation:](#-explanation-47) + - [💡 Explanation:](#-explanation-46) - [▶ `goto`, but why?](#-goto-but-why) - - [💡 Explanation:](#-explanation-48) + - [💡 Explanation:](#-explanation-47) - [▶ Brace yourself!](#-brace-yourself) - - [💡 Explanation:](#-explanation-49) + - [💡 Explanation:](#-explanation-48) - [▶ Let's meet Friendly Language Uncle For Life](#-lets-meet-friendly-language-uncle-for-life) - - [💡 Explanation:](#-explanation-50) + - [💡 Explanation:](#-explanation-49) - [▶ Even Python understands that love is complicated](#-even-python-understands-that-love-is-complicated) - - [💡 Explanation:](#-explanation-51) + - [💡 Explanation:](#-explanation-50) - [▶ Yes, it exists!](#-yes-it-exists) - - [💡 Explanation:](#-explanation-52) + - [💡 Explanation:](#-explanation-51) - [▶ Ellipsis \*](#-ellipsis-) - - [💡 Explanation](#-explanation-53) + - [💡 Explanation](#-explanation-52) - [▶ Inpinity](#-inpinity) - - [💡 Explanation:](#-explanation-54) + - [💡 Explanation:](#-explanation-53) - [▶ Let's mangle](#-lets-mangle) - - [💡 Explanation:](#-explanation-55) + - [💡 Explanation:](#-explanation-54) - [Section: Appearances are deceptive!](#section-appearances-are-deceptive) - [▶ Skipping lines?](#-skipping-lines) - - [💡 Explanation](#-explanation-56) + - [💡 Explanation](#-explanation-55) - [▶ Teleportation](#-teleportation) - - [💡 Explanation:](#-explanation-57) + - [💡 Explanation:](#-explanation-56) - [▶ Well, something is fishy...](#-well-something-is-fishy) - - [💡 Explanation](#-explanation-58) + - [💡 Explanation](#-explanation-57) - [Section: Miscellaneous](#section-miscellaneous) - [▶ `+=` is faster](#--is-faster) - - [💡 Explanation:](#-explanation-59) + - [💡 Explanation:](#-explanation-58) - [▶ Let's make a giant string!](#-lets-make-a-giant-string) - - [💡 Explanation](#-explanation-60) + - [💡 Explanation](#-explanation-59) - [▶ Slowing down `dict` lookups \*](#-slowing-down-dict-lookups-) - - [💡 Explanation:](#-explanation-61) + - [💡 Explanation:](#-explanation-60) - [▶ Bloating instance `dict`s \*](#-bloating-instance-dicts-) - - [💡 Explanation:](#-explanation-62) + - [💡 Explanation:](#-explanation-61) - [▶ Minor Ones \*](#-minor-ones-) -- [Contributing](#contributing) -- [Acknowledgements](#acknowledgements) - - [Some nice Links!](#some-nice-links) -- [🎓 License](#-license) - - [Surprise your friends as well!](#surprise-your-friends-as-well) - - [Need a pdf version?](#need-a-pdf-version) +- [‫ مشارکت](#-مشارکت) +- [‫ تقدیر و تشکر](#-تقدیر-و-تشکر) + - [‫ چند لینک جالب!](#-چند-لینک-جالب) +- [‫ 🎓 مجوز](#--مجوز) + - [‫ دوستانتان را هم شگفت‌زده کنید!](#-دوستانتان-را-هم-شگفتزده-کنید) + - [‫ آیا به یک نسخه pdf نیاز دارید؟](#-آیا-به-یک-نسخه-pdf-نیاز-دارید) @@ -3893,25 +3893,26 @@ What makes those dictionaries become bloated? And why are newly created objects --- --- -# Contributing +# ‫ مشارکت -A few ways in which you can contribute to wtfpython, +‫چند روشی که می‌توانید در wtfpython مشارکت داشته باشید: -- Suggesting new examples -- Helping with translation (See [issues labeled translation](https://github.com/satwikkansal/wtfpython/issues?q=is%3Aissue+is%3Aopen+label%3Atranslation)) -- Minor corrections like pointing out outdated snippets, typos, formatting errors, etc. -- Identifying gaps (things like inadequate explanation, redundant examples, etc.) -- Any creative suggestions to make this project more fun and useful +- ‫ پیشنهاد مثال‌های جدید +- ‫ کمک به ترجمه (به [مشکلات برچسب ترجمه](https://github.com/satwikkansal/wtfpython/issues?q=is%3Aissue+is%3Aopen+label%3Atranslation) مراجعه کنید) +- ‫ اصلاحات جزئی مثل اشاره به تکه‌کدهای قدیمی، اشتباهات تایپی، خطاهای قالب‌بندی و غیره. +- ‫ شناسایی نواقص (مانند توضیحات ناکافی، مثال‌های تکراری و ...) +- ‫ هر پیشنهاد خلاقانه‌ای برای مفیدتر و جذاب‌تر شدن این پروژه -Please see [CONTRIBUTING.md](/CONTRIBUTING.md) for more details. Feel free to create a new [issue](https://github.com/satwikkansal/wtfpython/issues/new) to discuss things. +‫ برای اطلاعات بیشتر [CONTRIBUTING.md](/CONTRIBUTING.md) را مشاهده کنید. برای بحث درباره موارد مختلف می‌توانید یک [مشکل جدید](https://github.com/satwikkansal/wtfpython/issues/new) ایجاد کنید. -PS: Please don't reach out with backlinking requests, no links will be added unless they're highly relevant to the project. +‫ نکته: لطفاً برای درخواست بک‌لینک (backlink) تماس نگیرید. هیچ لینکی اضافه نمی‌شود مگر اینکه ارتباط بسیار زیادی با پروژه داشته باشد. -# Acknowledgements +# ‫ تقدیر و تشکر -The idea and design for this collection were initially inspired by Denys Dovhan's awesome project [wtfjs](https://github.com/denysdovhan/wtfjs). The overwhelming support by Pythonistas gave it the shape it is in right now. +‫ ایده و طراحی این مجموعه ابتدا از پروژه عالی [wtfjs](https://github.com/denysdovhan/wtfjs) توسط Denys Dovhan الهام گرفته شد. حمایت فوق‌العاده‌ جامعه پایتون باعث شد پروژه به شکل امروزی خود درآید. -#### Some nice Links! + +#### ‫ چند لینک جالب! * 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 @@ -3922,7 +3923,7 @@ The idea and design for this collection were initially inspired by Denys Dovhan' * https://github.com/wemake-services/wemake-python-styleguide/search?q=wtfpython&type=Issues * WFTPython discussion threads on [Hacker News](https://news.ycombinator.com/item?id=21862073) and [Reddit](https://www.reddit.com/r/programming/comments/edsh3q/what_the_fck_python_30_exploring_and/). -# 🎓 License +# ‫ 🎓 مجوز [![WTFPL 2.0][license-image]][license-url] @@ -3931,15 +3932,16 @@ The idea and design for this collection were initially inspired by Denys Dovhan' [license-url]: http://www.wtfpl.net [license-image]: https://img.shields.io/badge/License-WTFPL%202.0-lightgrey.svg?style=flat-square -## Surprise your friends as well! +## ‫ دوستانتان را هم شگفت‌زده کنید! -If you like wtfpython, you can use these quick links to share it with your friends, +‫ اگر از wtfpython خوشتان آمد، می‌توانید با این لینک‌های سریع آن را با دوستانتان به اشتراک بگذارید: -[Twitter](https://twitter.com/intent/tweet?url=https://github.com/satwikkansal/wtfpython&text=If%20you%20really%20think%20you%20know%20Python,%20think%20once%20more!%20Check%20out%20wtfpython&hashtags=python,wtfpython) | [Linkedin](https://www.linkedin.com/shareArticle?url=https://github.com/satwikkansal&title=What%20the%20f*ck%20Python!&summary=If%20you%20really%20thing%20you%20know%20Python,%20think%20once%20more!) | [Facebook](https://www.facebook.com/dialog/share?app_id=536779657179021&display=page&href=https%3A%2F%2Fgithub.com%2Fsatwikkansal%2Fwtfpython"e=If%20you%20really%20think%20you%20know%20Python%2C%20think%20once%20more!) - -## Need a pdf version? - -I've received a few requests for the pdf (and epub) version of wtfpython. You can add your details [here](https://form.jotform.com/221593245656057) to get them as soon as they are finished. +‫ [توییتر](https://twitter.com/intent/tweet?url=https://github.com/satwikkansal/wtfpython&text=If%20you%20really%20think%20you%20know%20Python,%20think%20once%20more!%20Check%20out%20wtfpython&hashtags=python,wtfpython) | [لینکدین](https://www.linkedin.com/shareArticle?url=https://github.com/satwikkansal&title=What%20the%20f*ck%20Python!&summary=If%20you%20really%20thing%20you%20know%20Python,%20think%20once%20more!) | [فیسبوک](https://www.facebook.com/dialog/share?app_id=536779657179021&display=page&href=https%3A%2F%2Fgithub.com%2Fsatwikkansal%2Fwtfpython"e=If%20you%20really%20think%20you%20know%20Python%2C%20think%20once%20more!) -**That's all folks!** For upcoming content like this, you can add your email [here](https://form.jotform.com/221593598380062). +## ‫ آیا به یک نسخه pdf نیاز دارید؟ + + +‫ من چند درخواست برای نسخه PDF (و epub) کتاب wtfpython دریافت کرده‌ام. برای دریافت این نسخه‌ها به محض آماده شدن، می‌توانید اطلاعات خود را [اینجا](https://form.jotform.com/221593245656057) وارد کنید. + +‫ **همین بود دوستان!** برای دریافت مطالب آینده مشابه این، می‌توانید ایمیل خود را [اینجا](https://form.jotform.com/221593598380062) اضافه کنید. From 31bc257d118603ce8f2d6f0f8581da50f5936bce Mon Sep 17 00:00:00 2001 From: Leo Alavi Date: Sun, 16 Mar 2025 21:03:21 +0100 Subject: [PATCH 08/33] translate miscellaneous section --- translations/fa-farsi/README.md | 181 ++++++++++++++++---------------- 1 file changed, 93 insertions(+), 88 deletions(-) diff --git a/translations/fa-farsi/README.md b/translations/fa-farsi/README.md index b8fbb9d..f55f843 100644 --- a/translations/fa-farsi/README.md +++ b/translations/fa-farsi/README.md @@ -164,16 +164,16 @@ - [💡 Explanation:](#-explanation-56) - [▶ Well, something is fishy...](#-well-something-is-fishy) - [💡 Explanation](#-explanation-57) - - [Section: Miscellaneous](#section-miscellaneous) - - [▶ `+=` is faster](#--is-faster) - - [💡 Explanation:](#-explanation-58) - - [▶ Let's make a giant string!](#-lets-make-a-giant-string) - - [💡 Explanation](#-explanation-59) - - [▶ Slowing down `dict` lookups \*](#-slowing-down-dict-lookups-) - - [💡 Explanation:](#-explanation-60) - - [▶ Bloating instance `dict`s \*](#-bloating-instance-dicts-) - - [💡 Explanation:](#-explanation-61) - - [▶ Minor Ones \*](#-minor-ones-) + - [بخش: متفرقه](#بخش-متفرقه) + - [▶ `+=` سریع‌تر است](#--سریعتر-است) + - [‫ 💡 توضیح:](#---توضیح) + - [‫ ▶ بیایید یک رشته‌ی بزرگ بسازیم!](#--بیایید-یک-رشتهی-بزرگ-بسازیم) + - [💡 توضیحات](#-توضیحات-1) + - [▶ ‫ کُند کردن جستجوها در `dict` \*](#---کُند-کردن-جستجوها-در-dict-) + - [‫ 💡 توضیح:](#---توضیح-1) + - [‫ ▶ حجیم کردن دیکشنری نمونه‌ها (`instance dicts`) \*](#--حجیم-کردن-دیکشنری-نمونهها-instance-dicts-) + - [💡 توضیح:](#-توضیح) + - [‫ ▶ موارد جزئی \*](#---موارد-جزئی-) - [‫ مشارکت](#-مشارکت) - [‫ تقدیر و تشکر](#-تقدیر-و-تشکر) - [‫ چند لینک جالب!](#-چند-لینک-جالب) @@ -3539,27 +3539,27 @@ Shouldn't that be 100? --- --- -## Section: Miscellaneous +## بخش: متفرقه -### ▶ `+=` is faster +### ▶ `+=` سریع‌تر است ```py -# using "+", three strings: +# استفاده از "+"، سه رشته: >>> timeit.timeit("s1 = s1 + s2 + s3", setup="s1 = ' ' * 100000; s2 = ' ' * 100000; s3 = ' ' * 100000", number=100) 0.25748300552368164 -# using "+=", three strings: +# استفاده از "+="، سه رشته: >>> timeit.timeit("s1 += s2 + s3", setup="s1 = ' ' * 100000; s2 = ' ' * 100000; s3 = ' ' * 100000", number=100) 0.012188911437988281 ``` -#### 💡 Explanation: -+ `+=` is faster than `+` for concatenating more than two strings because the first string (example, `s1` for `s1 += s2 + s3`) is not destroyed while calculating the complete string. +#### ‫ 💡 توضیح: ++ ‫ استفاده از `+=` برای اتصال بیش از دو رشته سریع‌تر از `+` است، زیرا هنگام محاسبه رشته‌ی نهایی، رشته‌ی اول (به‌عنوان مثال `s1` در عبارت `s1 += s2 + s3`) از بین نمی‌رود. --- -### ▶ Let's make a giant string! +### ‫ ▶ بیایید یک رشته‌ی بزرگ بسازیم! ```py def add_string_with_plus(iters): @@ -3593,10 +3593,11 @@ def convert_list_to_string(l, iters): **Output:** +‫ اجرا شده در پوسته‌ی ipython با استفاده از `%timeit` برای خوانایی بهتر نتایج. +‫ همچنین می‌توانید از ماژول `timeit` در پوسته یا اسکریپت عادی پایتون استفاده کنید؛ نمونه‌ی استفاده در زیر آمده است: +timeit.timeit('add_string_with_plus(10000)', number=1000, globals=globals()) + ```py -# Executed in ipython shell using %timeit for better readability of results. -# You can also use the timeit module in normal python shell/scriptm=, example usage below -# timeit.timeit('add_string_with_plus(10000)', number=1000, globals=globals()) >>> NUM_ITERS = 1000 >>> %timeit -n1000 add_string_with_plus(NUM_ITERS) @@ -3612,29 +3613,30 @@ def convert_list_to_string(l, iters): 10.1 µs ± 1.06 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) ``` -Let's increase the number of iterations by a factor of 10. +‫ بیایید تعداد تکرارها را ۱۰ برابر افزایش دهیم. ```py >>> NUM_ITERS = 10000 ->>> %timeit -n1000 add_string_with_plus(NUM_ITERS) # Linear increase in execution time +>>> %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) # Quadratic increase +>>> %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) # Linear increase +>>> %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) # Linear increase +>>> %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) # Linear increase +>>> %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) ``` -#### 💡 Explanation -- You can read more about [timeit](https://docs.python.org/3/library/timeit.html) or [%timeit](https://ipython.org/ipython-doc/dev/interactive/magics.html#magic-timeit) on these links. They are used to measure the execution time of code pieces. -- Don't use `+` for generating long strings — In Python, `str` is immutable, so the left and right strings have to be copied into the new string for every pair of concatenations. If you concatenate four strings of length 10, you'll be copying (10+10) + ((10+10)+10) + (((10+10)+10)+10) = 90 characters instead of just 40 characters. Things get quadratically worse as the number and size of the string increases (justified with the execution times of `add_bytes_with_plus` function) -- Therefore, it's advised to use `.format.` or `%` syntax (however, they are slightly slower than `+` for very short strings). -- Or better, if already you've contents available in the form of an iterable object, then use `''.join(iterable_object)` which is much faster. -- Unlike `add_bytes_with_plus` because of the `+=` optimizations discussed in the previous example, `add_string_with_plus` didn't show a quadratic increase in execution time. Had the statement been `s = s + "x" + "y" + "z"` instead of `s += "xyz"`, the increase would have been quadratic. +#### 💡 توضیحات +توضیحات +- ‫ برای اطلاعات بیشتر درباره‌ی [timeit](https://docs.python.org/3/library/timeit.html) یا [%timeit](https://ipython.org/ipython-doc/dev/interactive/magics.html#magic-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"`)، افزایش زمان اجرا درجه دو می‌شد. ```py def add_string_with_plus(iters): s = "" @@ -3644,23 +3646,24 @@ Let's increase the number of iterations by a factor of 10. >>> %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) # Quadratic increase in execution time + >>> %timeit -n100 add_string_with_plus(10000) # افزایش درجه دو در زمان اجرا 9 ms ± 298 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) ``` -- So many ways to format and create a giant string are somewhat in contrast to the [Zen of Python](https://www.python.org/dev/peps/pep-0020/), according to which, +- ‫ وجود راه‌های متعدد برای قالب‌بندی و ایجاد رشته‌های بزرگ تا حدودی در تضاد با [ذِن پایتون](https://www.python.org/dev/peps/pep-0020/) است که می‌گوید: + - > There should be one-- and preferably only one --obvious way to do it. + > ‫ «باید یک راه — و ترجیحاً فقط یک راه — واضح برای انجام آن وجود داشته باشد.» --- -### ▶ Slowing down `dict` lookups * +### ▶ ‫ کُند کردن جستجوها در `dict` * ```py some_dict = {str(i): 1 for i in range(1_000_000)} another_dict = {str(i): 1 for i in range(1_000_000)} ``` -**Output:** +‫ **خروجی:** ```py >>> %timeit some_dict['5'] 28.6 ns ± 0.115 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each) @@ -3670,23 +3673,23 @@ another_dict = {str(i): 1 for i in range(1_000_000)} >>> %timeit another_dict['5'] 28.5 ns ± 0.142 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each) ->>> another_dict[1] # Trying to access a key that doesn't exist +>>> another_dict[1] # تلاش برای دسترسی به کلیدی که وجود ندارد Traceback (most recent call last): File "", line 1, in KeyError: 1 >>> %timeit another_dict['5'] 38.5 ns ± 0.0913 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each) ``` -Why are same lookups becoming slower? +چرا جستجوهای یکسان کندتر می‌شوند؟ -#### 💡 Explanation: -+ CPython has a generic dictionary lookup function that handles all types of keys (`str`, `int`, any object ...), and a specialized one for the common case of dictionaries composed of `str`-only keys. -+ The specialized function (named `lookdict_unicode` in CPython's [source](https://github.com/python/cpython/blob/522691c46e2ae51faaad5bbbce7d959dd61770df/Objects/dictobject.c#L841)) knows all existing keys (including the looked-up key) are strings, and uses the faster & simpler string comparison to compare keys, instead of calling the `__eq__` method. -+ The first time a `dict` instance is accessed with a non-`str` key, it's modified so future lookups use the generic function. -+ This process is not reversible for the particular `dict` instance, and the key doesn't even have to exist in the dictionary. That's why attempting a failed lookup has the same effect. +#### ‫ 💡 توضیح: ++ ‫ در CPython یک تابع عمومی برای جستجوی کلید در دیکشنری‌ها وجود دارد که از تمام انواع کلیدها (`str`، `int` و هر شیء دیگر) پشتیبانی می‌کند؛ اما برای حالت متداولی که تمام کلیدها از نوع `str` هستند، یک تابع بهینه‌شده‌ی اختصاصی نیز وجود دارد. ++ ‫ تابع اختصاصی (که در کد منبع CPython با نام [`lookdict_unicode`](https://github.com/python/cpython/blob/522691c46e2ae51faaad5bbbce7d959dd61770df/Objects/dictobject.c#L841) شناخته می‌شود) فرض می‌کند که تمام کلیدهای موجود در دیکشنری (از جمله کلیدی که در حال جستجوی آن هستید) رشته (`str`) هستند و برای مقایسه‌ی کلیدها، به‌جای فراخوانی متد `__eq__`، از مقایسه‌ی سریع‌تر و ساده‌تر رشته‌ای استفاده می‌کند. ++ ‫ اولین باری که یک دیکشنری (`dict`) با کلیدی غیر از `str` فراخوانی شود، این حالت تغییر می‌کند و جستجوهای بعدی از تابع عمومی استفاده خواهند کرد. ++ ‫ این فرایند برای آن نمونه‌ی خاص از دیکشنری غیرقابل بازگشت است و حتی لازم نیست کلید موردنظر در دیکشنری موجود باشد. به همین دلیل است که حتی تلاش ناموفق برای دسترسی به کلیدی ناموجود نیز باعث ایجاد همین تأثیر (کند شدن جستجو) می‌شود. -### ▶ Bloating instance `dict`s * +### ‫ ▶ حجیم کردن دیکشنری نمونه‌ها (`instance dicts`) * ```py import sys @@ -3704,7 +3707,7 @@ def dict_size(o): ``` -**Output:** (Python 3.8, other Python 3 versions may vary a little) +‫ **خروجی:** (پایتون ۳.۸؛ سایر نسخه‌های پایتون ۳ ممکن است کمی متفاوت باشند) ```py >>> o1 = SomeClass() >>> o2 = SomeClass() @@ -3720,13 +3723,13 @@ def dict_size(o): 232 ``` -Let's try again... In a new interpreter: +‫ بیایید دوباره امتحان کنیم... در یک مفسر (interpreter) جدید: ```py >>> o1 = SomeClass() >>> o2 = SomeClass() >>> dict_size(o1) -104 # as expected +104 # همان‌طور که انتظار می‌رفت >>> o1.some_attr5 = 5 >>> o1.some_attr6 = 6 >>> dict_size(o1) @@ -3738,28 +3741,29 @@ Let's try again... In a new interpreter: 232 ``` -What makes those dictionaries become bloated? And why are newly created objects bloated as well? +‫ چه چیزی باعث حجیم‌شدن این دیکشنری‌ها می‌شود؟ و چرا اشیاء تازه ساخته‌شده نیز حجیم هستند؟ -#### 💡 Explanation: -+ CPython is able to reuse the same "keys" object in multiple dictionaries. This was added in [PEP 412](https://www.python.org/dev/peps/pep-0412/) with the motivation to reduce memory usage, specifically in dictionaries of instances - where keys (instance attributes) tend to be common to all instances. -+ This optimization is entirely seamless for instance dictionaries, but it is disabled if certain assumptions are broken. -+ Key-sharing dictionaries do not support deletion; if an instance attribute is deleted, the dictionary is "unshared", and key-sharing is disabled for all future instances of the same class. -+ Additionally, if the dictionary keys have been resized (because new keys are inserted), they are kept shared *only* if they are used by a exactly single dictionary (this allows adding many attributes in the `__init__` of the very first created instance, without causing an "unshare"). If multiple instances exist when a resize happens, key-sharing is disabled for all future instances of the same class: CPython can't tell if your instances are using the same set of attributes anymore, and decides to bail out on attempting to share their keys. -+ A small tip, if you aim to lower your program's memory footprint: don't delete instance attributes, and make sure to initialize all attributes in your `__init__`! +#### 💡 توضیح: ++ ‫ در CPython، امکان استفاده‌ی مجدد از یک شیء «کلیدها» (`keys`) در چندین دیکشنری وجود دارد. این ویژگی در [PEP 412](https://www.python.org/dev/peps/pep-0412/) معرفی شد تا مصرف حافظه کاهش یابد، به‌ویژه برای دیکشنری‌هایی که به نمونه‌ها (instances) تعلق دارند و معمولاً کلیدها (نام صفات نمونه‌ها) بین آن‌ها مشترک است. ++ ‫ این بهینه‌سازی برای دیکشنری‌های نمونه‌ها کاملاً شفاف و خودکار است؛ اما اگر بعضی فرضیات نقض شوند، غیرفعال می‌شود. ++ ‫ دیکشنری‌هایی که کلیدهایشان به اشتراک گذاشته شده باشد، از حذف کلید پشتیبانی نمی‌کنند؛ بنابراین اگر صفتی از یک نمونه حذف شود، دیکشنریِ آن نمونه «غیر مشترک» (`unshared`) شده و این قابلیت اشتراک‌گذاری کلیدها برای تمام نمونه‌هایی که در آینده از آن کلاس ساخته می‌شوند، غیرفعال می‌گردد. ++ ‫ همچنین اگر اندازه‌ی دیکشنری به‌علت اضافه‌شدن کلیدهای جدید تغییر کند (`resize` شود)، اشتراک‌گذاری کلیدها تنها زمانی ادامه می‌یابد که فقط یک دیکشنری در حال استفاده از آن‌ها باشد (این اجازه می‌دهد در متد `__init__` برای اولین نمونه‌ی ساخته‌شده، صفات متعددی تعریف کنید بدون آن‌که اشتراک‌گذاری کلیدها از بین برود). اما اگر چند نمونه همزمان وجود داشته باشند و تغییر اندازه‌ی دیکشنری رخ دهد، قابلیت اشتراک‌گذاری کلیدها برای نمونه‌های بعدی همان کلاس غیرفعال خواهد شد. زیرا CPython دیگر نمی‌تواند مطمئن باشد که آیا نمونه‌های بعدی دقیقاً از مجموعه‌ی یکسانی از صفات استفاده خواهند کرد یا خیر. ++ ‫ نکته‌ای کوچک برای کاهش مصرف حافظه‌ی برنامه: هرگز صفات نمونه‌ها را حذف نکنید و حتماً تمام صفات را در متد `__init__` تعریف و مقداردهی اولیه کنید! -### ▶ Minor Ones * +### ‫ ▶ موارد جزئی * -* `join()` is a string operation instead of list operation. (sort of counter-intuitive at first usage) +* ‫ متد `join()` عملیاتی مربوط به رشته (`str`) است، نه لیست (`list`). (در نگاه اول کمی برخلاف انتظار است.) - **💡 Explanation:** If `join()` is a method on a string, then it can operate on any iterable (list, tuple, iterators). If it were a method on a list, it'd have to be implemented separately by every type. Also, it doesn't make much sense to put a string-specific method on a generic `list` object API. - -* Few weird looking but semantically correct statements: - + `[] = ()` is a semantically correct statement (unpacking an empty `tuple` into an empty `list`) - + `'a'[0][0][0][0][0]` is also semantically correct, because Python doesn't have a character data type like other languages branched from C. So selecting a single character from a string returns a single-character string. - + `3 --0-- 5 == 8` and `--5 == 5` are both semantically correct statements and evaluate to `True`. + ** ‫💡 توضیح:** اگر `join()` به‌عنوان متدی روی رشته پیاده‌سازی شود، می‌تواند روی هر شیء قابل پیمایش (`iterable`) از جمله لیست، تاپل و هر نوع تکرارشونده‌ی دیگر کار کند. اگر به‌جای آن روی لیست تعریف می‌شد، باید به‌طور جداگانه برای هر نوع دیگری نیز پیاده‌سازی می‌شد. همچنین منطقی نیست که یک متد مختص رشته روی یک شیء عمومی مانند `list` پیاده شود. + +* ‫ تعدادی عبارت با ظاهری عجیب اما از نظر معنا صحیح: + + ‫ عبارت `[] = ()` از نظر معنایی صحیح است (باز کردن یا `unpack` کردن یک تاپل خالی درون یک لیست خالی). + + ‫ عبارت `'a'[0][0][0][0][0]` نیز از نظر معنایی صحیح است، زیرا پایتون برخلاف زبان‌هایی که از C منشعب شده‌اند، نوع داده‌ای جداگانه‌ای برای کاراکتر ندارد. بنابراین انتخاب یک کاراکتر از یک رشته، منجر به بازگشت یک رشته‌ی تک‌کاراکتری می‌شود. + + ‫ عبارات `3 --0-- 5 == 8` و `--5 == 5` هر دو از لحاظ معنایی درست بوده و مقدارشان برابر `True` است. + +* ‫ با فرض اینکه `a` یک عدد باشد، عبارات `++a` و `--a` هر دو در پایتون معتبر هستند؛ اما رفتاری مشابه با عبارات مشابه در زبان‌هایی مانند C، ++C یا جاوا ندارند. -* Given that `a` is a number, `++a` and `--a` are both valid Python statements but don't behave the same way as compared with similar statements in languages like C, C++, or Java. ```py >>> a = 5 >>> a @@ -3770,27 +3774,28 @@ What makes those dictionaries become bloated? And why are newly created objects 5 ``` - **💡 Explanation:** - + There is no `++` operator in Python grammar. It is actually two `+` operators. - + `++a` parses as `+(+a)` which translates to `a`. Similarly, the output of the statement `--a` can be justified. - + This StackOverflow [thread](https://stackoverflow.com/questions/3654830/why-are-there-no-and-operators-in-python) discusses the rationale behind the absence of increment and decrement operators in Python. + ** ‫ 💡 توضیح:** + + ‫ در گرامر پایتون عملگری به‌نام `++` وجود ندارد. در واقع `++` دو عملگر `+` جداگانه است. + + ‫ عبارت `++a` به‌شکل `+(+a)` تفسیر می‌شود که معادل `a` است. به‌همین ترتیب، خروجی عبارت `--a` نیز قابل توجیه است. + + ‫ این [تاپیک در StackOverflow](https://stackoverflow.com/questions/3654830/why-are-there-no-and-operators-in-python) دلایل نبودن عملگرهای افزایش (`++`) و کاهش (`--`) در پایتون را بررسی می‌کند. + +* ‫ احتمالاً با عملگر Walrus (گراز دریایی) در پایتون آشنا هستید؛ اما تا به حال در مورد *عملگر Space-invader (مهاجم فضایی)* شنیده‌اید؟ -* You must be aware of the Walrus operator in Python. But have you ever heard about *the space-invader operator*? ```py >>> a = 42 >>> a -=- 1 >>> a 43 ``` - It is used as an alternative incrementation operator, together with another one +‫ از آن به‌عنوان جایگزینی برای عملگر افزایش (increment)، در ترکیب با یک عملگر دیگر استفاده می‌شود. ```py >>> a +=+ 1 >>> a >>> 44 ``` - **💡 Explanation:** This prank comes from [Raymond Hettinger's tweet](https://twitter.com/raymondh/status/1131103570856632321?lang=en). The space invader operator is actually just a malformatted `a -= (-1)`. Which is equivalent to `a = a - (- 1)`. Similar for the `a += (+ 1)` case. - -* Python has an undocumented [converse implication](https://en.wikipedia.org/wiki/Converse_implication) operator. + **‫ 💡 توضیح:** این شوخی از [توییت Raymond Hettinger](https://twitter.com/raymondh/status/1131103570856632321?lang=en) برگرفته شده است. عملگر «مهاجم فضایی» در واقع همان عبارت بدفرمت‌شده‌ی `a -= (-1)` است که معادل با `a = a - (- 1)` می‌باشد. حالت مشابهی برای عبارت `a += (+ 1)` نیز وجود دارد. + +* ‫ پایتون یک عملگر مستندنشده برای [استلزام معکوس (converse implication)](https://en.wikipedia.org/wiki/Converse_implication) دارد. ```py >>> False ** False == True @@ -3803,9 +3808,9 @@ What makes those dictionaries become bloated? And why are newly created objects True ``` - **💡 Explanation:** If you replace `False` and `True` by 0 and 1 and do the maths, the truth table is equivalent to a converse implication operator. ([Source](https://github.com/cosmologicon/pywat/blob/master/explanation.md#the-undocumented-converse-implication-operator)) - -* Since we are talking operators, there's also `@` operator for matrix multiplication (don't worry, this time it's for real). + ‫ **💡 توضیح:** اگر مقادیر `False` و `True` را به‌ترتیب با اعداد ۰ و ۱ جایگزین کرده و محاسبات را انجام دهید، جدول درستی حاصل، معادل یک عملگر استلزام معکوس خواهد بود. ([منبع](https://github.com/cosmologicon/pywat/blob/master/explanation.md#the-undocumented-converse-implication-operator)) + +* ‫ حالا که صحبت از عملگرها شد، عملگر `@` نیز برای ضرب ماتریسی در پایتون وجود دارد (نگران نباشید، این بار واقعی است). ```py >>> import numpy as np @@ -3813,16 +3818,16 @@ What makes those dictionaries become bloated? And why are newly created objects 46 ``` - **💡 Explanation:** The `@` operator was added in Python 3.5 keeping the scientific community in mind. Any object can overload `__matmul__` magic method to define behavior for this operator. + ‫ **💡 توضیح:** عملگر `@` در پایتون ۳٫۵ با در نظر گرفتن نیازهای جامعه علمی اضافه شد. هر شی‌ای می‌تواند متد جادویی `__matmul__` را بازنویسی کند تا رفتار این عملگر را مشخص نماید. -* From Python 3.8 onwards you can use a typical f-string syntax like `f'{some_var=}` for quick debugging. Example, +* ‫ از پایتون ۳٫۸ به بعد می‌توانید از نحو متداول f-string مانند `f'{some_var=}'` برای اشکال‌زدایی سریع استفاده کنید. مثال, ```py >>> some_string = "wtfpython" >>> f'{some_string=}' "some_string='wtfpython'" ``` -* Python uses 2 bytes for local variable storage in functions. In theory, this means that only 65536 variables can be defined in a function. However, python has a handy solution built in that can be used to store more than 2^16 variable names. The following code demonstrates what happens in the stack when more than 65536 local variables are defined (Warning: This code prints around 2^18 lines of text, so be prepared!): +* ‫ پایتون برای ذخیره‌سازی متغیرهای محلی در توابع از ۲ بایت استفاده می‌کند. از نظر تئوری، این به معنای امکان تعریف حداکثر ۶۵۵۳۶ متغیر در یک تابع است. با این حال، پایتون راهکار مفیدی ارائه می‌کند که می‌توان با استفاده از آن بیش از ۲^۱۶ نام متغیر را ذخیره کرد. کد زیر نشان می‌دهد وقتی بیش از ۶۵۵۳۶ متغیر محلی تعریف شود، در پشته (stack) چه اتفاقی رخ می‌دهد (هشدار: این کد تقریباً ۲^۱۸ خط متن چاپ می‌کند، بنابراین آماده باشید!): ```py import dis @@ -3836,9 +3841,9 @@ What makes those dictionaries become bloated? And why are newly created objects print(dis.dis(f)) ``` -* Multiple Python threads won't run your *Python code* concurrently (yes, you heard it right!). It may seem intuitive to spawn several threads and let them execute your Python code concurrently, but, because of the [Global Interpreter Lock](https://wiki.python.org/moin/GlobalInterpreterLock) in Python, all you're doing is making your threads execute on the same core turn by turn. Python threads are good for IO-bound tasks, but to achieve actual parallelization in Python for CPU-bound tasks, you might want to use the Python [multiprocessing](https://docs.python.org/3/library/multiprocessing.html) module. +* ‫ چندین رشته (Thread) در پایتون، کدِ *پایتونی* شما را به‌صورت همزمان اجرا نمی‌کنند (بله، درست شنیدید!). شاید به نظر برسد که ایجاد چندین رشته و اجرای همزمان آن‌ها منطقی است، اما به دلیل وجود [قفل مفسر سراسری (GIL)](https://wiki.python.org/moin/GlobalInterpreterLock) در پایتون، تمام کاری که انجام می‌دهید این است که رشته‌هایتان به‌نوبت روی یک هسته اجرا می‌شوند. رشته‌ها در پایتون برای وظایفی مناسب هستند که عملیات I/O دارند، اما برای رسیدن به موازی‌سازی واقعی در وظایف پردازشی سنگین (CPU-bound)، بهتر است از ماژول [multiprocessing](https://docs.python.org/3/library/multiprocessing.html) در پایتون استفاده کنید. -* Sometimes, the `print` method might not print values immediately. For example, +* ‫ گاهی اوقات، متد `print` ممکن است مقادیر را فوراً چاپ نکند. برای مثال، ```py # File some_file.py @@ -3848,16 +3853,16 @@ What makes those dictionaries become bloated? And why are newly created objects time.sleep(3) ``` - This will print the `wtfpython` after 3 seconds due to the `end` argument because the output buffer is flushed either after encountering `\n` or when the program finishes execution. We can force the buffer to flush by passing `flush=True` argument. + ‫ این کد عبارت `wtfpython` را به دلیل آرگومان `end` پس از ۳ ثانیه چاپ می‌کند؛ چرا که بافر خروجی تنها پس از رسیدن به کاراکتر `\n` یا در زمان اتمام اجرای برنامه تخلیه می‌شود. برای تخلیه‌ی اجباری بافر می‌توانید از آرگومان `flush=True` استفاده کنید. -* List slicing with out of the bounds indices throws no errors +* ‫ برش لیست‌ها (List slicing) با اندیس‌های خارج از محدوده، خطایی ایجاد نمی‌کند. ```py >>> some_list = [1, 2, 3, 4, 5] >>> some_list[111:] [] ``` -* Slicing an iterable not always creates a new object. For example, +* ‫ برش زدن (slicing) یک شئ قابل پیمایش (iterable) همیشه یک شئ جدید ایجاد نمی‌کند. به‌عنوان مثال، ```py >>> some_str = "wtfpython" >>> some_list = ['w', 't', 'f', 'p', 'y', 't', 'h', 'o', 'n'] @@ -3867,9 +3872,9 @@ What makes those dictionaries become bloated? And why are newly created objects True ``` -* `int('١٢٣٤٥٦٧٨٩')` returns `123456789` in Python 3. In Python, Decimal characters include digit characters, and all characters that can be used to form decimal-radix numbers, e.g. U+0660, ARABIC-INDIC DIGIT ZERO. Here's an [interesting story](https://chris.improbable.org/2014/8/25/adventures-in-unicode-digits/) related to this behavior of Python. +* ‫ در پایتون ۳، فراخوانی `int('١٢٣٤٥٦٧٨٩')` مقدار `123456789` را برمی‌گرداند. در پایتون، نویسه‌های ده‌دهی (Decimal characters) شامل تمام ارقامی هستند که می‌توانند برای تشکیل اعداد در مبنای ده استفاده شوند؛ به‌عنوان مثال نویسه‌ی U+0660 که همان رقم صفر عربی-هندی است. [اینجا](https://chris.improbable.org/2014/8/25/adventures-in-unicode-digits/) داستان جالبی درباره این رفتار پایتون آمده است. -* You can separate numeric literals with underscores (for better readability) from Python 3 onwards. +* ‫ از پایتون ۳ به بعد، می‌توانید برای افزایش خوانایی، اعداد را با استفاده از زیرخط (`_`) جدا کنید. ```py >>> six_million = 6_000_000 @@ -3880,7 +3885,7 @@ What makes those dictionaries become bloated? And why are newly created objects 4027435774 ``` -* `'abc'.count('') == 4`. Here's an approximate implementation of `count` method, which would make the things more clear +* ‫ عبارت `'abc'.count('') == 4` مقدار `True` برمی‌گرداند. در اینجا یک پیاده‌سازی تقریبی از متد `count` آورده شده که این موضوع را شفاف‌تر می‌کند: ```py def count(s, sub): result = 0 @@ -3888,7 +3893,7 @@ What makes those dictionaries become bloated? And why are newly created objects result += (s[i:i + len(sub)] == sub) return result ``` - The behavior is due to the matching of empty substring(`''`) with slices of length 0 in the original string. +‫ این رفتار به این دلیل است که زیررشته‌ی خالی (`''`) با برش‌هایی (slices) به طول صفر در رشته‌ی اصلی مطابقت پیدا می‌کند. --- --- From 7ff13596635e3306e698fd933276f4668c5e7dc6 Mon Sep 17 00:00:00 2001 From: Leo Alavi Date: Sun, 16 Mar 2025 21:51:16 +0100 Subject: [PATCH 09/33] Translate Section: Appearances are deceptive --- translations/fa-farsi/README.md | 83 +++++++++++++++++---------------- 1 file changed, 42 insertions(+), 41 deletions(-) diff --git a/translations/fa-farsi/README.md b/translations/fa-farsi/README.md index f55f843..f85f1c1 100644 --- a/translations/fa-farsi/README.md +++ b/translations/fa-farsi/README.md @@ -157,15 +157,15 @@ - [💡 Explanation:](#-explanation-53) - [▶ Let's mangle](#-lets-mangle) - [💡 Explanation:](#-explanation-54) - - [Section: Appearances are deceptive!](#section-appearances-are-deceptive) - - [▶ Skipping lines?](#-skipping-lines) - - [💡 Explanation](#-explanation-55) - - [▶ Teleportation](#-teleportation) - - [💡 Explanation:](#-explanation-56) - - [▶ Well, something is fishy...](#-well-something-is-fishy) - - [💡 Explanation](#-explanation-57) + - [‫ بخش: ظاهرها فریبنده‌اند!](#-بخش-ظاهرها-فریبندهاند) + - [▶ ‫ خطوط را رد می‌کند؟](#--خطوط-را-رد-میکند) + - [‫ 💡 توضیح](#--توضیح) + - [▶ ‫ تله‌پورت کردن](#--تلهپورت-کردن) + - [‫ 💡 توضیح:](#--توضیح-1) + - [▶ ‫ خب، یک جای کار مشکوک است...](#--خب-یک-جای-کار-مشکوک-است) + - [‫ 💡 توضیح](#--توضیح-2) - [بخش: متفرقه](#بخش-متفرقه) - - [▶ `+=` سریع‌تر است](#--سریعتر-است) + - [‫ ▶ `+=` سریع‌تر است](#---سریعتر-است) - [‫ 💡 توضیح:](#---توضیح) - [‫ ▶ بیایید یک رشته‌ی بزرگ بسازیم!](#--بیایید-یک-رشتهی-بزرگ-بسازیم) - [💡 توضیحات](#-توضیحات-1) @@ -3427,9 +3427,9 @@ AttributeError: 'A' object has no attribute '__variable' --- --- -## Section: Appearances are deceptive! +## ‫ بخش: ظاهرها فریبنده‌اند! -### ▶ Skipping lines? +### ▶ ‫ خطوط را رد می‌کند؟ **Output:** ```py @@ -3439,33 +3439,33 @@ AttributeError: 'A' object has no attribute '__variable' 11 ``` -Wut? +‫ چی? -**Note:** The easiest way to reproduce this is to simply copy the statements from the above snippet and paste them into your file/shell. +‫ **نکته:** ساده‌ترین روش برای بازتولید این رفتار، کپی کردن دستورات از کد بالا و جایگذاری (paste) آن‌ها در فایل یا محیط تعاملی (shell) خودتان است. -#### 💡 Explanation +#### ‫ 💡 توضیح -Some non-Western characters look identical to letters in the English alphabet but are considered distinct by the interpreter. +‫ برخی از حروف غیرغربی کاملاً مشابه حروف الفبای انگلیسی به نظر می‌رسند، اما مفسر پایتون آن‌ها را متفاوت در نظر می‌گیرد. ```py ->>> ord('е') # cyrillic 'e' (Ye) +>>> ord('е') # حرف سیریلیک «е» (Ye) 1077 ->>> ord('e') # latin 'e', as used in English and typed using standard keyboard +>>> ord('e') # حرف لاتین «e»، که در انگلیسی استفاده می‌شود و با صفحه‌کلید استاندارد تایپ می‌گردد 101 >>> 'е' == 'e' False ->>> value = 42 # latin e ->>> valuе = 23 # cyrillic 'e', Python 2.x interpreter would raise a `SyntaxError` here +>>> value = 42 # حرف لاتین e +>>> valuе = 23 # حرف سیریلیک «е»؛ مفسر پایتون نسخه ۲ در اینجا خطای `SyntaxError` ایجاد می‌کند >>> value 42 ``` -The built-in `ord()` function returns a character's Unicode [code point](https://en.wikipedia.org/wiki/Code_point), and different code positions of Cyrillic 'e' and Latin 'e' justify the behavior of the above example. +‫ تابع داخلی `ord()`، [کدپوینت](https://fa.wikipedia.org/wiki/کدپوینت) یونیکد مربوط به یک نویسه را برمی‌گرداند. موقعیت‌های کدی متفاوت برای حرف سیریلیک «е» و حرف لاتین «e»، علت رفتار مثال بالا را توجیه می‌کنند. --- -### ▶ Teleportation +### ▶ ‫ تله‌پورت کردن @@ -3474,36 +3474,36 @@ The built-in `ord()` function returns a character's Unicode [code point](https:/ import numpy as np def energy_send(x): - # Initializing a numpy array + # مقداردهی اولیه یک آرایه numpy np.array([float(x)]) def energy_receive(): - # Return an empty numpy array + # بازگرداندن یک آرایه‌ی خالی numpy return np.empty((), dtype=np.float).tolist() ``` -**Output:** +‫ **خروجی:** ```py >>> energy_send(123.456) >>> energy_receive() 123.456 ``` -Where's the Nobel Prize? +‫ جایزه نوبل کجاست؟ -#### 💡 Explanation: +#### ‫ 💡 توضیح: -* Notice that the numpy array created in the `energy_send` function is not returned, so that memory space is free to reallocate. -* `numpy.empty()` returns the next free memory slot without reinitializing it. This memory spot just happens to be the same one that was just freed (usually, but not always). +* ‫ توجه کنید که آرایه‌ی numpy ایجادشده در تابع `energy_send` برگردانده نشده است، بنابراین فضای حافظه‌ی آن آزاد شده و مجدداً قابل استفاده است. +* ‫ تابع `numpy.empty()` نزدیک‌ترین فضای حافظه‌ی آزاد را بدون مقداردهی مجدد برمی‌گرداند. این فضای حافظه معمولاً همان فضایی است که به‌تازگی آزاد شده است (البته معمولاً این اتفاق می‌افتد و نه همیشه). --- -### ▶ Well, something is fishy... +### ▶ ‫ خب، یک جای کار مشکوک است... ```py def square(x): """ - A simple function to calculate the square of a number by addition. + یک تابع ساده برای محاسبه‌ی مربع یک عدد با استفاده از جمع. """ sum_so_far = 0 for counter in range(x): @@ -3511,27 +3511,28 @@ def square(x): return sum_so_far ``` -**Output (Python 2.x):** +‫ **خروجی (پایتون 2.X):** ```py >>> square(10) 10 ``` -Shouldn't that be 100? +‫ آیا این نباید ۱۰۰ باشد؟ -**Note:** If you're not able to reproduce this, try running the file [mixed_tabs_and_spaces.py](/mixed_tabs_and_spaces.py) via the shell. +‫ **نکته:** اگر نمی‌توانید این مشکل را بازتولید کنید، سعی کنید فایل [mixed_tabs_and_spaces.py](/mixed_tabs_and_spaces.py) را از طریق شِل اجرا کنید. -#### 💡 Explanation +#### ‫ 💡 توضیح -* **Don't mix tabs and spaces!** The character just preceding return is a "tab", and the code is indented by multiple of "4 spaces" elsewhere in the example. -* This is how Python handles tabs: - - > First, tabs are replaced (from left to right) by one to eight spaces such that the total number of characters up to and including the replacement is a multiple of eight <...> -* So the "tab" at the last line of `square` function is replaced with eight spaces, and it gets into the loop. -* Python 3 is kind enough to throw an error for such cases automatically. +* ‫ **تب‌ها و فاصله‌ها (space) را با هم ترکیب نکنید!** کاراکتری که دقیقاً قبل از دستور return آمده یک «تب» است، در حالی که در بقیۀ مثال، کد با مضربی از «۴ فاصله» تورفتگی دارد. +* ‫ نحوۀ برخورد پایتون با تب‌ها به این صورت است: + + > ‫ ابتدا تب‌ها (از چپ به راست) با یک تا هشت فاصله جایگزین می‌شوند به‌طوری که تعداد کل کاراکترها تا انتهای آن جایگزینی، مضربی از هشت باشد <...> +* ‫ بنابراین «تب» در آخرین خط تابع `square` با هشت فاصله جایگزین شده و به همین دلیل داخل حلقه قرار می‌گیرد. +* ‫ پایتون ۳ آنقدر هوشمند هست که چنین مواردی را به‌صورت خودکار با خطا اعلام کند. + + ‫ **خروجی (Python 3.x):** - **Output (Python 3.x):** ```py TabError: inconsistent use of tabs and spaces in indentation ``` @@ -3542,7 +3543,7 @@ Shouldn't that be 100? ## بخش: متفرقه -### ▶ `+=` سریع‌تر است +### ‫ ▶ `+=` سریع‌تر است ```py From ddab1b6ad23b1b83afc1fca0b03c003796fb9504 Mon Sep 17 00:00:00 2001 From: Leo Alavi Date: Mon, 17 Mar 2025 10:44:44 +0100 Subject: [PATCH 10/33] Translate hidden treasures section --- translations/fa-farsi/README.md | 212 ++++++++++++++++---------------- 1 file changed, 108 insertions(+), 104 deletions(-) diff --git a/translations/fa-farsi/README.md b/translations/fa-farsi/README.md index f85f1c1..43a5179 100644 --- a/translations/fa-farsi/README.md +++ b/translations/fa-farsi/README.md @@ -138,32 +138,32 @@ - [💡 Explanation:](#-explanation-44) - [▶ Midnight time doesn't exist?](#-midnight-time-doesnt-exist) - [💡 Explanation:](#-explanation-45) - - [Section: The Hidden treasures!](#section-the-hidden-treasures) - - [▶ Okay Python, Can you make me fly?](#-okay-python-can-you-make-me-fly) - - [💡 Explanation:](#-explanation-46) - - [▶ `goto`, but why?](#-goto-but-why) - - [💡 Explanation:](#-explanation-47) - - [▶ Brace yourself!](#-brace-yourself) - - [💡 Explanation:](#-explanation-48) - - [▶ Let's meet Friendly Language Uncle For Life](#-lets-meet-friendly-language-uncle-for-life) - - [💡 Explanation:](#-explanation-49) - - [▶ Even Python understands that love is complicated](#-even-python-understands-that-love-is-complicated) - - [💡 Explanation:](#-explanation-50) - - [▶ Yes, it exists!](#-yes-it-exists) - - [💡 Explanation:](#-explanation-51) + - [‫ بخش: گنجینه‌های پنهان!](#-بخش-گنجینههای-پنهان) + - [▶ ‫ خب پایتون، می‌توانی کاری کنی پرواز کنم؟](#--خب-پایتون-میتوانی-کاری-کنی-پرواز-کنم) + - [‫ 💡 توضیح:](#--توضیح) + - [▶ ‫ `goto`، ولی چرا؟](#--goto-ولی-چرا) + - [‫ 💡 توضیح:](#--توضیح-1) + - [▶ ‫ خودتان را آماده کنید!](#--خودتان-را-آماده-کنید) + - [‫ 💡 توضیح:](#--توضیح-2) + - [▶ ‫ بیایید با «عمو زبان مهربان برای همیشه» آشنا شویم](#--بیایید-با-عمو-زبان-مهربان-برای-همیشه-آشنا-شویم) + - [‫ 💡 توضیح:](#--توضیح-3) + - [▶ ‫ حتی پایتون هم می‌داند که عشق پیچیده است](#--حتی-پایتون-هم-میداند-که-عشق-پیچیده-است) + - [‫ 💡 توضیح:](#--توضیح-4) + - [▶ ‫ بله، این واقعاً وجود دارد!](#--بله-این-واقعاً-وجود-دارد) + - [‫ 💡 توضیح:](#--توضیح-5) - [▶ Ellipsis \*](#-ellipsis-) - - [💡 Explanation](#-explanation-52) - - [▶ Inpinity](#-inpinity) - - [💡 Explanation:](#-explanation-53) - - [▶ Let's mangle](#-lets-mangle) - - [💡 Explanation:](#-explanation-54) + - [‫ 💡توضیح](#-توضیح) + - [▶ ‫ بی‌نهایت (`Inpinity`)](#--بینهایت-inpinity) + - [‫ 💡 توضیح:](#--توضیح-6) + - [▶ ‫ بیایید خرابکاری کنیم](#--بیایید-خرابکاری-کنیم) + - [‫ 💡 توضیح:](#--توضیح-7) - [‫ بخش: ظاهرها فریبنده‌اند!](#-بخش-ظاهرها-فریبندهاند) - [▶ ‫ خطوط را رد می‌کند؟](#--خطوط-را-رد-میکند) - - [‫ 💡 توضیح](#--توضیح) + - [‫ 💡 توضیح](#--توضیح-8) - [▶ ‫ تله‌پورت کردن](#--تلهپورت-کردن) - - [‫ 💡 توضیح:](#--توضیح-1) + - [‫ 💡 توضیح:](#--توضیح-9) - [▶ ‫ خب، یک جای کار مشکوک است...](#--خب-یک-جای-کار-مشکوک-است) - - [‫ 💡 توضیح](#--توضیح-2) + - [‫ 💡 توضیح](#--توضیح-10) - [بخش: متفرقه](#بخش-متفرقه) - [‫ ▶ `+=` سریع‌تر است](#---سریعتر-است) - [‫ 💡 توضیح:](#---توضیح) @@ -172,7 +172,7 @@ - [▶ ‫ کُند کردن جستجوها در `dict` \*](#---کُند-کردن-جستجوها-در-dict-) - [‫ 💡 توضیح:](#---توضیح-1) - [‫ ▶ حجیم کردن دیکشنری نمونه‌ها (`instance dicts`) \*](#--حجیم-کردن-دیکشنری-نمونهها-instance-dicts-) - - [💡 توضیح:](#-توضیح) + - [💡 توضیح:](#-توضیح-1) - [‫ ▶ موارد جزئی \*](#---موارد-جزئی-) - [‫ مشارکت](#-مشارکت) - [‫ تقدیر و تشکر](#-تقدیر-و-تشکر) @@ -3064,29 +3064,29 @@ Before Python 3.5, the boolean value for `datetime.time` object was considered t -## Section: The Hidden treasures! +## ‫ بخش: گنجینه‌های پنهان! -This section contains a few lesser-known and interesting things about Python that most beginners like me are unaware of (well, not anymore). +‫ این بخش شامل چند مورد جالب و کمتر شناخته‌شده درباره‌ی پایتون است که بیشتر مبتدی‌هایی مثل من از آن بی‌خبرند (البته دیگر اینطور نیست). -### ▶ Okay Python, Can you make me fly? +### ▶ ‫ خب پایتون، می‌توانی کاری کنی پرواز کنم؟ -Well, here you go +‫ خب، بفرمایید ```py import antigravity ``` -**Output:** +‫ **خروجی:** Sshh... It's a super-secret. -#### 💡 Explanation: -+ `antigravity` module is one of the few easter eggs released by Python developers. -+ `import antigravity` opens up a web browser pointing to the [classic XKCD comic](https://xkcd.com/353/) about Python. -+ Well, there's more to it. There's **another easter egg inside the easter egg**. If you look at the [code](https://github.com/python/cpython/blob/master/Lib/antigravity.py#L7-L17), there's a function defined that purports to implement the [XKCD's geohashing algorithm](https://xkcd.com/426/). +#### ‫ 💡 توضیح: ++ ‫ ماژول `antigravity` یکی از معدود ایستر اِگ‌هایی است که توسط توسعه‌دهندگان پایتون ارائه شده است. ++ ‫ دستور `import antigravity` باعث می‌شود مرورگر وب به سمت [کمیک کلاسیک XKCD](https://xkcd.com/353/) در مورد پایتون باز شود. ++ ‫ البته موضوع عمیق‌تر است؛ در واقع یک **ایستر اگ دیگر داخل این ایستر اگ** وجود دارد. اگر به [کد منبع](https://github.com/python/cpython/blob/master/Lib/antigravity.py#L7-L17) نگاه کنید، یک تابع تعریف شده که ادعا می‌کند [الگوریتم جئوهشینگ XKCD](https://xkcd.com/426/) را پیاده‌سازی کرده است. --- -### ▶ `goto`, but why? +### ▶ ‫ `goto`، ولی چرا؟ ```py @@ -3096,56 +3096,56 @@ for i in range(9): for k in range(9): print("I am trapped, please rescue!") if k == 2: - goto .breakout # breaking out from a deeply nested loop + goto .breakout # خروج از یک حلقه‌ی تودرتوی عمیق label .breakout print("Freedom!") ``` -**Output (Python 2.3):** +‫ **خروجی (پایتون ۲.۳):** ```py I am trapped, please rescue! I am trapped, please rescue! Freedom! ``` -#### 💡 Explanation: -- A working version of `goto` in Python was [announced](https://mail.python.org/pipermail/python-announce-list/2004-April/002982.html) as an April Fool's joke on 1st April 2004. -- Current versions of Python do not have this module. -- Although it works, but please don't use it. Here's the [reason](https://docs.python.org/3/faq/design.html#why-is-there-no-goto) to why `goto` is not present in Python. +#### ‫ 💡 توضیح: +- ‫ نسخه‌ی قابل استفاده‌ای از `goto` در پایتون به عنوان یک شوخی [در اول آوریل ۲۰۰۴ معرفی شد](https://mail.python.org/pipermail/python-announce-list/2004-April/002982.html). +- ‫ نسخه‌های فعلی پایتون فاقد این ماژول هستند. +- ‫ اگرچه این ماژول واقعاً کار می‌کند، ولی لطفاً از آن استفاده نکنید. در [این صفحه](https://docs.python.org/3/faq/design.html#why-is-there-no-goto) می‌توانید دلیل عدم حضور دستور `goto` در پایتون را مطالعه کنید. --- -### ▶ Brace yourself! +### ▶ ‫ خودتان را آماده کنید! -If you are one of the people who doesn't like using whitespace in Python to denote scopes, you can use the C-style {} by importing, +‫ اگر جزو افرادی هستید که دوست ندارند در پایتون برای مشخص کردن محدوده‌ها از فضای خالی (whitespace) استفاده کنند، می‌توانید با ایمپورت کردن ماژول زیر از آکولاد `{}` به سبک زبان C استفاده کنید: ```py from __future__ import braces ``` -**Output:** +‫ **خروجی:** ```py File "some_file.py", line 1 from __future__ import braces SyntaxError: not a chance ``` -Braces? No way! If you think that's disappointing, use Java. Okay, another surprising thing, can you find where's the `SyntaxError` raised in `__future__` module [code](https://github.com/python/cpython/blob/master/Lib/__future__.py)? +‫ آکولاد؟ هرگز! اگر از این بابت ناامید شدید، بهتر است از جاوا استفاده کنید. خب، یک چیز شگفت‌آور دیگر؛ آیا می‌توانید تشخیص دهید که ارور `SyntaxError` در کجای کد ماژول `__future__` [اینجا](https://github.com/python/cpython/blob/master/Lib/__future__.py) ایجاد می‌شود؟ -#### 💡 Explanation: -+ The `__future__` module is normally used to provide features from future versions of Python. The "future" in this specific context is however, ironic. -+ This is an easter egg concerned with the community's feelings on this issue. -+ The code is actually present [here](https://github.com/python/cpython/blob/025eb98dc0c1dc27404df6c544fc2944e0fa9f3a/Python/future.c#L49) in `future.c` file. -+ When the CPython compiler encounters a [future statement](https://docs.python.org/3.3/reference/simple_stmts.html#future-statements), it first runs the appropriate code in `future.c` before treating it as a normal import statement. +#### ‫ 💡 توضیح: ++ ‫ ماژول `__future__` معمولاً برای ارائه قابلیت‌هایی از نسخه‌های آینده پایتون به کار می‌رود. اما کلمه «future» (آینده) در این زمینه خاص، حالت طنز و کنایه دارد. ++ ‫ این مورد یک «ایستر اگ» (easter egg) است که به احساسات جامعه برنامه‌نویسان پایتون در این خصوص اشاره دارد. ++ ‫ کد مربوط به این موضوع در واقع [اینجا](https://github.com/python/cpython/blob/025eb98dc0c1dc27404df6c544fc2944e0fa9f3a/Python/future.c#L49) در فایل `future.c` قرار دارد. ++ ‫ زمانی که کامپایلر CPython با یک [عبارت future](https://docs.python.org/3.3/reference/simple_stmts.html#future-statements) مواجه می‌شود، ابتدا کد مرتبط در `future.c` را اجرا کرده و سپس آن را همانند یک دستور ایمپورت عادی در نظر می‌گیرد. --- -### ▶ Let's meet Friendly Language Uncle For Life +### ▶ ‫ بیایید با «عمو زبان مهربان برای همیشه» آشنا شویم **Output (Python 3.x)** ```py >>> from __future__ import barry_as_FLUFL ->>> "Ruby" != "Python" # there's no doubt about it +>>> "Ruby" != "Python" # شکی در این نیست. File "some_file.py", line 1 "Ruby" != "Python" ^ @@ -3155,15 +3155,17 @@ SyntaxError: invalid syntax True ``` -There we go. +‫ حالا می‌رسیم به اصل ماجرا. -#### 💡 Explanation: -- This is relevant to [PEP-401](https://www.python.org/dev/peps/pep-0401/) released on April 1, 2009 (now you know, what it means). -- Quoting from the PEP-401 +#### ‫ 💡 توضیح: +- ‫ این مورد مربوط به [PEP-401](https://www.python.org/dev/peps/pep-0401/) است که در تاریخ ۱ آوریل ۲۰۰۹ منتشر شد (اکنون می‌دانید این یعنی چه!). +- ‫ نقل قولی از PEP-401: + + > ‫ با توجه به اینکه عملگر نابرابری `!=` در پایتون ۳.۰ یک اشتباه وحشتناک و انگشت‌سوز (!) بوده است، عمو زبان مهربان برای همیشه (FLUFL) عملگر الماسی‌شکل `<>` را مجدداً به‌عنوان تنها روش درست برای این منظور بازگردانده است. - > Recognized that the != inequality operator in Python 3.0 was a horrible, finger-pain inducing mistake, the FLUFL reinstates the <> diamond operator as the sole spelling. -- There were more things that Uncle Barry had to share in the PEP; you can read them [here](https://www.python.org/dev/peps/pep-0401/). -- It works well in an interactive environment, but it will raise a `SyntaxError` when you run via python file (see this [issue](https://github.com/satwikkansal/wtfpython/issues/94)). However, you can wrap the statement inside an `eval` or `compile` to get it working, +- ‫ البته «عمو بَری» چیزهای بیشتری برای گفتن در این PEP داشت؛ می‌توانید آن‌ها را [اینجا](https://www.python.org/dev/peps/pep-0401/) مطالعه کنید. +- ‫ این قابلیت در محیط تعاملی به خوبی عمل می‌کند، اما در زمان اجرای کد از طریق فایل پایتون، با خطای `SyntaxError` روبرو خواهید شد (برای اطلاعات بیشتر به این [issue](https://github.com/satwikkansal/wtfpython/issues/94) مراجعه کنید). با این حال، می‌توانید کد خود را درون یک `eval` یا `compile` قرار دهید تا این قابلیت فعال شود. + ```py from __future__ import barry_as_FLUFL print(eval('"Ruby" <> "Python"')) @@ -3171,7 +3173,7 @@ There we go. --- -### ▶ Even Python understands that love is complicated +### ▶ ‫ حتی پایتون هم می‌داند که عشق پیچیده است ```py import this @@ -3179,7 +3181,7 @@ import this Wait, what's **this**? `this` is love :heart: -**Output:** +‫ **خروجی:** ``` The Zen of Python, by Tim Peters @@ -3204,7 +3206,7 @@ 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! ``` -It's the Zen of Python! +‫ این ذنِ پایتون است! ```py >>> love = this @@ -3216,21 +3218,21 @@ False False >>> love is not True or False True ->>> love is not True or False; love is love # Love is complicated +>>> love is not True or False; love is love # عشق پیجیده است True ``` -#### 💡 Explanation: +#### ‫ 💡 توضیح: -* `this` module in Python is an easter egg for The Zen Of Python ([PEP 20](https://www.python.org/dev/peps/pep-0020)). -* And if you think that's already interesting enough, check out the implementation of [this.py](https://hg.python.org/cpython/file/c3896275c0f6/Lib/this.py). Interestingly, **the code for the Zen violates itself** (and that's probably the only place where this happens). -* Regarding the statement `love is not True or False; love is love`, ironic but it's self-explanatory (if not, please see the examples related to `is` and `is not` operators). +* ‫ ماژول `this` در پایتون، یک ایستر اگ برای «ذنِ پایتون» ([PEP 20](https://www.python.org/dev/peps/pep-0020)) است. +* ‫ اگر این موضوع به‌اندازه کافی جالب است، حتماً پیاده‌سازی [this.py](https://hg.python.org/cpython/file/c3896275c0f6/Lib/this.py) را ببینید. نکته جالب این است که **کد مربوط به ذنِ پایتون، خودش اصول ذن را نقض کرده است** (و احتمالاً این تنها جایی است که چنین اتفاقی می‌افتد). +* ‫ درباره جمله `love is not True or False; love is love`، اگرچه طعنه‌آمیز است، اما خود گویاست. (اگر واضح نیست، لطفاً مثال‌های مربوط به عملگرهای `is` و `is not` را مشاهده کنید.) --- -### ▶ Yes, it exists! +### ▶ ‫ بله، این واقعاً وجود دارد! -**The `else` clause for loops.** One typical example might be: +‫ **عبارت `else` برای حلقه‌ها.** یک مثال معمول آن می‌تواند چنین باشد: ```py def does_exists_num(l, to_find): @@ -3242,7 +3244,7 @@ True print("Does not exist") ``` -**Output:** +**خروجی:** ```py >>> some_list = [1, 2, 3, 4, 5] >>> does_exists_num(some_list, 4) @@ -3251,7 +3253,7 @@ Exists! Does not exist ``` -**The `else` clause in exception handling.** An example, +**عبارت `else` در مدیریت استثناها.** مثالی از آن: ```py try: @@ -3262,14 +3264,14 @@ else: print("Try block executed successfully...") ``` -**Output:** +**خروجی:** ```py Try block executed successfully... ``` -#### 💡 Explanation: -- The `else` clause after a loop is executed only when there's no explicit `break` after all the iterations. You can think of it as a "nobreak" clause. -- `else` clause after a try block is also called "completion clause" as reaching the `else` clause in a `try` statement means that the try block actually completed successfully. +#### ‫ 💡 توضیح: +- عبارت `else` بعد از حلقه‌ها تنها زمانی اجرا می‌شود که در هیچ‌کدام از تکرارها (`iterations`) از دستور `break` استفاده نشده باشد. می‌توانید آن را به عنوان یک شرط «بدون شکست» (nobreak) در نظر بگیرید. +- عبارت `else` پس از بلاک `try` به عنوان «عبارت تکمیل» (`completion clause`) نیز شناخته می‌شود؛ چراکه رسیدن به عبارت `else` در ساختار `try` به این معنی است که بلاک `try` بدون رخ دادن استثنا با موفقیت تکمیل شده است. --- ### ▶ Ellipsis * @@ -3279,10 +3281,10 @@ def some_func(): Ellipsis ``` -**Output** +**خروجی** ```py >>> some_func() -# No output, No Error +# بدون خروجی و بدون خطا >>> SomeRandomString Traceback (most recent call last): @@ -3293,15 +3295,16 @@ NameError: name 'SomeRandomString' is not defined Ellipsis ``` -#### 💡 Explanation -- In Python, `Ellipsis` is a globally available built-in object which is equivalent to `...`. +#### ‫ 💡توضیح +- ‫ در پایتون، `Ellipsis` یک شیء درونی (`built-in`) است که به صورت سراسری (`global`) در دسترس است و معادل `...` است. ```py >>> ... Ellipsis ``` -- Ellipsis can be used for several purposes, - + As a placeholder for code that hasn't been written yet (just like `pass` statement) - + In slicing syntax to represent the full slices in remaining direction +- ‫ `Ellipsis` می‌تواند برای چندین منظور استفاده شود: + + ‫ به عنوان یک نگه‌دارنده برای کدی که هنوز نوشته نشده است (مانند دستور `pass`) + + ‫ در سینتکس برش (`slicing`) برای نمایش برش کامل در ابعاد باقی‌مانده + ```py >>> import numpy as np >>> three_dimensional_array = np.arange(8).reshape(2, 2, 2) @@ -3317,26 +3320,27 @@ Ellipsis ] ]) ``` - So our `three_dimensional_array` is an array of array of arrays. Let's say we want to print the second element (index `1`) of all the innermost arrays, we can use Ellipsis to bypass all the preceding dimensions + ‫ بنابراین، آرایه‌ی `three_dimensional_array` ما، آرایه‌ای از آرایه‌ها از آرایه‌ها است. فرض کنیم می‌خواهیم عنصر دوم (اندیس `1`) از تمامی آرایه‌های درونی را چاپ کنیم؛ در این حالت می‌توانیم از `Ellipsis` برای عبور از تمامی ابعاد قبلی استفاده کنیم: ```py >>> three_dimensional_array[:,:,1] array([[1, 3], [5, 7]]) - >>> three_dimensional_array[..., 1] # using Ellipsis. + >>> three_dimensional_array[..., 1] # با استفاده از Ellipsis. array([[1, 3], [5, 7]]) ``` - Note: this will work for any number of dimensions. You can even select slice in first and last dimension and ignore the middle ones this way (`n_dimensional_array[firs_dim_slice, ..., last_dim_slice]`) - + In [type hinting](https://docs.python.org/3/library/typing.html) to indicate only a part of the type (like `(Callable[..., int]` or `Tuple[str, ...]`)) - + You may also use Ellipsis as a default function argument (in the cases when you want to differentiate between the "no argument passed" and "None value passed" scenarios). + ‫ نکته: این روش برای آرایه‌هایی با هر تعداد بُعد کار می‌کند. حتی می‌توانید از برش (`slice`) در بُعد اول و آخر استفاده کرده و ابعاد میانی را نادیده بگیرید (به صورت `n_dimensional_array[first_dim_slice, ..., last_dim_slice]`). + + ‫ در [نوع‌دهی (`type hinting`)](https://docs.python.org/3/library/typing.html) برای اشاره به بخشی از نوع (مانند `Callable[..., int]` یا `Tuple[str, ...]`) استفاده می‌شود. + + ‫ همچنین می‌توانید از `Ellipsis` به عنوان آرگومان پیش‌فرض تابع استفاده کنید (برای مواردی که می‌خواهید میان «آرگومانی ارسال نشده است» و «مقدار `None` ارسال شده است» تمایز قائل شوید). + --- -### ▶ Inpinity +### ▶ ‫ بی‌نهایت (`Inpinity`) -The spelling is intended. Please, don't submit a patch for this. +‫ این املای کلمه تعمداً به همین شکل نوشته شده است. لطفاً برای اصلاح آن درخواست (`patch`) ارسال نکنید. -**Output (Python 3.x):** +‫ **خروجی (پایتون 3.x):** ```py >>> infinity = float('infinity') >>> hash(infinity) @@ -3345,13 +3349,13 @@ The spelling is intended. Please, don't submit a patch for this. -314159 ``` -#### 💡 Explanation: -- Hash of infinity is 10⁵ x π. -- Interestingly, the hash of `float('-inf')` is "-10⁵ x π" in Python 3, whereas "-10⁵ x e" in Python 2. +#### ‫ 💡 توضیح: +- ‫ هش (`hash`) مقدار بی‌نهایت برابر با 10⁵ × π است. +- ‫ نکته جالب اینکه در پایتون ۳ هشِ مقدار `float('-inf')` برابر با «-10⁵ × π» است، در حالی که در پایتون ۲ برابر با «-10⁵ × e» است. --- -### ▶ Let's mangle +### ▶ ‫ بیایید خرابکاری کنیم 1\. ```py @@ -3361,7 +3365,7 @@ class Yo(object): self.bro = True ``` -**Output:** +‫ **خروجی:** ```py >>> Yo().bro True @@ -3375,12 +3379,12 @@ True ```py class Yo(object): def __init__(self): - # Let's try something symmetrical this time + # این بار بیایید چیزی متقارن را امتحان کنیم self.__honey__ = True self.bro = True ``` -**Output:** +‫ **خروجی:** ```py >>> Yo().bro True @@ -3391,7 +3395,7 @@ Traceback (most recent call last): AttributeError: 'Yo' object has no attribute '_Yo__honey__' ``` -Why did `Yo()._Yo__honey` work? +چرا کد `Yo()._Yo__honey` کار کرد؟ 3\. @@ -3400,10 +3404,10 @@ _A__variable = "Some value" class A(object): def some_func(self): - return __variable # not initialized anywhere yet + return __variable # هنوز در هیچ جا مقداردهی اولیه نشده است ``` -**Output:** +‫ **خروجی:** ```py >>> A().__variable Traceback (most recent call last): @@ -3415,14 +3419,14 @@ AttributeError: 'A' object has no attribute '__variable' ``` -#### 💡 Explanation: +#### ‫ 💡 توضیح: -* [Name Mangling](https://en.wikipedia.org/wiki/Name_mangling) is used to avoid naming collisions between different namespaces. -* In Python, the interpreter modifies (mangles) the class member names starting with `__` (double underscore a.k.a "dunder") and not ending with more than one trailing underscore by adding `_NameOfTheClass` in front. -* So, to access `__honey` attribute in the first snippet, we had to append `_Yo` to the front, which would prevent conflicts with the same name attribute defined in any other class. -* But then why didn't it work in the second snippet? Because name mangling excludes the names ending with double underscores. -* The third snippet was also a consequence of name mangling. The name `__variable` in the statement `return __variable` was mangled to `_A__variable`, which also happens to be the name of the variable we declared in the outer scope. -* Also, if the mangled name is longer than 255 characters, truncation will happen. +* ‫ [تغییر نام](https://en.wikipedia.org/wiki/Name_mangling) برای جلوگیری از برخورد نام‌ها بین فضاهای نام مختلف استفاده می‌شود. +* ‫ در پایتون، مفسر نام‌های اعضای کلاس که با `__` (دو آندرلاین که به عنوان "دندر" شناخته می‌شود) شروع می‌شوند و بیش از یک آندرلاین انتهایی ندارند را با اضافه کردن `_NameOfTheClass` در ابتدای آنها تغییر می‌دهد. +* ‫ بنابراین، برای دسترسی به ویژگی `__honey` در اولین قطعه کد، مجبور بودیم `_Yo` را به ابتدای آن اضافه کنیم، که از بروز تعارض با ویژگی با همان نام تعریف‌شده در هر کلاس دیگری جلوگیری می‌کند. +* ‫ اما چرا در دومین قطعه کد کار نکرد؟ زیرا تغییر نام، نام‌هایی که با دو آندرلاین خاتمه می‌یابند را شامل نمی‌شود. +* ‫ قطعه سوم نیز نتیجه تغییر نام بود. نام `__variable` در عبارت `return __variable` به `_A__variable` تغییر یافت، که همچنین همان نام متغیری است که در محدوده بیرونی تعریف کرده بودیم. +* ‫ همچنین، اگر نام تغییر یافته بیش از ۲۵۵ کاراکتر باشد، برش داده می‌شود. --- --- From 2ca7ebe2a4ccf04775271e3ec2e448889af196ca Mon Sep 17 00:00:00 2001 From: Mohamad Reza Date: Tue, 18 Mar 2025 15:20:17 +0330 Subject: [PATCH 11/33] update farsi translation - section 1 --- translations/fa-farsi/section1-temp.md | 217 +++++++++++++++++++++++++ 1 file changed, 217 insertions(+) diff --git a/translations/fa-farsi/section1-temp.md b/translations/fa-farsi/section1-temp.md index f14400d..7c37b26 100644 --- a/translations/fa-farsi/section1-temp.md +++ b/translations/fa-farsi/section1-temp.md @@ -585,6 +585,7 @@ TypeError: unhashable type: 'dict' >>> len(another_set) 2 ``` + پس بی‌ثباتی تو این رفتار به خاطر اینه که مقدار `another_ordered_dict in another_set` برابر با `False` هست چون `ordered_dict` از قبل داخل `another_set` هست و همونطور که قبلا مشاهده کردید، مقدار `ordered_dict == another_ordered_dict` برابر با `False` هست. --- @@ -788,3 +789,219 @@ False - در مثال بالا، عبارت `(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` رو تشکیل میدیم، تصویر زیر نشون میده که چه اتفاقی در حافظه دستگاه میافته. + +

+ + + + Shows a memory segment after row is initialized. + +

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

+ + + + Shows a memory segment after board is initialized. + +

+ +ما می‌تونیم با استفاده نکردن از متغیر `row` برای تولید متغیر `board` از این سناریو پرهیز کنیم. (در [این](https://github.com/satwikkansal/wtfpython/issues/68) موضوع پرسیده شده). + +```py +>>> board = [['']*3 for _ in range(3)] +>>> board[0][0] = "X" +>>> board +[['X', '', ''], ['', '', ''], ['', '', '']] +``` + +--- + + +### ▶ متغیر شرودینگر * + + + +```py +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] +``` + +**خروجی:** +```py +>>> results +[0, 1, 2, 3, 4, 5, 6] +>>> funcs_results +[6, 6, 6, 6, 6, 6, 6] +``` + +مقدار `x` در هر تکرار حلقه قبل از اضافه کردن `some_func` به لیست `funcs` متفاوت بود، ولی همه توابع در خارج از حلقه مقدار `6` رو برمیگردونند. + +2. + +```py +>>> powers_of_x = [lambda x: x**i for i in range(10)] +>>> [f(2) for f in powers_of_x] +[512, 512, 512, 512, 512, 512, 512, 512, 512, 512] +``` + +#### 💡 توضیحات: +* وقتی یک تابع رو در داخل یک حلقه تعریف می‌کنیم که در بدنه‌اش از متغیر اون حلقه استفاده شده، بست این تابع به *متغیر* وصله، نه *مقدار* اون. تابع به جای اینکه از مقدار `x` در زمان تعریف تابع استفاده کنه، در زمینه اطرافش دنبال `x` می‌گرده. پس همه این توابع از آخرین مقداری که به متغیر `x` مقداردهی شده برای محاسباتشون استفاده می‌کنند. ما می‌تونیم ببینیم که این توابع از متغیر `x` که در زمینه اطرافشون (*نه* از متغیر محلی) هست، استفاده می‌کنند، به این صورت: + +```py +>>> import inspect +>>> inspect.getclosurevars(funcs[0]) +ClosureVars(nonlocals={}, globals={'x': 6}, builtins={}, unbound=set()) +``` + +از اونجایی که `x` یک متغیر سراسریه (گلوبال)، ما می‌تونیم مقداری که توابع داخل `funcs` دنبالشون می‌گردند و برمیگردونند رو با به‌روز کردن `x` تغییر بدیم: + +```py +>>> x = 42 +>>> [func() for func in funcs] +[42, 42, 42, 42, 42, 42, 42] +``` + +* برای رسیدن به رفتار موردنظر شما می‌تونید متغیر حلقه رو به عنوان یک متغیر اسم‌دار به تابع بدید. **چرا در این صورت کار می‌کنه؟** چون اینجوری یک متغیر در دامنه خود تابع تعریف میشه. تابع دیگه دنبال مقدار `x` در دامنه اطراف (سراسری) نمی‌گرده ولی یک متغیر محلی برای ذخیره کردن مقدار `x` در اون لحظه می‌سازه. + +```py +funcs = [] +for x in range(7): + def some_func(x=x): + return x + funcs.append(some_func) +``` + +**خروجی:** + +```py +>>> funcs_results = [func() for func in funcs] +>>> funcs_results +[0, 1, 2, 3, 4, 5, 6] +``` + +دیگه از متغیر `x` در دامنه سراسری استفاده نمی‌کنه: + +```py +>>> inspect.getclosurevars(funcs[0]) +ClosureVars(nonlocals={}, globals={}, builtins={}, unbound=set()) +``` + +--- + + +### ▶ اول مرغ بوده یا تخم مرغ؟ * + +1\. +```py +>>> isinstance(3, int) +True +>>> isinstance(type, object) +True +>>> isinstance(object, type) +True +``` + +پس کدوم کلاس پایه "نهایی" هست؟ راستی سردرگمی بیشتری هم تو راهه. + +2\. + +```py +>>> class A: pass +>>> isinstance(A, A) +False +>>> isinstance(type, type) +True +>>> isinstance(object, object) +True +``` + +3\. + +```py +>>> issubclass(int, object) +True +>>> issubclass(type, object) +True +>>> issubclass(object, type) +False +``` + + +#### 💡 توضیحات + +- در پایتون، `type` یک [متاکلاس](https://realpython.com/python-metaclasses/) است. +- در پایتون **همه چیز** یک `object` است، که کلاس‌ها و همچنین نمونه‌هاشون (یا همان instance های کلاس‌ها) هم شامل این موضوع میشن. +- کلاس `type` یک متاکلاسه برای کلاس `object` و همه کلاس‌ها (همچنین کلاس `type`) به صورت مستقیم یا غیرمستقیم از کلاس `object` ارث بری کرده است. +- هیچ کلاس پایه واقعی بین کلاس‌های `object` و `type` وجود نداره. سردرگمی که در قطعه‌کدهای بالا به وجود اومده، به خاطر اینه که ما به این روابط (یعنی `issubclass` و `isinstance`) از دیدگاه کلاس‌های پایتون فکر می‌کنیم. رابطه بین `object` و `type` رو در پایتون خالص نمیشه بازتولید کرد. برای اینکه دقیق‌تر باشیم، رابطه‌های زیر در پایتون خالص نمی‌تونند بازتولید بشن. + + کلاس A یک نمونه از کلاس B، و کلاس B یک نمونه از کلاس A باشه. + + کلاس A یک نمونه از خودش باشه. +- +- این روابط بین `object` و `type` (که هردو نمونه یکدیگه و همچنین خودشون باشند) به خاطر "تقلب" در مرحله پیاده‌سازی، وجود دارند. + +--- + + +### ▶ روابط بین زیرمجموعه کلاس‌ها + +**خروجی:** +```py +>>> from collections.abc import Hashable +>>> issubclass(list, object) +True +>>> issubclass(object, Hashable) +True +>>> issubclass(list, Hashable) +False +``` + +ما انتظار داشتیم که روابط بین زیرکلاس‌ها، انتقالی باشند، درسته؟ (یعنی اگه `A` زیرکلاس `B` باشه و `B` هم زیرکلاس `C` باشه، کلس `A` __باید__ زیرکلاس `C` باشه) + +#### 💡 توضیحات: + +* روابط بین زیرکلاس‌ها در پایتون لزوما انتقالی نیستند. همه مجازند که تابع `__subclasscheck__` دلخواه خودشون رو در یک متاکلاس تعریف کنند. +* وقتی عبارت `issubclass(cls, Hashable)` اجرا میشه، برنامه دنبال یک تابع "غیر نادرست" (یا non-Falsy) در `cls` یا هرچیزی که ازش ارث‌بری می‌کنه، می‌گرده. +* از اونجایی که `object` قابل هش شدنه، ولی `list` این‌طور نیست، رابطه انتقالی شکسته میشه. +* توضیحات با جزئیات بیشتر [اینجا](https://www.naftaliharris.com/blog/python-subclass-intransitivity/) پیدا میشه. + +--- From c956abd9b3db5105d29a35733306e38398f3f981 Mon Sep 17 00:00:00 2001 From: Mohamad Reza Date: Tue, 18 Mar 2025 16:03:14 +0330 Subject: [PATCH 12/33] replace offensive word in farsi translation --- translations/fa-farsi/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/translations/fa-farsi/README.md b/translations/fa-farsi/README.md index 43a5179..fa53fdb 100644 --- a/translations/fa-farsi/README.md +++ b/translations/fa-farsi/README.md @@ -20,7 +20,7 @@ این یه پروژه باحاله که سعی داریم توش توضیح بدیم که پشت پرده یه سری قطعه‌کدهای غیرشهودی و فابلیت‌های کمتر شناخته شده پایتون چه خبره. -درحالی که بعضی از مثال‌هایی که قراره تو این سند ببینید واقعا پشم‌ریزون نیستند ولی بخش‌های جالبی از پایتون رو ظاهر می‌کنند که +درحالی که بعضی از مثال‌هایی که قراره تو این سند ببینید واقعا عجیب و غریب نیستند ولی بخش‌های جالبی از پایتون رو ظاهر می‌کنند که ممکنه شما از وجودشون بی‌خبر باشید. به نظرم این شیوه جالبیه برای یادگیری جزئیات داخلی یه زبان برنامه نویسی و باور دارم که برای شما هم جالب خواهد بود. From 9330752306e48a497e1a4153557dffefd5df1f81 Mon Sep 17 00:00:00 2001 From: Leo Alavi Date: Fri, 28 Mar 2025 14:34:10 +0100 Subject: [PATCH 13/33] Translate slippery Slopes section --- translations/fa-farsi/README.md | 408 ++++++++++++++++---------------- 1 file changed, 203 insertions(+), 205 deletions(-) diff --git a/translations/fa-farsi/README.md b/translations/fa-farsi/README.md index fa53fdb..6443cd8 100644 --- a/translations/fa-farsi/README.md +++ b/translations/fa-farsi/README.md @@ -105,65 +105,65 @@ - [💡 Explanation:](#-explanation-28) - [▶ Exceeds the limit for integer string conversion](#-exceeds-the-limit-for-integer-string-conversion) - [💡 Explanation:](#-explanation-29) - - [Section: Slippery Slopes](#section-slippery-slopes) - - [▶ Modifying a dictionary while iterating over it](#-modifying-a-dictionary-while-iterating-over-it) + - [‫ بخش: شیب‌های لغزنده](#-بخش-شیبهای-لغزنده) + - [▶ ‫ تغییر یک دیکشنری هنگام پیمایش روی آن](#--تغییر-یک-دیکشنری-هنگام-پیمایش-روی-آن) + - [‫ 💡 توضیح:](#--توضیح) + - [▶ عملیات سرسختانه‌ی `del`](#-عملیات-سرسختانهی-del) + - [‫ 💡 توضیح:](#--توضیح-1) + - [▶ ‫ متغیری که از حوزه خارج است](#--متغیری-که-از-حوزه-خارج-است) + - [‫ 💡 توضیح:](#--توضیح-2) + - [▶ ‫ حذف المان‌های لیست در حین پیمایش](#--حذف-المانهای-لیست-در-حین-پیمایش) - [💡 Explanation:](#-explanation-30) - - [▶ Stubborn `del` operation](#-stubborn-del-operation) - - [💡 Explanation:](#-explanation-31) - - [▶ The out of scope variable](#-the-out-of-scope-variable) - - [💡 Explanation:](#-explanation-32) - - [▶ Deleting a list item while iterating](#-deleting-a-list-item-while-iterating) - - [💡 Explanation:](#-explanation-33) - - [▶ Lossy zip of iterators \*](#-lossy-zip-of-iterators-) - - [💡 Explanation:](#-explanation-34) - - [▶ Loop variables leaking out!](#-loop-variables-leaking-out) - - [💡 Explanation:](#-explanation-35) - - [▶ Beware of default mutable arguments!](#-beware-of-default-mutable-arguments) - - [💡 Explanation:](#-explanation-36) - - [▶ Catching the Exceptions](#-catching-the-exceptions) - - [💡 Explanation](#-explanation-37) - - [▶ Same operands, different story!](#-same-operands-different-story) - - [💡 Explanation:](#-explanation-38) - - [▶ Name resolution ignoring class scope](#-name-resolution-ignoring-class-scope) - - [💡 Explanation](#-explanation-39) - - [▶ Rounding like a banker \*](#-rounding-like-a-banker-) - - [💡 Explanation:](#-explanation-40) - - [▶ Needles in a Haystack \*](#-needles-in-a-haystack-) - - [💡 Explanation:](#-explanation-41) - - [▶ Splitsies \*](#-splitsies-) - - [💡 Explanation:](#-explanation-42) - - [▶ Wild imports \*](#-wild-imports-) - - [💡 Explanation:](#-explanation-43) - - [▶ All sorted? \*](#-all-sorted-) - - [💡 Explanation:](#-explanation-44) - - [▶ Midnight time doesn't exist?](#-midnight-time-doesnt-exist) - - [💡 Explanation:](#-explanation-45) + - [▶ ‫ زیپِ دارای اتلاف برای پیمایشگرها \*](#--زیپِ-دارای-اتلاف-برای-پیمایشگرها-) + - [‫ 💡 توضیحات:](#--توضیحات) + - [▶ ‫ نشت کردن متغیرهای حلقه!](#--نشت-کردن-متغیرهای-حلقه) + - [💡 ‫ توضیحات:](#--توضیحات-1) + - [▶ ‫ مراقب آرگومان‌های تغییرپذیر پیش‌فرض باشید!](#--مراقب-آرگومانهای-تغییرپذیر-پیشفرض-باشید) + - [💡 ‫ توضیحات:](#--توضیحات-2) + - [▶ ‫ گرفتن استثناها (Exceptions)](#--گرفتن-استثناها-exceptions) + - [💡 ‫ توضیحات](#--توضیحات-3) + - [▶ ‫ عملوندهای یکسان، داستانی متفاوت!](#--عملوندهای-یکسان-داستانی-متفاوت) + - [💡 ‫ توضیحات:](#--توضیحات-4) + - [▶ ‫ تفکیک نام‌ها با نادیده گرفتن حوزه‌ی کلاس](#--تفکیک-نامها-با-نادیده-گرفتن-حوزهی-کلاس) + - [💡 ‫ توضیحات](#--توضیحات-5) + - [▶ ‫ گرد کردن به روش بانکدار \*](#--گرد-کردن-به-روش-بانکدار-) + - [💡 ‫ توضیحات:](#--توضیحات-6) + - [▶ ‫ سوزن‌هایی در انبار کاه \*](#--سوزنهایی-در-انبار-کاه-) + - [💡 ‫ توضیحات:](#--توضیحات-7) + - [▶ ‫ تقسیم‌ها \*](#--تقسیمها-) + - [💡 ‫ توضیحات:](#--توضیحات-8) + - [▶ واردسازی‌های عمومی \*](#-واردسازیهای-عمومی-) + - [💡 ‫ توضیحات:](#--توضیحات-9) + - [▶ ‫ همه چیز مرتب شده؟ \*](#--همه-چیز-مرتب-شده-) + - [💡 ‫ توضیحات:](#--توضیحات-10) + - [▶ ‫ زمان نیمه‌شب وجود ندارد؟](#--زمان-نیمهشب-وجود-ندارد) + - [💡 ‫ توضیحات:](#--توضیحات-11) - [‫ بخش: گنجینه‌های پنهان!](#-بخش-گنجینههای-پنهان) - [▶ ‫ خب پایتون، می‌توانی کاری کنی پرواز کنم؟](#--خب-پایتون-میتوانی-کاری-کنی-پرواز-کنم) - - [‫ 💡 توضیح:](#--توضیح) - - [▶ ‫ `goto`، ولی چرا؟](#--goto-ولی-چرا) - - [‫ 💡 توضیح:](#--توضیح-1) - - [▶ ‫ خودتان را آماده کنید!](#--خودتان-را-آماده-کنید) - - [‫ 💡 توضیح:](#--توضیح-2) - - [▶ ‫ بیایید با «عمو زبان مهربان برای همیشه» آشنا شویم](#--بیایید-با-عمو-زبان-مهربان-برای-همیشه-آشنا-شویم) - [‫ 💡 توضیح:](#--توضیح-3) - - [▶ ‫ حتی پایتون هم می‌داند که عشق پیچیده است](#--حتی-پایتون-هم-میداند-که-عشق-پیچیده-است) + - [▶ ‫ `goto`، ولی چرا؟](#--goto-ولی-چرا) - [‫ 💡 توضیح:](#--توضیح-4) - - [▶ ‫ بله، این واقعاً وجود دارد!](#--بله-این-واقعاً-وجود-دارد) + - [▶ ‫ خودتان را آماده کنید!](#--خودتان-را-آماده-کنید) - [‫ 💡 توضیح:](#--توضیح-5) + - [▶ ‫ بیایید با «عمو زبان مهربان برای همیشه» آشنا شویم](#--بیایید-با-عمو-زبان-مهربان-برای-همیشه-آشنا-شویم) + - [‫ 💡 توضیح:](#--توضیح-6) + - [▶ ‫ حتی پایتون هم می‌داند که عشق پیچیده است](#--حتی-پایتون-هم-میداند-که-عشق-پیچیده-است) + - [‫ 💡 توضیح:](#--توضیح-7) + - [▶ ‫ بله، این واقعاً وجود دارد!](#--بله-این-واقعاً-وجود-دارد) + - [‫ 💡 توضیح:](#--توضیح-8) - [▶ Ellipsis \*](#-ellipsis-) - [‫ 💡توضیح](#-توضیح) - [▶ ‫ بی‌نهایت (`Inpinity`)](#--بینهایت-inpinity) - - [‫ 💡 توضیح:](#--توضیح-6) + - [‫ 💡 توضیح:](#--توضیح-9) - [▶ ‫ بیایید خرابکاری کنیم](#--بیایید-خرابکاری-کنیم) - - [‫ 💡 توضیح:](#--توضیح-7) + - [‫ 💡 توضیح:](#--توضیح-10) - [‫ بخش: ظاهرها فریبنده‌اند!](#-بخش-ظاهرها-فریبندهاند) - [▶ ‫ خطوط را رد می‌کند؟](#--خطوط-را-رد-میکند) - - [‫ 💡 توضیح](#--توضیح-8) + - [‫ 💡 توضیح](#--توضیح-11) - [▶ ‫ تله‌پورت کردن](#--تلهپورت-کردن) - - [‫ 💡 توضیح:](#--توضیح-9) + - [‫ 💡 توضیح:](#--توضیح-12) - [▶ ‫ خب، یک جای کار مشکوک است...](#--خب-یک-جای-کار-مشکوک-است) - - [‫ 💡 توضیح](#--توضیح-10) + - [‫ 💡 توضیح](#--توضیح-13) - [بخش: متفرقه](#بخش-متفرقه) - [‫ ▶ `+=` سریع‌تر است](#---سریعتر-است) - [‫ 💡 توضیح:](#---توضیح) @@ -2112,9 +2112,9 @@ Fortunately, you can increase the limit for the allowed number of digits when yo --- -## Section: Slippery Slopes +## ‫ بخش: شیب‌های لغزنده -### ▶ Modifying a dictionary while iterating over it +### ▶ ‫ تغییر یک دیکشنری هنگام پیمایش روی آن ```py x = {0: None} @@ -2125,7 +2125,7 @@ for i in x: print(i) ``` -**Output (Python 2.7- Python 3.5):** +‫ **خروجی (پایتون 2.7تا پایتون 3.5):** ``` 0 @@ -2138,19 +2138,19 @@ for i in x: 7 ``` -Yes, it runs for exactly **eight** times and stops. +‫ بله، دقیقاً **هشت** مرتبه اجرا می‌شود و سپس متوقف می‌شود. -#### 💡 Explanation: +#### ‫ 💡 توضیح: -* Iteration over a dictionary that you edit at the same time is not supported. -* It runs eight times because that's the point at which the dictionary resizes to hold more keys (we have eight deletion entries, so a resize is needed). This is actually an implementation detail. -* How deleted keys are handled and when the resize occurs might be different for different Python implementations. -* So for Python versions other than Python 2.7 - Python 3.5, the count might be different from 8 (but whatever the count is, it's going to be the same every time you run it). You can find some discussion around this [here](https://github.com/satwikkansal/wtfpython/issues/53) or in [this](https://stackoverflow.com/questions/44763802/bug-in-python-dict) StackOverflow thread. -* Python 3.7.6 onwards, you'll see `RuntimeError: dictionary keys changed during iteration` exception if you try to do this. +- ‫ پیمایش روی یک دیکشنری در حالی که همزمان آن را ویرایش می‌کنید پشتیبانی نمی‌شود. +- ‫ هشت بار اجرا می‌شود چون در آن لحظه دیکشنری برای نگهداری کلیدهای بیشتر تغییر اندازه می‌دهد (ما هشت ورودی حذف داریم، بنابراین تغییر اندازه لازم است). این در واقع یک جزئیات پیاده‌سازی است. +- ‫ اینکه کلیدهای حذف‌شده چگونه مدیریت می‌شوند و چه زمانی تغییر اندازه اتفاق می‌افتد ممکن است در پیاده‌سازی‌های مختلف پایتون متفاوت باشد. +- ‫ بنابراین در نسخه‌های دیگر پایتون (به جز Python 2.7 - Python 3.5)، تعداد ممکن است متفاوت از ۸ باشد (اما هر چه که باشد، در هر بار اجرا یکسان خواهد بود). می‌توانید برخی مباحث پیرامون این موضوع را [اینجا](https://github.com/satwikkansal/wtfpython/issues/53) یا در این [رشته‌ی StackOverflow](https://stackoverflow.com/questions/44763802/bug-in-python-dict) مشاهده کنید. +- ‫ از نسخه‌ی Python 3.7.6 به بعد، در صورت تلاش برای انجام این کار، خطای `RuntimeError: dictionary keys changed during iteration` را دریافت خواهید کرد. --- -### ▶ Stubborn `del` operation +### ▶ عملیات سرسختانه‌ی `del` @@ -2160,42 +2160,42 @@ class SomeClass: print("Deleted!") ``` -**Output:** +‫ **خروجی:** 1\. ```py >>> x = SomeClass() >>> y = x ->>> del x # this should print "Deleted!" +>>> del x # باید این عبارت را چاپ کند "Deleted!" >>> del y Deleted! ``` -Phew, deleted at last. You might have guessed what saved `__del__` from being called in our first attempt to delete `x`. Let's add more twists to the example. +‫ «خُب، بالاخره حذف شد.» احتمالاً حدس زده‌اید چه چیزی جلوی فراخوانی `__del__` را در اولین تلاشی که برای حذف `x` داشتیم، گرفته بود. بیایید مثال را پیچیده‌تر کنیم. 2\. ```py >>> x = SomeClass() >>> y = x >>> del x ->>> y # check if y exists +>>> y # بررسی وجود y <__main__.SomeClass instance at 0x7f98a1a67fc8> ->>> del y # Like previously, this should print "Deleted!" ->>> globals() # oh, it didn't. Let's check all our global variables and confirm +>>> del y # مثل قبل، باید این عبارت را چاپ کند "Deleted!" +>>> globals() # اوه، چاپ نکرد. بیایید مقادیر گلوبال را بررسی کنیم. Deleted! {'__builtins__': , 'SomeClass': , '__package__': None, '__name__': '__main__', '__doc__': None} ``` -Okay, now it's deleted :confused: +‫ «باشه، حالا حذف شد» :confused: -#### 💡 Explanation: -+ `del x` doesn’t directly call `x.__del__()`. -+ When `del x` is encountered, Python deletes the name `x` from current scope and decrements by 1 the reference count of the object `x` referenced. `__del__()` is called only when the object's reference count reaches zero. -+ In the second output snippet, `__del__()` was not called because the previous statement (`>>> y`) in the interactive interpreter created another reference to the same object (specifically, the `_` magic variable which references the result value of the last non `None` expression on the REPL), thus preventing the reference count from reaching zero when `del y` was encountered. -+ Calling `globals` (or really, executing anything that will have a non `None` result) caused `_` to reference the new result, dropping the existing reference. Now the reference count reached 0 and we can see "Deleted!" being printed (finally!). +#### ‫ 💡 توضیح: +- ‫ عبارت `del x` مستقیماً باعث فراخوانی `x.__del__()` نمی‌شود. +- ‫ وقتی به دستور `del x` می‌رسیم، پایتون نام `x` را از حوزه‌ی فعلی حذف کرده و شمارنده‌ی مراجع شیٔ‌ای که `x` به آن اشاره می‌کرد را یک واحد کاهش می‌دهد. فقط وقتی شمارنده‌ی مراجع شیٔ به صفر برسد، تابع `__del__()` فراخوانی می‌شود. +- ‫ در خروجی دوم، متد `__del__()` فراخوانی نشد چون دستور قبلی (`>>> y`) در مفسر تعاملی یک ارجاع دیگر به شیٔ ایجاد کرده بود (به صورت خاص، متغیر جادویی `_` به مقدار آخرین عبارت غیر `None` در REPL اشاره می‌کند). بنابراین مانع از رسیدن شمارنده‌ی مراجع به صفر در هنگام اجرای `del y` شد. +- ‫ فراخوانی `globals` (یا هر چیزی که نتیجه‌اش `None` نباشد) باعث می‌شود که `_` به نتیجه‌ی جدید اشاره کند و ارجاع قبلی از بین برود. حالا شمارنده‌ی مراجع به صفر می‌رسد و عبارت «Deleted!» (حذف شد!) نمایش داده می‌شود. --- -### ▶ The out of scope variable +### ▶ ‫ متغیری که از حوزه خارج است 1\. @@ -2225,7 +2225,7 @@ def another_closure_func(): return another_inner_func() ``` -**Output:** +‫ **خروجی:** ```py >>> some_func() 1 @@ -2238,9 +2238,9 @@ UnboundLocalError: local variable 'a' referenced before assignment UnboundLocalError: local variable 'a' referenced before assignment ``` -#### 💡 Explanation: -* When you make an assignment to a variable in scope, it becomes local to that scope. So `a` becomes local to the scope of `another_func`, but it has not been initialized previously in the same scope, which throws an error. -* To modify the outer scope variable `a` in `another_func`, we have to use the `global` keyword. +#### ‫ 💡 توضیح: +* ‫ وقتی در محدوده (Scope) یک تابع به متغیری مقداردهی می‌کنید، آن متغیر در همان حوزه محلی تعریف می‌شود. بنابراین `a` در تابع `another_func` تبدیل به متغیر محلی می‌شود، اما پیش‌تر در همان حوزه مقداردهی نشده است، و این باعث خطا می‌شود. +* ‫ برای تغییر متغیر سراسری `a` در تابع `another_func`، باید از کلیدواژه‌ی `global` استفاده کنیم. ```py def another_func() global a @@ -2248,13 +2248,13 @@ UnboundLocalError: local variable 'a' referenced before assignment return a ``` - **Output:** + **خروجی:** ```py >>> another_func() 2 ``` -* In `another_closure_func`, `a` becomes local to the scope of `another_inner_func`, but it has not been initialized previously in the same scope, which is why it throws an error. -* To modify the outer scope variable `a` in `another_inner_func`, use the `nonlocal` keyword. The nonlocal statement is used to refer to variables defined in the nearest outer (excluding the global) scope. +* ‫ در تابع `another_closure_func`، متغیر `a` در حوزه‌ی `another_inner_func` محلی می‌شود ولی پیش‌تر در آن حوزه مقداردهی نشده است. به همین دلیل خطا می‌دهد. +* ‫ برای تغییر متغیر حوزه‌ی بیرونی `a` در `another_inner_func`، باید از کلیدواژه‌ی `nonlocal` استفاده کنیم. دستور `nonlocal` به مفسر می‌گوید که متغیر را در نزدیک‌ترین حوزه‌ی بیرونی (به‌جز حوزه‌ی global) جستجو کند. ```py def another_func(): a = 1 @@ -2265,17 +2265,17 @@ UnboundLocalError: local variable 'a' referenced before assignment return another_inner_func() ``` - **Output:** + ‫ **خروجی:** ```py >>> another_func() 2 ``` -* The keywords `global` and `nonlocal` tell the python interpreter to not declare new variables and look them up in the corresponding outer scopes. -* Read [this](https://sebastianraschka.com/Articles/2014_python_scope_and_namespaces.html) short but an awesome guide to learn more about how namespaces and scope resolution works in Python. +* ‫ کلیدواژه‌های `global` و `nonlocal` به مفسر پایتون می‌گویند که متغیر جدیدی را تعریف نکند و به جای آن در حوزه‌های بیرونی (سراسری یا میانجی) آن را بیابد. +* ‫ برای مطالعه‌ی بیشتر در مورد نحوه‌ی کار فضای نام‌ها و مکانیزم تعیین حوزه‌ها در پایتون، می‌توانید این [مقاله کوتاه ولی عالی](https://sebastianraschka.com/Articles/2014_python_scope_and_namespaces.html) را بخوانید. --- -### ▶ Deleting a list item while iterating +### ▶ ‫ حذف المان‌های لیست در حین پیمایش ```py list_1 = [1, 2, 3, 4] @@ -2296,7 +2296,7 @@ for idx, item in enumerate(list_4): list_4.pop(idx) ``` -**Output:** +‫**خروجی:** ```py >>> list_1 [1, 2, 3, 4] @@ -2308,35 +2308,35 @@ for idx, item in enumerate(list_4): [2, 4] ``` -Can you guess why the output is `[2, 4]`? +‫ می‌توانید حدس بزنید چرا خروجی `[2, 4]` است؟ #### 💡 Explanation: -* It's never a good idea to change the object you're iterating over. The correct way to do so is to iterate over a copy of the object instead, and `list_3[:]` does just that. +* ‫ هیچ‌وقت ایده‌ی خوبی نیست که شیئی را که روی آن پیمایش می‌کنید تغییر دهید. روش درست این است که روی یک کپی از آن شیء پیمایش کنید؛ در این‌جا `list_3[:]` دقیقاً همین کار را می‌کند. ```py >>> some_list = [1, 2, 3, 4] >>> id(some_list) 139798789457608 - >>> id(some_list[:]) # Notice that python creates new object for sliced list. + >>> id(some_list[:]) # دقت کنید که پایتون برای اسلایس کردن، یک شی جدید میسازد 139798779601192 ``` -**Difference between `del`, `remove`, and `pop`:** -* `del var_name` just removes the binding of the `var_name` from the local or global namespace (That's why the `list_1` is unaffected). -* `remove` removes the first matching value, not a specific index, raises `ValueError` if the value is not found. -* `pop` removes the element at a specific index and returns it, raises `IndexError` if an invalid index is specified. +‫ **تفاوت بین `del`، `remove` و `pop`:** +* ‫ `del var_name` فقط اتصال `var_name` را از فضای نام محلی یا سراسری حذف می‌کند (به همین دلیل است که `list_1` تحت تأثیر قرار نمی‌گیرد). +* ‫ متد `remove` اولین مقدار مطابق را حذف می‌کند، نه یک اندیس خاص را؛ اگر مقدار مورد نظر پیدا نشود، خطای `ValueError` ایجاد می‌شود. +* ‫ متد `pop` عنصری را در یک اندیس مشخص حذف کرده و آن را برمی‌گرداند؛ اگر اندیس نامعتبری مشخص شود، خطای `IndexError` ایجاد می‌شود. -**Why the output is `[2, 4]`?** -- The list iteration is done index by index, and when we remove `1` from `list_2` or `list_4`, the contents of the lists are now `[2, 3, 4]`. The remaining elements are shifted down, i.e., `2` is at index 0, and `3` is at index 1. Since the next iteration is going to look at index 1 (which is the `3`), the `2` gets skipped entirely. A similar thing will happen with every alternate element in the list sequence. +‫ **چرا خروجی `[2, 4]` است؟** +- ‫ پیمایش لیست به صورت اندیس به اندیس انجام می‌شود، و هنگامی که عدد `1` را از `list_2` یا `list_4` حذف می‌کنیم، محتوای لیست به `[2, 3, 4]` تغییر می‌کند. در این حالت عناصر باقی‌مانده به سمت چپ جابه‌جا شده و جایگاهشان تغییر می‌کند؛ یعنی عدد `2` در اندیس 0 و عدد `3` در اندیس 1 قرار می‌گیرد. از آنجا که در مرحله بعدی حلقه به سراغ اندیس 1 می‌رود (که اکنون مقدار آن `3` است)، عدد `2` به طور کامل نادیده گرفته می‌شود. این اتفاق مشابه برای هر عنصر یک‌درمیان در طول پیمایش لیست رخ خواهد داد. -* Refer to this StackOverflow [thread](https://stackoverflow.com/questions/45946228/what-happens-when-you-try-to-delete-a-list-element-while-iterating-over-it) explaining the example -* See also this nice StackOverflow [thread](https://stackoverflow.com/questions/45877614/how-to-change-all-the-dictionary-keys-in-a-for-loop-with-d-items) for a similar example related to dictionaries in Python. +* ‫ برای توضیح بیشتر این مثال، این [تاپیک StackOverflow](https://stackoverflow.com/questions/45946228/what-happens-when-you-try-to-delete-a-list-element-while-iterating-over-it) را ببینید. +* ‫ همچنین برای نمونه مشابهی مربوط به دیکشنری‌ها در پایتون، این [تاپیک مفید StackOverflow](https://stackoverflow.com/questions/45877614/how-to-change-all-the-dictionary-keys-in-a-for-loop-with-d-items) را ببینید. --- -### ▶ Lossy zip of iterators * +### ▶ ‫ زیپِ دارای اتلاف برای پیمایشگرها * ```py @@ -2353,11 +2353,11 @@ Can you guess why the output is `[2, 4]`? >>> list(zip(numbers_iter, remaining)) [(4, 3), (5, 4), (6, 5)] ``` -Where did element `3` go from the `numbers` list? +‫ عنصر `3` از لیست `numbers` چه شد؟ -#### 💡 Explanation: +#### ‫ 💡 توضیحات: -- From Python [docs](https://docs.python.org/3.3/library/functions.html#zip), here's an approximate implementation of zip function, +- ‫ بر اساس [مستندات](https://docs.python.org/3.3/library/functions.html#zip) پایتون، پیاده‌سازی تقریبی تابع `zip` به شکل زیر است: ```py def zip(*iterables): sentinel = object() @@ -2370,9 +2370,9 @@ Where did element `3` go from the `numbers` list? result.append(elem) yield tuple(result) ``` -- So the function takes in arbitrary number of iterable objects, adds each of their items to the `result` list by calling the `next` function on them, and stops whenever any of the iterable is exhausted. -- The caveat here is when any iterable is exhausted, the existing elements in the `result` list are discarded. That's what happened with `3` in the `numbers_iter`. -- The correct way to do the above using `zip` would be, +- ‫ بنابراین این تابع تعداد دلخواهی از اشیای قابل پیمایش (*iterable*) را دریافت می‌کند، و با فراخوانی تابع `next` روی آن‌ها، هر یک از عناصرشان را به لیست `result` اضافه می‌کند. این فرایند زمانی متوقف می‌شود که اولین پیمایشگر به انتها برسد. +- ‫ نکته مهم اینجاست که هر زمان یکی از پیمایشگرها به پایان برسد، عناصر موجود در لیست `result` نیز دور ریخته می‌شوند. این دقیقاً همان اتفاقی است که برای عدد `3` در `numbers_iter` رخ داد. +- ‫ روش صحیح برای انجام عملیات بالا با استفاده از تابع `zip` چنین است: ```py >>> numbers = list(range(7)) >>> numbers_iter = iter(numbers) @@ -2381,11 +2381,11 @@ Where did element `3` go from the `numbers` list? >>> list(zip(remaining, numbers_iter)) [(3, 3), (4, 4), (5, 5), (6, 6)] ``` - The first argument of zip should be the one with fewest elements. + ‫ اولین آرگومانِ تابع `zip` باید پیمایشگری باشد که کمترین تعداد عنصر را دارد. --- -### ▶ Loop variables leaking out! +### ▶ ‫ نشت کردن متغیرهای حلقه! 1\. ```py @@ -2395,17 +2395,17 @@ for x in range(7): print(x, ': x in global') ``` -**Output:** +‫ **خروجی:** ```py 6 : for x inside loop 6 : x in global ``` -But `x` was never defined outside the scope of for loop... +‫ اما متغیر `x` هرگز خارج از محدوده (scope) حلقه `for` تعریف نشده بود... 2\. ```py -# This time let's initialize x first +# این دفعه، مقدار ایکس را در ابتدا مقداردهی اولیه میکنیم. x = -1 for x in range(7): if x == 6: @@ -2413,7 +2413,7 @@ for x in range(7): print(x, ': x in global') ``` -**Output:** +‫ **خروجی:** ```py 6 : for x inside loop 6 : x in global @@ -2421,7 +2421,7 @@ print(x, ': x in global') 3\. -**Output (Python 2.x):** +‫ **خروجی (Python 2.x):** ```py >>> x = 1 >>> print([x for x in range(5)]) @@ -2430,7 +2430,7 @@ print(x, ': x in global') 4 ``` -**Output (Python 3.x):** +‫ **خروجی (Python 3.x):** ```py >>> x = 1 >>> print([x for x in range(5)]) @@ -2439,17 +2439,17 @@ print(x, ': x in global') 1 ``` -#### 💡 Explanation: +#### 💡 ‫ توضیحات: -- In Python, for-loops use the scope they exist in and leave their defined loop-variable behind. This also applies if we explicitly defined the for-loop variable in the global namespace before. In this case, it will rebind the existing variable. +- ‫ در پایتون، حلقه‌های `for` از حوزه (*scope*) فعلی که در آن قرار دارند استفاده می‌کنند و متغیرهای تعریف‌شده در حلقه حتی بعد از اتمام حلقه نیز باقی می‌مانند. این قاعده حتی در مواردی که متغیر حلقه پیش‌تر در فضای نام سراسری (*global namespace*) تعریف شده باشد نیز صدق می‌کند؛ در چنین حالتی، متغیر موجود مجدداً به مقدار جدید متصل می‌شود. -- The differences in the output of Python 2.x and Python 3.x interpreters for list comprehension example can be explained by following change documented in [What’s New In Python 3.0](https://docs.python.org/3/whatsnew/3.0.html) changelog: +- ‫ تفاوت‌های موجود در خروجی مفسرهای Python 2.x و Python 3.x در مثال مربوط به «لیست‌های ادراکی» (*list comprehension*) به دلیل تغییراتی است که در مستند [«تغییرات جدید در Python 3.0»](https://docs.python.org/3/whatsnew/3.0.html) آمده است: - > "List comprehensions no longer support the syntactic form `[... for var in item1, item2, ...]`. Use `[... for var in (item1, item2, ...)]` instead. Also, note that list comprehensions have different semantics: they are closer to syntactic sugar for a generator expression inside a `list()` constructor, and in particular, the loop control variables are no longer leaked into the surrounding scope." + > ‫ «لیست‌های ادراکی دیگر فرم نحوی `[... for var in item1, item2, ...]` را پشتیبانی نمی‌کنند و به جای آن باید از `[... for var in (item1, item2, ...)]` استفاده شود. همچنین توجه داشته باشید که لیست‌های ادراکی در Python 3.x معنای متفاوتی دارند: آن‌ها از لحاظ معنایی به بیان ساده‌تر، مشابه یک عبارت تولیدکننده (*generator expression*) درون تابع `list()` هستند و در نتیجه، متغیرهای کنترل حلقه دیگر به فضای نام بیرونی نشت نمی‌کنند.» --- -### ▶ Beware of default mutable arguments! +### ▶ ‫ مراقب آرگومان‌های تغییرپذیر پیش‌فرض باشید! ```py @@ -2458,7 +2458,7 @@ def some_func(default_arg=[]): return default_arg ``` -**Output:** +‫ **خروجی:** ```py >>> some_func() ['some_string'] @@ -2470,9 +2470,9 @@ def some_func(default_arg=[]): ['some_string', 'some_string', 'some_string'] ``` -#### 💡 Explanation: +#### 💡 ‫ توضیحات: -- The default mutable arguments of functions in Python aren't really initialized every time you call the function. Instead, the recently assigned value to them is used as the default value. When we explicitly passed `[]` to `some_func` as the argument, the default value of the `default_arg` variable was not used, so the function returned as expected. +- ‫ آرگومان‌های تغییرپذیر پیش‌فرض در توابع پایتون، هر بار که تابع فراخوانی می‌شود مقداردهی نمی‌شوند؛ بلکه مقداردهی آنها تنها یک بار در زمان تعریف تابع انجام می‌شود و مقدار اختصاص‌یافته به آن‌ها به عنوان مقدار پیش‌فرض برای فراخوانی‌های بعدی استفاده خواهد شد. هنگامی که به صراحت مقدار `[]` را به عنوان آرگومان به `some_func` ارسال کردیم، مقدار پیش‌فرض برای متغیر `default_arg` مورد استفاده قرار نگرفت، بنابراین تابع همان‌طور که انتظار داشتیم عمل کرد. ```py def some_func(default_arg=[]): @@ -2480,9 +2480,9 @@ def some_func(default_arg=[]): return default_arg ``` - **Output:** + ‫ **خروجی:** ```py - >>> some_func.__defaults__ #This will show the default argument values for the function + >>> some_func.__defaults__ # مقادیر پیشفرض این تابع را نمایش می دهد. ([],) >>> some_func() >>> some_func.__defaults__ @@ -2495,7 +2495,7 @@ def some_func(default_arg=[]): (['some_string', 'some_string'],) ``` -- A common practice to avoid bugs due to mutable arguments is to assign `None` as the default value and later check if any value is passed to the function corresponding to that argument. Example: +- ‫ یک روش رایج برای جلوگیری از باگ‌هایی که به دلیل آرگومان‌های تغییرپذیر رخ می‌دهند، این است که مقدار پیش‌فرض را `None` قرار داده و سپس درون تابع بررسی کنیم که آیا مقداری به آن آرگومان ارسال شده است یا خیر. مثال: ```py def some_func(default_arg=None): @@ -2507,31 +2507,31 @@ def some_func(default_arg=[]): --- -### ▶ Catching the Exceptions +### ▶ ‫ گرفتن استثناها (Exceptions) ```py some_list = [1, 2, 3] try: - # This should raise an ``IndexError`` + # ‫ این باید یک `IndexError` ایجاد کند print(some_list[4]) except IndexError, ValueError: print("Caught!") try: - # This should raise a ``ValueError`` + # ‫ این باید یک `ValueError` ایجاد کند some_list.remove(4) except IndexError, ValueError: print("Caught again!") ``` -**Output (Python 2.x):** +‫ **خروجی (Python 2.x):** ```py Caught! ValueError: list.remove(x): x not in list ``` -**Output (Python 3.x):** +‫ **خروجی (Python 3.x):** ```py File "", line 3 except IndexError, ValueError: @@ -2539,7 +2539,7 @@ ValueError: list.remove(x): x not in list SyntaxError: invalid syntax ``` -#### 💡 Explanation +#### 💡 ‫ توضیحات * 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, ```py @@ -2551,12 +2551,12 @@ SyntaxError: invalid syntax print("Caught again!") print(e) ``` - **Output (Python 2.x):** + ‫ **خروجی (Python 2.x):** ``` Caught again! list.remove(x): x not in list ``` - **Output (Python 3.x):** + ‫ **خروجی (Python 3.x):** ```py File "", line 4 except (IndexError, ValueError), e: @@ -2574,7 +2574,7 @@ SyntaxError: invalid syntax print("Caught again!") print(e) ``` - **Output:** + ‫ **خروجی:** ``` Caught again! list.remove(x): x not in list @@ -2582,7 +2582,7 @@ SyntaxError: invalid syntax --- -### ▶ Same operands, different story! +### ▶ ‫ عملوندهای یکسان، داستانی متفاوت! 1\. ```py @@ -2591,7 +2591,7 @@ b = a a = a + [5, 6, 7, 8] ``` -**Output:** +‫ **خروجی:** ```py >>> a [1, 2, 3, 4, 5, 6, 7, 8] @@ -2606,7 +2606,7 @@ b = a a += [5, 6, 7, 8] ``` -**Output:** +‫ **خروجی:** ```py >>> a [1, 2, 3, 4, 5, 6, 7, 8] @@ -2614,17 +2614,16 @@ a += [5, 6, 7, 8] [1, 2, 3, 4, 5, 6, 7, 8] ``` -#### 💡 Explanation: +#### 💡 ‫ توضیحات: +* ‫ عملگر `a += b` همیشه همانند `a = a + b` رفتار نمی‌کند. کلاس‌ها *ممکن است* عملگرهای *`op=`* را به گونه‌ای متفاوت پیاده‌سازی کنند، و لیست‌ها نیز چنین می‌کنند. -* `a += b` doesn't always behave the same way as `a = a + b`. Classes *may* implement the *`op=`* operators differently, and lists do this. +* ‫ عبارت `a = a + [5,6,7,8]` یک لیست جدید ایجاد می‌کند و مرجع `a` را به این لیست جدید اختصاص می‌دهد، بدون آنکه `b` را تغییر دهد. -* The expression `a = a + [5,6,7,8]` generates a new list and sets `a`'s reference to that new list, leaving `b` unchanged. - -* The expression `a += [5,6,7,8]` is actually mapped to an "extend" function that operates on the list such that `a` and `b` still point to the same list that has been modified in-place. +* ‫ عبارت `a += [5,6,7,8]` در واقع به تابعی معادل «extend» ترجمه می‌شود که روی لیست اصلی عمل می‌کند؛ بنابراین `a` و `b` همچنان به همان لیست اشاره می‌کنند که به‌صورت درجا (in-place) تغییر کرده است. --- -### ▶ Name resolution ignoring class scope +### ▶ ‫ تفکیک نام‌ها با نادیده گرفتن حوزه‌ی کلاس 1\. ```py @@ -2634,7 +2633,7 @@ class SomeClass: y = (x for i in range(10)) ``` -**Output:** +‫ **خروجی:** ```py >>> list(SomeClass.y)[0] 5 @@ -2648,28 +2647,28 @@ class SomeClass: y = [x for i in range(10)] ``` -**Output (Python 2.x):** +‫ **خروجی (Python 2.x):** ```py >>> SomeClass.y[0] 17 ``` -**Output (Python 3.x):** +‫ **خروجی (Python 3.x):** ```py >>> SomeClass.y[0] 5 ``` -#### 💡 Explanation -- Scopes nested inside class definition ignore names bound at the class level. -- A generator expression has its own scope. -- Starting from Python 3.X, list comprehensions also have their own scope. +#### 💡 ‫ توضیحات +- ‫ حوزه‌هایی که درون تعریف کلاس تو در تو هستند، نام‌های تعریف‌شده در سطح کلاس را نادیده می‌گیرند. +- ‫ عبارت‌های جنراتور (generator expressions) حوزه‌ی مختص به خود دارند. +- ‫ از پایتون نسخه‌ی ۳ به بعد، لیست‌های فشرده (list comprehensions) نیز حوزه‌ی مختص به خود دارند. --- -### ▶ Rounding like a banker * +### ▶ ‫ گرد کردن به روش بانکدار * -Let's implement a naive function to get the middle element of a list: +‫ بیایید یک تابع ساده برای به‌دست‌آوردن عنصر میانی یک لیست پیاده‌سازی کنیم: ```py def get_middle(some_list): mid_index = round(len(some_list) / 2) @@ -2678,22 +2677,22 @@ def get_middle(some_list): **Python 3.x:** ```py ->>> get_middle([1]) # looks good +>>> get_middle([1]) # خوب به نظر می رسد. 1 ->>> get_middle([1,2,3]) # looks good +>>> get_middle([1,2,3]) # خوب به نظر می رسد. 2 ->>> get_middle([1,2,3,4,5]) # huh? +>>> get_middle([1,2,3,4,5]) # چی? 2 ->>> len([1,2,3,4,5]) / 2 # good +>>> len([1,2,3,4,5]) / 2 # خوبه 2.5 ->>> round(len([1,2,3,4,5]) / 2) # why? +>>> round(len([1,2,3,4,5]) / 2) # چرا? 2 ``` -It seems as though Python rounded 2.5 to 2. +‫ به نظر می‌رسد که پایتون عدد ۲٫۵ را به ۲ گرد کرده است. -#### 💡 Explanation: +#### 💡 ‫ توضیحات: -- This is not a float precision error, in fact, this behavior is intentional. Since Python 3.0, `round()` uses [banker's rounding](https://en.wikipedia.org/wiki/Rounding#Rounding_half_to_even) where .5 fractions are rounded to the nearest **even** number: +- ‫ این یک خطای مربوط به دقت اعداد اعشاری نیست؛ بلکه این رفتار عمدی است. از پایتون نسخه 3.0 به بعد، تابع `round()` از [گرد کردن بانکی](https://en.wikipedia.org/wiki/Rounding#Rounding_half_to_even) استفاده می‌کند که در آن کسرهای `.5` به نزدیک‌ترین عدد **زوج** گرد می‌شوند: ```py >>> round(0.5) @@ -2702,7 +2701,7 @@ It seems as though Python rounded 2.5 to 2. 2 >>> round(2.5) 2 ->>> import numpy # numpy does the same +>>> import numpy # numpy هم همینکار را می کند. >>> numpy.round(0.5) 0.0 >>> numpy.round(1.5) @@ -2711,17 +2710,17 @@ It seems as though Python rounded 2.5 to 2. 2.0 ``` -- This is the recommended way to round .5 fractions as described in [IEEE 754](https://en.wikipedia.org/wiki/IEEE_754#Rounding_rules). However, the other way (round away from zero) is taught in school most of the time, so banker's rounding is likely not that well known. Furthermore, some of the most popular programming languages (for example: JavaScript, Java, C/C++, Ruby, Rust) do not use banker's rounding either. Therefore, this is still quite special to Python and may result in confusion when rounding fractions. -- See the [round() docs](https://docs.python.org/3/library/functions.html#round) or [this stackoverflow thread](https://stackoverflow.com/questions/10825926/python-3-x-rounding-behavior) for more information. -- Note that `get_middle([1])` only returned 1 because the index was `round(0.5) - 1 = 0 - 1 = -1`, returning the last element in the list. +- ‫ این روشِ پیشنهادی برای گرد کردن کسرهای `.5` مطابق با استاندارد [IEEE 754](https://en.wikipedia.org/wiki/IEEE_754#Rounding_rules) است. با این حال، روش دیگر (گرد کردن به سمت دور از صفر) اغلب در مدارس آموزش داده می‌شود؛ بنابراین، «گرد کردن بانکی» احتمالا چندان شناخته‌شده نیست. همچنین، برخی از رایج‌ترین زبان‌های برنامه‌نویسی (مانند جاوااسکریپت، جاوا، C/C++‎، روبی و راست) نیز از گرد کردن بانکی استفاده نمی‌کنند. به همین دلیل این موضوع همچنان مختص پایتون بوده و ممکن است باعث سردرگمی هنگام گرد کردن کسرها شود. +- ‫ برای اطلاعات بیشتر به [مستندات تابع `round()`](https://docs.python.org/3/library/functions.html#round) یا [این بحث در Stack Overflow](https://stackoverflow.com/questions/10825926/python-3-x-rounding-behavior) مراجعه کنید. +- ‫ توجه داشته باشید که `get_middle([1])` فقط به این دلیل مقدار 1 را بازگرداند که اندیس آن `round(0.5) - 1 = 0 - 1 = -1` بود و در نتیجه آخرین عنصر لیست را برمی‌گرداند. --- -### ▶ Needles in a Haystack * +### ▶ ‫ سوزن‌هایی در انبار کاه * -I haven't met even a single experience Pythonist till date who has not come across one or more of the following scenarios, +‫ من تا به امروز حتی یک برنامه‌نویس باتجربهٔ پایتون را ندیده‌ام که حداقل با یکی از سناریوهای زیر مواجه نشده باشد: 1\. @@ -2729,10 +2728,10 @@ I haven't met even a single experience Pythonist till date who has not come acro x, y = (0, 1) if True else None, None ``` -**Output:** +‫ **خروجی:** ```py ->>> x, y # expected (0, 1) +>>> x, y # چیزی که توقع داریم. (0, 1) ((0, 1), None) ``` @@ -2751,7 +2750,7 @@ t = () print(t) ``` -**Output:** +‫ **خروجی:** ```py one @@ -2779,26 +2778,26 @@ ten_words_list = [ ] ``` -**Output** +‫ **خروجی** ```py >>> len(ten_words_list) 9 ``` -4\. Not asserting strongly enough +4\. ‫ عدم تأکید کافی ```py a = "python" b = "javascript" ``` -**Output:** +‫ **خروجی:** ```py -# An assert statement with an assertion failure message. +# ‫ دستور assert همراه با پیام خطای assertion >>> assert(a == b, "Both languages are different") -# No AssertionError is raised +# ‫ هیچ AssertionError ای رخ نمی‌دهد ``` 5\. @@ -2815,7 +2814,7 @@ some_list = some_list.append(4) some_dict = some_dict.update({"key_4": 4}) ``` -**Output:** +‫ **خروجی:** ```py >>> print(some_list) @@ -2842,7 +2841,7 @@ def similar_recursive_func(a): return a ``` -**Output:** +‫ **خروجی:** ```py >>> some_recursive_func([5, 0]) @@ -2851,22 +2850,22 @@ def similar_recursive_func(a): 4 ``` -#### 💡 Explanation: +#### 💡 ‫ توضیحات: +* ‫ برای مورد ۱، عبارت صحیح برای رفتار مورد انتظار این است: +`x, y = (0, 1) if True else (None, None)` -* For 1, the correct statement for expected behavior is `x, y = (0, 1) if True else (None, None)`. +* ‫ برای مورد ۲، عبارت صحیح برای رفتار مورد انتظار این است: +‫`t = ('one',)` یا `t = 'one',` (ویرگول از قلم افتاده است). در غیر این صورت مفسر `t` را به عنوان یک `str` در نظر گرفته و به صورت کاراکتر به کاراکتر روی آن پیمایش می‌کند. -* For 2, the correct statement for expected behavior is `t = ('one',)` or `t = 'one',` (missing comma) otherwise the interpreter considers `t` to be a `str` and iterates over it character by character. - -* `()` is a special token and denotes empty `tuple`. - -* In 3, as you might have already figured out, there's a missing comma after 5th element (`"that"`) in the list. So by implicit string literal concatenation, +* ‫ علامت `()` یک توکن خاص است و نشان‌دهنده‌ی یک `tuple` خالی است. +* ‫ در مورد ۳، همان‌طور که احتمالاً متوجه شدید، بعد از عنصر پنجم (`"that"`) یک ویرگول از قلم افتاده است. بنابراین با الحاق ضمنی رشته‌ها، ```py >>> ten_words_list ['some', 'very', 'big', 'list', 'thatconsists', 'of', 'exactly', 'ten', 'words'] ``` -* No `AssertionError` was raised in 4th snippet because instead of asserting the individual expression `a == b`, we're asserting entire tuple. The following snippet will clear things up, +* ‫ در قطعه‌ی چهارم هیچ `AssertionError`ای رخ نداد؛ زیرا به جای ارزیابی عبارت تکی `a == b`، کل یک تاپل ارزیابی شده است. قطعه‌ی کد زیر این موضوع را روشن‌تر می‌کند: ```py >>> a = "python" @@ -2885,16 +2884,16 @@ def similar_recursive_func(a): AssertionError: Values are not equal ``` -* As for the fifth snippet, most methods that modify the items of sequence/mapping objects like `list.append`, `dict.update`, `list.sort`, etc. modify the objects in-place and return `None`. The rationale behind this is to improve performance by avoiding making a copy of the object if the operation can be done in-place (Referred from [here](https://docs.python.org/3/faq/design.html#why-doesn-t-list-sort-return-the-sorted-list)). +* ‫ در قطعه‌ی پنجم، بیشتر متدهایی که اشیای ترتیبی (Sequence) یا نگاشت‌ها (Mapping) را تغییر می‌دهند (مانند `list.append`، `dict.update`، `list.sort` و غیره)، شیء اصلی را به‌صورت درجا (in-place) تغییر داده و مقدار `None` برمی‌گردانند. منطق پشت این تصمیم، بهبود عملکرد با جلوگیری از کپی کردن شیء است (به این [منبع](https://docs.python.org/3/faq/design.html#why-doesn-t-list-sort-return-the-sorted-list) مراجعه کنید). -* Last one should be fairly obvious, mutable object (like `list`) can be altered in the function, and the reassignment of an immutable (`a -= 1`) is not an alteration of the value. +* ‫ قطعه‌ی آخر نیز نسبتاً واضح است؛ شیء تغییرپذیر (mutable)، مثل `list`، می‌تواند در داخل تابع تغییر کند، درحالی‌که انتساب دوباره‌ی یک شیء تغییرناپذیر (مانند `a -= 1`) باعث تغییر مقدار اصلی آن نخواهد شد. -* Being aware of these nitpicks can save you hours of debugging effort in the long run. +* ‫ آگاهی از این نکات ظریف در بلندمدت می‌تواند ساعت‌ها از زمان شما برای رفع اشکال را صرفه‌جویی کند. --- -### ▶ Splitsies * +### ▶ ‫ تقسیم‌ها * ```py >>> 'a'.split() @@ -2913,12 +2912,12 @@ def similar_recursive_func(a): 1 ``` -#### 💡 Explanation: +#### 💡 ‫ توضیحات: -- It might appear at first that the default separator for split is a single space `' '`, but as per the [docs](https://docs.python.org/3/library/stdtypes.html#str.split) - > If sep is not specified or is `None`, a different splitting algorithm is applied: runs of consecutive whitespace are regarded as a single separator, and the result will contain no empty strings at the start or end if the string has leading or trailing whitespace. Consequently, splitting an empty string or a string consisting of just whitespace with a None separator returns `[]`. - > If sep is given, consecutive delimiters are not grouped together and are deemed to delimit empty strings (for example, `'1,,2'.split(',')` returns `['1', '', '2']`). Splitting an empty string with a specified separator returns `['']`. -- Noticing how the leading and trailing whitespaces are handled in the following snippet will make things clear, +- ‫ در نگاه اول ممکن است به نظر برسد جداکننده‌ی پیش‌فرض متد `split` یک فاصله‌ی تکی (`' '`) است؛ اما مطابق با [مستندات رسمی](https://docs.python.org/3/library/stdtypes.html#str.split): + > ‫ اگر `sep` مشخص نشده یا برابر با `None` باشد، یک الگوریتم متفاوت برای جدا کردن اعمال می‌شود: رشته‌هایی از فاصله‌های متوالی به عنوان یک جداکننده‌ی واحد در نظر گرفته شده و در نتیجه، هیچ رشته‌ی خالی‌ای در ابتدا یا انتهای لیست خروجی قرار نمی‌گیرد، حتی اگر رشته‌ی اولیه دارای فاصله‌های اضافی در ابتدا یا انتها باشد. به همین دلیل، تقسیم یک رشته‌ی خالی یا رشته‌ای که فقط شامل فضای خالی است با جداکننده‌ی `None` باعث بازگشت یک لیست خالی `[]` می‌شود. + > ‫ اگر `sep` مشخص شود، جداکننده‌های متوالی در کنار هم قرار نمی‌گیرند و هر جداکننده، یک رشته‌ی خالی جدید ایجاد می‌کند. (مثلاً `'1,,2'.split(',')` مقدار `['1', '', '2']` را برمی‌گرداند.) تقسیم یک رشته‌ی خالی با یک جداکننده‌ی مشخص‌شده نیز باعث بازگشت `['']` می‌شود. +- ‫ توجه به اینکه چگونه فضای خالی در ابتدا و انتهای رشته در قطعه‌ی کد زیر مدیریت شده است، این مفهوم را روشن‌تر می‌کند: ```py >>> ' a '.split(' ') ['', 'a', ''] @@ -2930,7 +2929,7 @@ def similar_recursive_func(a): --- -### ▶ Wild imports * +### ▶ واردسازی‌های عمومی * @@ -2945,7 +2944,7 @@ def _another_weird_name_func(): ``` -**Output** +‫ **خروجی** ```py >>> from module import * @@ -2957,16 +2956,16 @@ Traceback (most recent call last): NameError: name '_another_weird_name_func' is not defined ``` -#### 💡 Explanation: +#### 💡 ‫ توضیحات: -- It is often advisable to not use wildcard imports. The first obvious reason for this is, in wildcard imports, the names with a leading underscore don't get imported. This may lead to errors during runtime. -- Had we used `from ... import a, b, c` syntax, the above `NameError` wouldn't have occurred. +- ‫ اغلب توصیه می‌شود از واردسازی عمومی (wildcard imports) استفاده نکنید. اولین دلیل واضح آن این است که در این نوع واردسازی‌ها، اسامی که با زیرخط (`_`) شروع شوند، وارد نمی‌شوند. این مسئله ممکن است در زمان اجرا به خطا منجر شود. +- ‫ اگر از ساختار `from ... import a, b, c` استفاده کنیم، خطای `NameError` فوق اتفاق نمی‌افتاد. ```py >>> from module import some_weird_name_func_, _another_weird_name_func >>> _another_weird_name_func() works! ``` -- If you really want to use wildcard imports, then you'd have to define the list `__all__` in your module that will contain a list of public objects that'll be available when we do wildcard imports. +- ‫ اگر واقعاً تمایل دارید از واردسازی عمومی استفاده کنید، لازم است فهرستی به نام `__all__` را در ماژول خود تعریف کنید که شامل نام اشیاء عمومی (public) قابل‌دسترس هنگام واردسازی عمومی است. ```py __all__ = ['_another_weird_name_func'] @@ -2976,7 +2975,7 @@ NameError: name '_another_weird_name_func' is not defined def _another_weird_name_func(): print("works!") ``` - **Output** + ‫ **خروجی** ```py >>> _another_weird_name_func() @@ -2989,7 +2988,7 @@ NameError: name '_another_weird_name_func' is not defined --- -### ▶ All sorted? * +### ▶ ‫ همه چیز مرتب شده؟ * @@ -3005,9 +3004,9 @@ True False ``` -#### 💡 Explanation: +#### 💡 ‫ توضیحات: -- The `sorted` method always returns a list, and comparing lists and tuples always returns `False` in Python. +- ‫ متد `sorted` همیشه یک لیست (`list`) برمی‌گرداند، و در پایتون مقایسه‌ی لیست‌ها و تاپل‌ها (`tuple`) همیشه مقدار `False` را برمی‌گرداند. - ```py >>> [] == tuple() @@ -3016,10 +3015,9 @@ False >>> type(x), type(sorted(x)) (tuple, list) ``` +- ‫ برخلاف متد `sorted`، متد `reversed` یک تکرارکننده (iterator) برمی‌گرداند. چرا؟ زیرا مرتب‌سازی نیاز به تغییر درجا (in-place) یا استفاده از ظرف جانبی (مانند یک لیست اضافی) دارد، در حالی که معکوس کردن می‌تواند به‌سادگی با پیمایش از اندیس آخر به اول انجام شود. -- Unlike `sorted`, the `reversed` method returns an iterator. Why? Because sorting requires the iterator to be either modified in-place or use an extra container (a list), whereas reversing can simply work by iterating from the last index to the first. - -- So during comparison `sorted(y) == sorted(y)`, the first call to `sorted()` will consume the iterator `y`, and the next call will just return an empty list. +- ‫ بنابراین در مقایسه‌ی `sorted(y) == sorted(y)`، فراخوانی اولِ `sorted()` تمام عناصرِ تکرارکننده‌ی `y` را مصرف می‌کند، و فراخوانی بعدی یک لیست خالی برمی‌گرداند. ```py >>> x = 7, 8, 9 @@ -3030,7 +3028,7 @@ False --- -### ▶ Midnight time doesn't exist? +### ▶ ‫ زمان نیمه‌شب وجود ندارد؟ ```py from datetime import datetime @@ -3048,14 +3046,14 @@ if noon_time: print("Time at noon is", noon_time) ``` -**Output (< 3.5):** +‫ **خروجی (< 3.5):** ```py ('Time at noon is', datetime.time(12, 0)) ``` The midnight time is not printed. -#### 💡 Explanation: +#### 💡 ‫ توضیحات: 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." @@ -3142,7 +3140,7 @@ SyntaxError: not a chance ### ▶ ‫ بیایید با «عمو زبان مهربان برای همیشه» آشنا شویم -**Output (Python 3.x)** +‫ **خروجی (Python 3.x)** ```py >>> from __future__ import barry_as_FLUFL >>> "Ruby" != "Python" # شکی در این نیست. @@ -3435,7 +3433,7 @@ AttributeError: 'A' object has no attribute '__variable' ### ▶ ‫ خطوط را رد می‌کند؟ -**Output:** +‫ **خروجی:** ```py >>> value = 11 >>> valuе = 32 @@ -3596,7 +3594,7 @@ def convert_list_to_string(l, iters): assert len(s) == 3*iters ``` -**Output:** +‫ **خروجی:** ‫ اجرا شده در پوسته‌ی ipython با استفاده از `%timeit` برای خوانایی بهتر نتایج. ‫ همچنین می‌توانید از ماژول `timeit` در پوسته یا اسکریپت عادی پایتون استفاده کنید؛ نمونه‌ی استفاده در زیر آمده است: From 010868a767e6779205c231895bc676e398a656a3 Mon Sep 17 00:00:00 2001 From: Leo Alavi Date: Tue, 1 Apr 2025 15:58:39 +0200 Subject: [PATCH 14/33] Add partial transations for first section --- translations/fa-farsi/README.md | 418 ++++++++++++++++---------------- 1 file changed, 205 insertions(+), 213 deletions(-) diff --git a/translations/fa-farsi/README.md b/translations/fa-farsi/README.md index 6443cd8..d913359 100644 --- a/translations/fa-farsi/README.md +++ b/translations/fa-farsi/README.md @@ -74,101 +74,101 @@ - [💡 Explanation](#-explanation-12) - [▶ Subclass relationships](#-subclass-relationships) - [💡 Explanation:](#-explanation-13) - - [▶ Methods equality and identity](#-methods-equality-and-identity) - - [💡 Explanation](#-explanation-14) - - [▶ All-true-ation \*](#-all-true-ation-) + - [▶ ‫ برابری و هویت متدها](#--برابری-و-هویت-متدها) + - [💡 ‫ توضیحات](#--توضیحات) + - [▶ ‫ آل-ترو-یشن \*](#--آل-ترو-یشن-) + - [💡 Explanation:](#-explanation-14) + - [💡 ‫ توضیح:](#--توضیح) + - [▶ ‫ رشته‌ها و بک‌اسلش‌ها](#--رشتهها-و-بکاسلشها) + - [💡 ‫ توضیح:](#--توضیح-1) + - [▶ ‫ گره نیست، نَه!](#--گره-نیست-نَه) - [💡 Explanation:](#-explanation-15) - - [💡 Explanation:](#-explanation-16) - - [▶ Strings and the backslashes](#-strings-and-the-backslashes) - - [💡 Explanation](#-explanation-17) - - [▶ not knot!](#-not-knot) - - [💡 Explanation:](#-explanation-18) - - [▶ Half triple-quoted strings](#-half-triple-quoted-strings) - - [💡 Explanation:](#-explanation-19) - - [▶ What's wrong with booleans?](#-whats-wrong-with-booleans) - - [💡 Explanation:](#-explanation-20) - - [▶ Class attributes and instance attributes](#-class-attributes-and-instance-attributes) - - [💡 Explanation:](#-explanation-21) + - [▶ رشته‌های نیمه سه‌نقل‌قولی](#-رشتههای-نیمه-سهنقلقولی) + - [💡 ‫ توضیح:](#--توضیح-2) + - [▶ ‫ مشکل بولین ها چیست؟](#--مشکل-بولین-ها-چیست) + - [💡 ‫ توضیحات:](#--توضیحات-1) + - [▶ ‫ ویژگی‌های کلاس و ویژگی‌های نمونه](#--ویژگیهای-کلاس-و-ویژگیهای-نمونه) + - [💡 ‫ توضیح:](#--توضیح-3) - [▶ yielding None](#-yielding-none) - - [💡 Explanation:](#-explanation-22) + - [💡 Explanation:](#-explanation-16) - [▶ Yielding from... return! \*](#-yielding-from-return-) - - [💡 Explanation:](#-explanation-23) - - [▶ Nan-reflexivity \*](#-nan-reflexivity-) - - [💡 Explanation:](#-explanation-24) - - [▶ Mutating the immutable!](#-mutating-the-immutable) - - [💡 Explanation:](#-explanation-25) - - [▶ The disappearing variable from outer scope](#-the-disappearing-variable-from-outer-scope) - - [💡 Explanation:](#-explanation-26) - - [▶ The mysterious key type conversion](#-the-mysterious-key-type-conversion) - - [💡 Explanation:](#-explanation-27) - - [▶ Let's see if you can guess this?](#-lets-see-if-you-can-guess-this) - - [💡 Explanation:](#-explanation-28) - - [▶ Exceeds the limit for integer string conversion](#-exceeds-the-limit-for-integer-string-conversion) - - [💡 Explanation:](#-explanation-29) + - [💡 ‫ توضیح:](#--توضیح-4) + - [▶ ‫ بازتاب‌ناپذیری \*](#--بازتابناپذیری-) + - [💡 توضیحات:](#-توضیحات-1) + - [▶ ‫ تغییر دادن اشیای تغییرناپذیر!](#--تغییر-دادن-اشیای-تغییرناپذیر) + - [💡 ‫ توضیحات:](#--توضیحات-2) + - [▶ ‫ متغیری که از اسکوپ بیرونی ناپدید می‌شود](#--متغیری-که-از-اسکوپ-بیرونی-ناپدید-میشود) + - [💡 ‫ توضیحات:](#--توضیحات-3) + - [▶ ‫ تبدیل اسرارآمیز نوع کلید](#--تبدیل-اسرارآمیز-نوع-کلید) + - [💡 ‫ توضیحات:](#--توضیحات-4) + - [▶ ‫ ببینیم می‌توانید این را حدس بزنید؟](#--ببینیم-میتوانید-این-را-حدس-بزنید) + - [💡 ‫ توضیح:](#--توضیح-5) + - [▶ ‫ از حد مجاز برای تبدیل رشته به عدد صحیح فراتر می‌رود](#--از-حد-مجاز-برای-تبدیل-رشته-به-عدد-صحیح-فراتر-میرود) + - [💡 ‫ توضیح:](#--توضیح-6) - [‫ بخش: شیب‌های لغزنده](#-بخش-شیبهای-لغزنده) - [▶ ‫ تغییر یک دیکشنری هنگام پیمایش روی آن](#--تغییر-یک-دیکشنری-هنگام-پیمایش-روی-آن) - - [‫ 💡 توضیح:](#--توضیح) + - [‫ 💡 توضیح:](#--توضیح-7) - [▶ عملیات سرسختانه‌ی `del`](#-عملیات-سرسختانهی-del) - - [‫ 💡 توضیح:](#--توضیح-1) + - [‫ 💡 توضیح:](#--توضیح-8) - [▶ ‫ متغیری که از حوزه خارج است](#--متغیری-که-از-حوزه-خارج-است) - - [‫ 💡 توضیح:](#--توضیح-2) + - [‫ 💡 توضیح:](#--توضیح-9) - [▶ ‫ حذف المان‌های لیست در حین پیمایش](#--حذف-المانهای-لیست-در-حین-پیمایش) - - [💡 Explanation:](#-explanation-30) + - [💡 Explanation:](#-explanation-17) - [▶ ‫ زیپِ دارای اتلاف برای پیمایشگرها \*](#--زیپِ-دارای-اتلاف-برای-پیمایشگرها-) - - [‫ 💡 توضیحات:](#--توضیحات) + - [‫ 💡 توضیحات:](#--توضیحات-5) - [▶ ‫ نشت کردن متغیرهای حلقه!](#--نشت-کردن-متغیرهای-حلقه) - - [💡 ‫ توضیحات:](#--توضیحات-1) - - [▶ ‫ مراقب آرگومان‌های تغییرپذیر پیش‌فرض باشید!](#--مراقب-آرگومانهای-تغییرپذیر-پیشفرض-باشید) - - [💡 ‫ توضیحات:](#--توضیحات-2) - - [▶ ‫ گرفتن استثناها (Exceptions)](#--گرفتن-استثناها-exceptions) - - [💡 ‫ توضیحات](#--توضیحات-3) - - [▶ ‫ عملوندهای یکسان، داستانی متفاوت!](#--عملوندهای-یکسان-داستانی-متفاوت) - - [💡 ‫ توضیحات:](#--توضیحات-4) - - [▶ ‫ تفکیک نام‌ها با نادیده گرفتن حوزه‌ی کلاس](#--تفکیک-نامها-با-نادیده-گرفتن-حوزهی-کلاس) - - [💡 ‫ توضیحات](#--توضیحات-5) - - [▶ ‫ گرد کردن به روش بانکدار \*](#--گرد-کردن-به-روش-بانکدار-) - [💡 ‫ توضیحات:](#--توضیحات-6) - - [▶ ‫ سوزن‌هایی در انبار کاه \*](#--سوزنهایی-در-انبار-کاه-) + - [▶ ‫ مراقب آرگومان‌های تغییرپذیر پیش‌فرض باشید!](#--مراقب-آرگومانهای-تغییرپذیر-پیشفرض-باشید) - [💡 ‫ توضیحات:](#--توضیحات-7) - - [▶ ‫ تقسیم‌ها \*](#--تقسیمها-) - - [💡 ‫ توضیحات:](#--توضیحات-8) - - [▶ واردسازی‌های عمومی \*](#-واردسازیهای-عمومی-) + - [▶ ‫ گرفتن استثناها (Exceptions)](#--گرفتن-استثناها-exceptions) + - [💡 ‫ توضیحات](#--توضیحات-8) + - [▶ ‫ عملوندهای یکسان، داستانی متفاوت!](#--عملوندهای-یکسان-داستانی-متفاوت) - [💡 ‫ توضیحات:](#--توضیحات-9) - - [▶ ‫ همه چیز مرتب شده؟ \*](#--همه-چیز-مرتب-شده-) - - [💡 ‫ توضیحات:](#--توضیحات-10) - - [▶ ‫ زمان نیمه‌شب وجود ندارد؟](#--زمان-نیمهشب-وجود-ندارد) + - [▶ ‫ تفکیک نام‌ها با نادیده گرفتن حوزه‌ی کلاس](#--تفکیک-نامها-با-نادیده-گرفتن-حوزهی-کلاس) + - [💡 ‫ توضیحات](#--توضیحات-10) + - [▶ ‫ گرد کردن به روش بانکدار \*](#--گرد-کردن-به-روش-بانکدار-) - [💡 ‫ توضیحات:](#--توضیحات-11) + - [▶ ‫ سوزن‌هایی در انبار کاه \*](#--سوزنهایی-در-انبار-کاه-) + - [💡 ‫ توضیحات:](#--توضیحات-12) + - [▶ ‫ تقسیم‌ها \*](#--تقسیمها-) + - [💡 ‫ توضیحات:](#--توضیحات-13) + - [▶ واردسازی‌های عمومی \*](#-واردسازیهای-عمومی-) + - [💡 ‫ توضیحات:](#--توضیحات-14) + - [▶ ‫ همه چیز مرتب شده؟ \*](#--همه-چیز-مرتب-شده-) + - [💡 ‫ توضیحات:](#--توضیحات-15) + - [▶ ‫ زمان نیمه‌شب وجود ندارد؟](#--زمان-نیمهشب-وجود-ندارد) + - [💡 ‫ توضیحات:](#--توضیحات-16) - [‫ بخش: گنجینه‌های پنهان!](#-بخش-گنجینههای-پنهان) - [▶ ‫ خب پایتون، می‌توانی کاری کنی پرواز کنم؟](#--خب-پایتون-میتوانی-کاری-کنی-پرواز-کنم) - - [‫ 💡 توضیح:](#--توضیح-3) + - [‫ 💡 توضیح:](#--توضیح-10) - [▶ ‫ `goto`، ولی چرا؟](#--goto-ولی-چرا) - - [‫ 💡 توضیح:](#--توضیح-4) + - [‫ 💡 توضیح:](#--توضیح-11) - [▶ ‫ خودتان را آماده کنید!](#--خودتان-را-آماده-کنید) - - [‫ 💡 توضیح:](#--توضیح-5) + - [‫ 💡 توضیح:](#--توضیح-12) - [▶ ‫ بیایید با «عمو زبان مهربان برای همیشه» آشنا شویم](#--بیایید-با-عمو-زبان-مهربان-برای-همیشه-آشنا-شویم) - - [‫ 💡 توضیح:](#--توضیح-6) + - [‫ 💡 توضیح:](#--توضیح-13) - [▶ ‫ حتی پایتون هم می‌داند که عشق پیچیده است](#--حتی-پایتون-هم-میداند-که-عشق-پیچیده-است) - - [‫ 💡 توضیح:](#--توضیح-7) + - [‫ 💡 توضیح:](#--توضیح-14) - [▶ ‫ بله، این واقعاً وجود دارد!](#--بله-این-واقعاً-وجود-دارد) - - [‫ 💡 توضیح:](#--توضیح-8) + - [‫ 💡 توضیح:](#--توضیح-15) - [▶ Ellipsis \*](#-ellipsis-) - [‫ 💡توضیح](#-توضیح) - [▶ ‫ بی‌نهایت (`Inpinity`)](#--بینهایت-inpinity) - - [‫ 💡 توضیح:](#--توضیح-9) + - [‫ 💡 توضیح:](#--توضیح-16) - [▶ ‫ بیایید خرابکاری کنیم](#--بیایید-خرابکاری-کنیم) - - [‫ 💡 توضیح:](#--توضیح-10) + - [‫ 💡 توضیح:](#--توضیح-17) - [‫ بخش: ظاهرها فریبنده‌اند!](#-بخش-ظاهرها-فریبندهاند) - [▶ ‫ خطوط را رد می‌کند؟](#--خطوط-را-رد-میکند) - - [‫ 💡 توضیح](#--توضیح-11) + - [‫ 💡 توضیح](#--توضیح-18) - [▶ ‫ تله‌پورت کردن](#--تلهپورت-کردن) - - [‫ 💡 توضیح:](#--توضیح-12) + - [‫ 💡 توضیح:](#--توضیح-19) - [▶ ‫ خب، یک جای کار مشکوک است...](#--خب-یک-جای-کار-مشکوک-است) - - [‫ 💡 توضیح](#--توضیح-13) + - [‫ 💡 توضیح](#--توضیح-20) - [بخش: متفرقه](#بخش-متفرقه) - [‫ ▶ `+=` سریع‌تر است](#---سریعتر-است) - [‫ 💡 توضیح:](#---توضیح) - [‫ ▶ بیایید یک رشته‌ی بزرگ بسازیم!](#--بیایید-یک-رشتهی-بزرگ-بسازیم) - - [💡 توضیحات](#-توضیحات-1) + - [💡 توضیحات](#-توضیحات-2) - [▶ ‫ کُند کردن جستجوها در `dict` \*](#---کُند-کردن-جستجوها-در-dict-) - [‫ 💡 توضیح:](#---توضیح-1) - [‫ ▶ حجیم کردن دیکشنری نمونه‌ها (`instance dicts`) \*](#--حجیم-کردن-دیکشنری-نمونهها-instance-dicts-) @@ -1238,7 +1238,7 @@ The Subclass relationships were expected to be transitive, right? (i.e., if `A` --- -### ▶ Methods equality and identity +### ▶ ‫ برابری و هویت متدها 1. @@ -1256,7 +1256,7 @@ class SomeClass: pass ``` -**Output:** +‫ **خروجی:** ```py >>> print(SomeClass.method is SomeClass.method) True @@ -1268,8 +1268,8 @@ True True ``` -Accessing `classm` twice, we get an equal object, but not the *same* one? Let's see what happens -with instances of `SomeClass`: +‫ با دوبار دسترسی به `classm`، یک شیء برابر دریافت می‌کنیم، اما *همان* شیء نیست؟ بیایید ببینیم +‫ چه اتفاقی برای نمونه‌های `SomeClass` می‌افتد: 2. ```py @@ -1277,7 +1277,7 @@ o1 = SomeClass() o2 = SomeClass() ``` -**Output:** +‫ **خروجی:** ```py >>> print(o1.method == o2.method) False @@ -1293,53 +1293,41 @@ True True ``` -Accessing `classm` or `method` twice, creates equal but not *same* objects for the same instance of `SomeClass`. +‫ دسترسی به `classm` یا `method` دو بار، اشیایی برابر اما نه *یکسان* را برای همان نمونه از `SomeClass` ایجاد می‌کند. -#### 💡 Explanation -* Functions are [descriptors](https://docs.python.org/3/howto/descriptor.html). Whenever a function is accessed as an -attribute, the descriptor is invoked, creating a method object which "binds" the function with the object owning the -attribute. If called, the method calls the function, implicitly passing the bound object as the first argument -(this is how we get `self` as the first argument, despite not passing it explicitly). +#### 💡 ‫ توضیحات +* ‫ تابع‌ها [وصاف](https://docs.python.org/3/howto/descriptor.html) هستند. هر زمان که تابعی به عنوان یک ویژگی فراخوانی شود، وصف فعال می‌شود و یک شیء متد ایجاد می‌کند که تابع را به شیء صاحب آن ویژگی "متصل" می‌کند. اگر این متد فراخوانی شود، تابع را با ارسال ضمنی شیء متصل‌شده به عنوان اولین آرگومان صدا می‌زند (به این ترتیب است که `self` را به عنوان اولین آرگومان دریافت می‌کنیم، با وجود اینکه آن را به‌طور صریح ارسال نکرده‌ایم). ```py >>> o1.method > ``` -* Accessing the attribute multiple times creates a method object every time! Therefore `o1.method is o1.method` is -never truthy. Accessing functions as class attributes (as opposed to instance) does not create methods, however; so -`SomeClass.method is SomeClass.method` is truthy. +* ‫ دسترسی به ویژگی چندین بار، هر بار یک شیء متد جدید ایجاد می‌کند! بنابراین عبارت `o1.method is o1.method` هرگز درست (truthy) نیست. با این حال، دسترسی به تابع‌ها به عنوان ویژگی‌های کلاس (و نه نمونه) متد ایجاد نمی‌کند؛ بنابراین عبارت `SomeClass.method is SomeClass.method` درست است. ```py >>> SomeClass.method ``` -* `classmethod` transforms functions into class methods. Class methods are descriptors that, when accessed, create -a method object which binds the *class* (type) of the object, instead of the object itself. +* ‫ `classmethod` توابع را به متدهای کلاس تبدیل می‌کند. متدهای کلاس وصاف‌هایی هستند که هنگام دسترسی، یک شیء متد ایجاد می‌کنند که به *کلاس* (نوع) شیء متصل می‌شود، نه خود شیء. ```py >>> o1.classm > ``` -* Unlike functions, `classmethod`s will create a method also when accessed as class attributes (in which case they -bind the class, not to the type of it). So `SomeClass.classm is SomeClass.classm` is falsy. +* ‫ برخلاف توابع، `classmethod`‌ها هنگام دسترسی به عنوان ویژگی‌های کلاس نیز یک شیء متد ایجاد می‌کنند (که در این حالت به خود کلاس متصل می‌شوند، نه نوع آن). بنابراین عبارت `SomeClass.classm is SomeClass.classm` نادرست (falsy) است. ```py >>> SomeClass.classm > ``` -* A method object compares equal when both the functions are equal, and the bound objects are the same. So -`o1.method == o1.method` is truthy, although not the same object in memory. -* `staticmethod` transforms functions into a "no-op" descriptor, which returns the function as-is. No method -objects are ever created, so comparison with `is` is truthy. +* ‫ یک شیء متد زمانی برابر در نظر گرفته می‌شود که هم تابع‌ها برابر باشند و هم شیءهای متصل‌شده یکسان باشند. بنابراین عبارت `o1.method == o1.method` درست (truthy) است، هرچند که آن‌ها در حافظه شیء یکسانی نیستند. +* ‫ `staticmethod` توابع را به یک وصف "بدون عملیات" (no-op) تبدیل می‌کند که تابع را به همان صورت بازمی‌گرداند. هیچ شیء متدی ایجاد نمی‌شود، بنابراین مقایسه با `is` نیز درست (truthy) است. ```py >>> o1.staticm >>> SomeClass.staticm ``` -* Having to create new "method" objects every time Python calls instance methods and having to modify the arguments -every time in order to insert `self` affected performance badly. -CPython 3.7 [solved it](https://bugs.python.org/issue26110) by introducing new opcodes that deal with calling methods -without creating the temporary method objects. This is used only when the accessed function is actually called, so the -snippets here are not affected, and still generate methods :) +* ‫ ایجاد شیءهای "متد" جدید در هر بار فراخوانی متدهای نمونه و نیاز به اصلاح آرگومان‌ها برای درج `self`، عملکرد را به شدت تحت تأثیر قرار می‌داد. +CPython 3.7 [این مشکل را حل کرد](https://bugs.python.org/issue26110) با معرفی opcodeهای جدیدی که فراخوانی متدها را بدون ایجاد شیء متد موقتی مدیریت می‌کنند. این به شرطی است که تابع دسترسی‌یافته واقعاً فراخوانی شود، بنابراین قطعه‌کدهای اینجا تحت تأثیر قرار نمی‌گیرند و همچنان متد ایجاد می‌کنند :) -### ▶ All-true-ation * +### ▶ ‫ آل-ترو-یشن * @@ -1357,11 +1345,11 @@ False True ``` -Why's this True-False alteration? +‫ چرا این تغییر درست-نادرسته؟ #### 💡 Explanation: -- The implementation of `all` function is equivalent to +- ‫ پیاده‌سازی تابع `all` معادل است با - ```py def all(iterable): @@ -1371,15 +1359,15 @@ Why's this True-False alteration? return True ``` -- `all([])` returns `True` since the iterable is empty. -- `all([[]])` returns `False` because the passed array has one element, `[]`, and in python, an empty list is falsy. -- `all([[[]]])` and higher recursive variants are always `True`. This is because the passed array's single element (`[[...]]`) is no longer empty, and lists with values are truthy. +- ‫ `all([])` مقدار `True` را برمی‌گرداند چون iterable خالی است. +- ‫ `all([[]])` مقدار `False` را برمی‌گرداند چون آرایه‌ی داده‌شده یک عنصر دارد، یعنی `[]`، و در پایتون، لیست خالی مقدار falsy دارد. +- ‫ `all([[[]]])` و نسخه‌های بازگشتی بالاتر همیشه `True` هستند. دلیلش این است که عنصر واحد آرایه‌ی داده‌شده (`[[...]]`) دیگر خالی نیست، و لیست‌هایی که دارای مقدار باشند، truthy در نظر گرفته می‌شوند. --- -### ▶ The surprising comma +### ▶ ‫ کاما‌ی شگفت‌انگیز -**Output (< 3.6):** +‫ **خروجی (< 3.6):** ```py >>> def f(x, y,): @@ -1401,17 +1389,17 @@ SyntaxError: invalid syntax SyntaxError: invalid syntax ``` -#### 💡 Explanation: +#### 💡 ‫ توضیح: -- Trailing comma is not always legal in formal parameters list of a Python function. -- In Python, the argument list is defined partially with leading commas and partially with trailing commas. This conflict causes situations where a comma is trapped in the middle, and no rule accepts it. -- **Note:** The trailing comma problem is [fixed in Python 3.6](https://bugs.python.org/issue9232). The remarks in [this](https://bugs.python.org/issue9232#msg248399) post discuss in brief different usages of trailing commas in Python. +- ‫ کامای انتهایی همیشه در لیست پارامترهای رسمی یک تابع در پایتون قانونی نیست. +- ‫ در پایتون، لیست آرگومان‌ها تا حدی با کاماهای ابتدایی و تا حدی با کاماهای انتهایی تعریف می‌شود. این تضاد باعث ایجاد موقعیت‌هایی می‌شود که در آن یک کاما در وسط گیر می‌افتد و هیچ قانونی آن را نمی‌پذیرد. +- ‫ **نکته:** مشکل کامای انتهایی در [پایتون ۳.۶ رفع شده است](https://bugs.python.org/issue9232). توضیحات در [این پست](https://bugs.python.org/issue9232#msg248399) به‌طور خلاصه کاربردهای مختلف کاماهای انتهایی در پایتون را بررسی می‌کند. --- -### ▶ Strings and the backslashes +### ▶ ‫ رشته‌ها و بک‌اسلش‌ها -**Output:** +‫ **خروجی:** ```py >>> print("\"") " @@ -1429,14 +1417,14 @@ SyntaxError: EOL while scanning string literal True ``` -#### 💡 Explanation +#### 💡 ‫ توضیح: -- In a usual python string, the backslash is used to escape characters that may have a special meaning (like single-quote, double-quote, and the backslash itself). +- ‫ در یک رشته‌ی معمولی در پایتون، بک‌اسلش برای فرار دادن (escape) نویسه‌هایی استفاده می‌شود که ممکن است معنای خاصی داشته باشند (مانند تک‌نقل‌قول، دوتا‌نقل‌قول، و خودِ بک‌اسلش). ```py >>> "wt\"f" 'wt"f' ``` -- In a raw string literal (as indicated by the prefix `r`), the backslashes pass themselves as is along with the behavior of escaping the following character. +- ‫ در یک رشته‌ی خام (raw string literal) که با پیشوند `r` مشخص می‌شود، بک‌اسلش‌ها خودشان به همان شکل منتقل می‌شوند، به‌همراه رفتار فرار دادن نویسه‌ی بعدی. ```py >>> r'wt\"f' == 'wt\\"f' True @@ -1448,18 +1436,18 @@ True >>> print(r"\\n") '\\n' ``` -- This means when a parser encounters a backslash in a raw string, it expects another character following it. And in our case (`print(r"\")`), the backslash escaped the trailing quote, leaving the parser without a terminating quote (hence the `SyntaxError`). That's why backslashes don't work at the end of a raw string. +- ‫ در یک رشته‌ی خام (raw string) که با پیشوند `r` مشخص می‌شود، بک‌اسلش‌ها خودشان به همان صورت منتقل می‌شوند، همراه با رفتاری که کاراکتر بعدی را فرار می‌دهد (escape می‌کند). --- -### ▶ not knot! +### ▶ ‫ گره نیست، نَه! ```py x = True y = False ``` -**Output:** +‫ **خروجی:** ```py >>> not x == y True @@ -1472,16 +1460,16 @@ SyntaxError: invalid syntax #### 💡 Explanation: -* Operator precedence affects how an expression is evaluated, and `==` operator has higher precedence than `not` operator in Python. -* So `not x == y` is equivalent to `not (x == y)` which is equivalent to `not (True == False)` finally evaluating to `True`. -* But `x == not y` raises a `SyntaxError` because it can be thought of being equivalent to `(x == not) y` and not `x == (not y)` which you might have expected at first sight. -* The parser expected the `not` token to be a part of the `not in` operator (because both `==` and `not in` operators have the same precedence), but after not being able to find an `in` token following the `not` token, it raises a `SyntaxError`. +* ‫ تقدم عملگرها بر نحوه‌ی ارزیابی یک عبارت تأثیر می‌گذارد، و در پایتون، عملگر `==` تقدم بالاتری نسبت به عملگر `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` صادر می‌شود. --- -### ▶ Half triple-quoted strings +### ▶ رشته‌های نیمه سه‌نقل‌قولی -**Output:** +‫ **خروجی:** ```py >>> print('wtfpython''') wtfpython @@ -1496,25 +1484,25 @@ wtfpython SyntaxError: EOF while scanning triple-quoted string literal ``` -#### 💡 Explanation: -+ Python supports implicit [string literal concatenation](https://docs.python.org/3/reference/lexical_analysis.html#string-literal-concatenation), Example, +#### 💡 ‫ توضیح: ++ ‫ پایتون از الحاق ضمنی [رشته‌های متنی](https://docs.python.org/3/reference/lexical_analysis.html#string-literal-concatenation) پشتیبانی می‌کند. برای مثال، ``` >>> print("wtf" "python") wtfpython >>> print("wtf" "") # or "wtf""" wtf ``` -+ `'''` and `"""` are also string delimiters in Python which causes a SyntaxError because the Python interpreter was expecting a terminating triple quote as delimiter while scanning the currently encountered triple quoted string literal. ++ ‫ `'''` و `"""` نیز جداکننده‌های رشته‌ای در پایتون هستند که باعث ایجاد SyntaxError می‌شوند، چون مفسر پایتون هنگام اسکن رشته‌ای که با سه‌نقل‌قول آغاز شده، انتظار یک سه‌نقل‌قول پایانی به‌عنوان جداکننده را دارد. --- -### ▶ What's wrong with booleans? +### ▶ ‫ مشکل بولین ها چیست؟ 1\. ```py -# A simple example to count the number of booleans and -# integers in an iterable of mixed data types. +# یک مثال ساده برای شمردن تعداد مقادیر بولی و +# اعداد صحیح در یک iterable با انواع داده‌ی مخلوط. mixed_list = [False, 1.0, "some_string", 3, True, [], False] integers_found_so_far = 0 booleans_found_so_far = 0 @@ -1526,7 +1514,7 @@ for item in mixed_list: booleans_found_so_far += 1 ``` -**Output:** +‫ **خروجی:** ```py >>> integers_found_so_far 4 @@ -1554,7 +1542,7 @@ def tell_truth(): print("I have lost faith in truth!") ``` -**Output (< 3.x):** +‫ **خروجی (< 3.x):** ```py >>> tell_truth() @@ -1563,9 +1551,9 @@ I have lost faith in truth! -#### 💡 Explanation: +#### 💡 ‫ توضیحات: -* `bool` is a subclass of `int` in Python +* ‫ در پایتون، `bool` زیرکلاسی از `int` است ```py >>> issubclass(bool, int) @@ -1574,7 +1562,7 @@ I have lost faith in truth! False ``` -* And thus, `True` and `False` are instances of `int` +* ‫ و بنابراین، `True` و `False` نمونه‌هایی از `int` هستند ```py >>> isinstance(True, int) True @@ -1582,7 +1570,7 @@ I have lost faith in truth! True ``` -* The integer value of `True` is `1` and that of `False` is `0`. +* ‫ مقدار عددی `True` برابر با `1` و مقدار عددی `False` برابر با `0` است. ```py >>> int(True) 1 @@ -1590,15 +1578,15 @@ I have lost faith in truth! 0 ``` -* See this StackOverflow [answer](https://stackoverflow.com/a/8169049/4354153) for the rationale behind it. +* ‫ این پاسخ در StackOverflow را ببینید: [answer](https://stackoverflow.com/a/8169049/4354153) برای توضیح منطقی پشت این موضوع. -* Initially, Python used to have no `bool` type (people used 0 for false and non-zero value like 1 for true). `True`, `False`, and a `bool` type was added in 2.x versions, but, for backward compatibility, `True` and `False` couldn't be made constants. They just were built-in variables, and it was possible to reassign them +* ‫ در ابتدا، پایتون نوع `bool` نداشت (کاربران از 0 برای false و مقادیر غیر صفر مثل 1 برای true استفاده می‌کردند). `True`، `False` و نوع `bool` در نسخه‌های 2.x اضافه شدند، اما برای سازگاری با نسخه‌های قبلی، `True` و `False` نمی‌توانستند به عنوان ثابت تعریف شوند. آن‌ها فقط متغیرهای توکار (built-in) بودند و امکان تغییر مقدارشان وجود داشت. -* Python 3 was backward-incompatible, the issue was finally fixed, and thus the last snippet won't work with Python 3.x! +* ‫ پایتون ۳ با نسخه‌های قبلی ناسازگار بود، این مشکل سرانجام رفع شد، و بنابراین قطعه‌کد آخر در نسخه‌های Python 3.x کار نخواهد کرد! --- -### ▶ Class attributes and instance attributes +### ▶ ‫ ویژگی‌های کلاس و ویژگی‌های نمونه 1\. ```py @@ -1620,7 +1608,7 @@ class C(A): >>> A.x, B.x, C.x (1, 2, 1) >>> A.x = 3 ->>> A.x, B.x, C.x # C.x changed, but B.x didn't +>>> A.x, B.x, C.x # C.x تغییر کرد, اما B.x تغییر نکرد. (3, 2, 3) >>> a = A() >>> a.x, A.x @@ -1642,7 +1630,7 @@ class SomeClass: self.another_list += [x] ``` -**Output:** +‫ **خروجی:** ```py >>> some_obj = SomeClass(420) @@ -1661,10 +1649,11 @@ True True ``` -#### 💡 Explanation: +#### 💡 ‫ توضیح: + +* ‫ متغیرهای کلاس و متغیرهای نمونه‌های کلاس درونی به‌صورت دیکشنری‌هایی از شیء کلاس مدیریت می‌شوند. اگر نام متغیری در دیکشنری کلاس جاری پیدا نشود، کلاس‌های والد برای آن جست‌وجو می‌شوند. +* ‫ عملگر `+=` شیء قابل‌تغییر (mutable) را به‌صورت درجا (in-place) تغییر می‌دهد بدون اینکه شیء جدیدی ایجاد کند. بنابراین، تغییر ویژگی یک نمونه بر نمونه‌های دیگر و همچنین ویژگی کلاس تأثیر می‌گذارد. -* Class variables and variables in class instances are internally handled as dictionaries of a class object. If a variable name is not found in the dictionary of the current class, the parent classes are searched for it. -* The `+=` operator modifies the mutable object in-place without creating a new object. So changing the attribute of one instance affects the other instances and the class attribute as well. --- @@ -1713,14 +1702,14 @@ def some_func(x): yield from range(x) ``` -**Output (> 3.3):** +‫ **خروجی (> 3.3):** ```py >>> list(some_func(3)) [] ``` -Where did the `"wtf"` go? Is it due to some special effect of `yield from`? Let's validate that, +‫ چی شد که `"wtf"` ناپدید شد؟ آیا به خاطر اثر خاصی از `yield from` است؟ بیایید این موضوع را بررسی کنیم، 2\. @@ -1733,24 +1722,24 @@ def some_func(x): yield i ``` -**Output:** +‫ **خروجی:** ```py >>> list(some_func(3)) [] ``` -The same result, this didn't work either. +‫ همان نتیجه، این یکی هم کار نکرد. -#### 💡 Explanation: +#### 💡 ‫ توضیح: -+ From Python 3.3 onwards, it became possible to use `return` statement with values inside generators (See [PEP380](https://www.python.org/dev/peps/pep-0380/)). The [official docs](https://www.python.org/dev/peps/pep-0380/#enhancements-to-stopiteration) say that, ++ ‫ از پایتون نسخه ۳.۳ به بعد، امکان استفاده از عبارت `return` همراه با مقدار در داخل ژنراتورها فراهم شد (نگاه کنید به [PEP380](https://www.python.org/dev/peps/pep-0380/)). [مستندات رسمی](https://www.python.org/dev/peps/pep-0380/#enhancements-to-stopiteration) می‌گویند: -> "... `return expr` in a generator causes `StopIteration(expr)` to be raised upon exit from the generator." +> ‫ "... `return expr` در یک ژنراتور باعث می‌شود که هنگام خروج از ژنراتور، `StopIteration(expr)` ایجاد شود." -+ In the case of `some_func(3)`, `StopIteration` is raised at the beginning because of `return` statement. The `StopIteration` exception is automatically caught inside the `list(...)` wrapper and the `for` loop. Therefore, the above two snippets result in an empty list. ++ ‫ در حالت `some_func(3)`، استثنای `StopIteration` در ابتدای اجرا به دلیل وجود دستور `return` رخ می‌دهد. این استثنا به‌طور خودکار درون پوشش `list(...)` و حلقه `for` گرفته می‌شود. بنابراین، دو قطعه‌کد بالا منجر به یک لیست خالی می‌شوند. -+ To get `["wtf"]` from the generator `some_func` we need to catch the `StopIteration` exception, ++ ‫ برای اینکه مقدار `["wtf"]` را از ژنراتور `some_func` بگیریم، باید استثنای `StopIteration` را خودمان مدیریت کنیم، ```py try: @@ -1766,7 +1755,7 @@ The same result, this didn't work either. --- -### ▶ Nan-reflexivity * +### ▶ ‫ بازتاب‌ناپذیری * @@ -1775,11 +1764,11 @@ The same result, this didn't work either. ```py a = float('inf') b = float('nan') -c = float('-iNf') # These strings are case-insensitive +c = float('-iNf') # این رشته‌ها نسبت به حروف بزرگ و کوچک حساس نیستند d = float('nan') ``` -**Output:** +‫ **خروجی:** ```py >>> a @@ -1794,7 +1783,7 @@ ValueError: could not convert string to float: some_other_string True >>> None == None # None == None True ->>> b == d # but nan!=nan +>>> b == d # اما nan!=nan False >>> 50 / a 0.0 @@ -1809,21 +1798,21 @@ nan ```py >>> x = float('nan') >>> y = x / x ->>> y is y # identity holds +>>> y is y # برابری هویتی برقرار است True ->>> y == y # equality fails of y +>>> y == y #برابری در مورد y برقرار نیست False ->>> [y] == [y] # but the equality succeeds for the list containing y +>>> [y] == [y] # اما برابری برای لیستی که شامل y است برقرار می‌شود True ``` -#### 💡 Explanation: +#### 💡 توضیحات: -- `'inf'` and `'nan'` are special strings (case-insensitive), which, when explicitly typecast-ed to `float` type, are used to represent mathematical "infinity" and "not a number" respectively. +- ‫ `'inf'` و `'nan'` رشته‌هایی خاص هستند (نسبت به حروف بزرگ و کوچک حساس نیستند) که وقتی به‌طور صریح به نوع `float` تبدیل شوند، به ترتیب برای نمایش "بی‌نهایت" ریاضی و "عدد نیست" استفاده می‌شوند. -- Since according to IEEE standards ` NaN != NaN`, obeying this rule breaks the reflexivity assumption of a collection element in Python i.e. if `x` is a part of a collection like `list`, the implementations like comparison are based on the assumption that `x == x`. Because of this assumption, the identity is compared first (since it's faster) while comparing two elements, and the values are compared only when the identities mismatch. The following snippet will make things clearer, +- ‫ از آنجا که طبق استاندارد IEEE، `NaN != NaN`، پایبندی به این قانون فرض بازتاب‌پذیری (reflexivity) یک عنصر در مجموعه‌ها را در پایتون نقض می‌کند؛ یعنی اگر `x` عضوی از مجموعه‌ای مثل `list` باشد، پیاده‌سازی‌هایی مانند مقایسه، بر اساس این فرض هستند که `x == x`. به دلیل همین فرض، ابتدا هویت (identity) دو عنصر مقایسه می‌شود (چون سریع‌تر است) و فقط زمانی مقادیر مقایسه می‌شوند که هویت‌ها متفاوت باشند. قطعه‌کد زیر موضوع را روشن‌تر می‌کند، ```py >>> x = float('nan') @@ -1836,24 +1825,24 @@ True (False, False) ``` - Since the identities of `x` and `y` are different, the values are considered, which are also different; hence the comparison returns `False` this time. + ‫ از آنجا که هویت‌های `x` و `y` متفاوت هستند، مقادیر آن‌ها در نظر گرفته می‌شوند که آن‌ها نیز متفاوت‌اند؛ بنابراین مقایسه این بار `False` را برمی‌گرداند. -- Interesting read: [Reflexivity, and other pillars of civilization](https://bertrandmeyer.com/2010/02/06/reflexivity-and-other-pillars-of-civilization/) +- ‫ خواندنی جالب: [بازتاب‌پذیری و دیگر ارکان تمدن](https://bertrandmeyer.com/2010/02/06/reflexivity-and-other-pillars-of-civilization/) --- -### ▶ Mutating the immutable! +### ▶ ‫ تغییر دادن اشیای تغییرناپذیر! -This might seem trivial if you know how references work in Python. +‫ این موضوع ممکن است بدیهی به نظر برسد اگر با نحوه‌ی کار ارجاع‌ها در پایتون آشنا باشید. ```py some_tuple = ("A", "tuple", "with", "values") another_tuple = ([1, 2], [3, 4], [5, 6]) ``` -**Output:** +‫ **خروجی:** ```py >>> some_tuple[2] = "change this" TypeError: 'tuple' object does not support item assignment @@ -1866,21 +1855,22 @@ TypeError: 'tuple' object does not support item assignment ([1, 2], [3, 4], [5, 6, 1000, 99, 999]) ``` -But I thought tuples were immutable... +اما من فکر می‌کردم تاپل‌ها تغییرناپذیر هستند... -#### 💡 Explanation: +#### 💡 ‫ توضیحات: -* Quoting from https://docs.python.org/3/reference/datamodel.html +* ‫ نقل‌قول از https://docs.python.org/3/reference/datamodel.html - > Immutable sequences - An object of an immutable sequence type cannot change once it is created. (If the object contains references to other objects, these other objects may be mutable and may be modified; however, the collection of objects directly referenced by an immutable object cannot change.) + > ‫ دنباله‌های تغییرناپذیر + ‫ شیئی از نوع دنباله‌ی تغییرناپذیر، پس از ایجاد دیگر قابل تغییر نیست. (اگر شیء شامل ارجاع‌هایی به اشیای دیگر باشد، این اشیای دیگر ممکن است قابل تغییر باشند و تغییر کنند؛ اما مجموعه‌ی اشیایی که مستقیماً توسط یک شیء تغییرناپذیر ارجاع داده می‌شوند، نمی‌تواند تغییر کند.) + +* ‫ عملگر `+=` لیست را به‌صورت درجا (in-place) تغییر می‌دهد. تخصیص به یک عضو کار نمی‌کند، اما زمانی که استثنا ایجاد می‌شود، عضو موردنظر پیش از آن به‌صورت درجا تغییر کرده است. +* ‫ همچنین توضیحی در [پرسش‌های متداول رسمی پایتون](https://docs.python.org/3/faq/programming.html#why-does-a-tuple-i-item-raise-an-exception-when-the-addition-works) وجود دارد. -* `+=` operator changes the list in-place. The item assignment doesn't work, but when the exception occurs, the item has already been changed in place. -* There's also an explanation in [official Python FAQ](https://docs.python.org/3/faq/programming.html#why-does-a-tuple-i-item-raise-an-exception-when-the-addition-works). --- -### ▶ The disappearing variable from outer scope +### ▶ ‫ متغیری که از اسکوپ بیرونی ناپدید می‌شود ```py @@ -1894,7 +1884,7 @@ except Exception as e: **Output (Python 2.x):** ```py >>> print(e) -# prints nothing +# ‫ چیزی چاپ نمی شود. ``` **Output (Python 3.x):** @@ -1903,18 +1893,17 @@ except Exception as e: NameError: name 'e' is not defined ``` -#### 💡 Explanation: +#### 💡 ‫ توضیحات: +* ‫ منبع: [مستندات رسمی پایتون](https://docs.python.org/3/reference/compound_stmts.html#except) -* Source: https://docs.python.org/3/reference/compound_stmts.html#except - - When an exception has been assigned using `as` target, it is cleared at the end of the `except` clause. This is as if +‫ هنگامی که یک استثنا (Exception) با استفاده از کلمه‌ی کلیدی `as` به متغیری تخصیص داده شود، این متغیر در انتهای بلاکِ `except` پاک می‌شود. این رفتار مشابه کد زیر است: ```py except E as N: foo ``` - was translated into + ‫ به این شکل ترجمه شده باشد: ```py except E as N: @@ -1924,9 +1913,10 @@ NameError: name 'e' is not defined del N ``` - This means the exception must be assigned to a different name to be able to refer to it after the except clause. Exceptions are cleared because, with the traceback attached to them, they form a reference cycle with the stack frame, keeping all locals in that frame alive until the next garbage collection occurs. +‫ این بدان معناست که استثنا باید به نام دیگری انتساب داده شود تا بتوان پس از پایان بند `except` به آن ارجاع داد. استثناها پاک می‌شوند چون با داشتن «ردیابی» (traceback) ضمیمه‌شده، یک چرخه‌ی مرجع (reference cycle) با قاب پشته (stack frame) تشکیل می‌دهند که باعث می‌شود تمام متغیرهای محلی (locals) در آن قاب تا زمان پاکسازی حافظه (garbage collection) باقی بمانند. + +* ‫ در پایتون، بندها (`clauses`) حوزه‌ی مستقل ندارند. در مثال بالا، همه‌چیز در یک حوزه‌ی واحد قرار دارد، و متغیر `e` در اثر اجرای بند `except` حذف می‌شود. این موضوع در مورد توابع صادق نیست، زیرا توابع حوزه‌های داخلی جداگانه‌ای دارند. مثال زیر این نکته را نشان می‌دهد: -* The clauses are not scoped in Python. Everything in the example is present in the same scope, and the variable `e` got removed due to the execution of the `except` clause. The same is not the case with functions that have their separate inner-scopes. The example below illustrates this: ```py def f(x): @@ -1937,7 +1927,7 @@ NameError: name 'e' is not defined y = [5, 4, 3] ``` - **Output:** + ‫ **خروجی:** ```py >>> f(x) UnboundLocalError: local variable 'x' referenced before assignment @@ -1949,20 +1939,20 @@ NameError: name 'e' is not defined [5, 4, 3] ``` -* In Python 2.x, the variable name `e` gets assigned to `Exception()` instance, so when you try to print, it prints nothing. +* ‫ در پایتون نسخه‌ی ۲.x، نام متغیر `e` به یک نمونه از `Exception()` انتساب داده می‌شود، بنابراین وقتی سعی کنید آن را چاپ کنید، چیزی نمایش داده نمی‌شود. - **Output (Python 2.x):** + ‫ **خروجی (Python 2.x):** ```py >>> e Exception() >>> print e - # Nothing is printed! + # چیزی چاپ نمی شود. ``` --- -### ▶ The mysterious key type conversion +### ▶ ‫ تبدیل اسرارآمیز نوع کلید ```py class SomeClass(str): @@ -1971,7 +1961,7 @@ class SomeClass(str): some_dict = {'s': 42} ``` -**Output:** +‫ **خروجی:** ```py >>> type(list(some_dict.keys())[0]) str @@ -1983,12 +1973,12 @@ str str ``` -#### 💡 Explanation: +#### 💡 ‫ توضیحات: -* Both the object `s` and the string `"s"` hash to the same value because `SomeClass` inherits the `__hash__` method of `str` class. -* `SomeClass("s") == "s"` evaluates to `True` because `SomeClass` also inherits `__eq__` method from `str` class. -* Since both the objects hash to the same value and are equal, they are represented by the same key in the dictionary. -* For the desired behavior, we can redefine the `__eq__` method in `SomeClass` +* ‫ هر دو شیء `s` و رشته‌ی `"s"` به دلیل ارث‌بری `SomeClass` از متد `__hash__` کلاس `str`، هش یکسانی دارند. +* ‫ عبارت `SomeClass("s") == "s"` به دلیل ارث‌بری `SomeClass` از متد `__eq__` کلاس `str` برابر با `True` ارزیابی می‌شود. +* ‫ از آنجا که این دو شیء هش یکسان و برابری دارند، به عنوان یک کلید مشترک در دیکشنری در نظر گرفته می‌شوند. +* ‫ برای رسیدن به رفتار دلخواه، می‌توانیم متد `__eq__` را در کلاس `SomeClass` بازتعریف کنیم. ```py class SomeClass(str): def __eq__(self, other): @@ -1998,14 +1988,14 @@ str and super().__eq__(other) ) - # When we define a custom __eq__, Python stops automatically inheriting the - # __hash__ method, so we need to define it as well + # ‫ هنگامی که متد __eq__ را به‌طور دلخواه تعریف می‌کنیم، پایتون دیگر متد __hash__ را به صورت خودکار به ارث نمی‌برد، + # ‫ بنابراین باید متد __hash__ را نیز مجدداً تعریف کنیم. __hash__ = str.__hash__ some_dict = {'s':42} ``` - **Output:** + ‫ **خروجی:** ```py >>> s = SomeClass('s') >>> some_dict[s] = 40 @@ -2018,37 +2008,37 @@ str --- -### ▶ Let's see if you can guess this? +### ▶ ‫ ببینیم می‌توانید این را حدس بزنید؟ ```py a, b = a[b] = {}, 5 ``` -**Output:** +‫ **خروجی:** ```py >>> a {5: ({...}, 5)} ``` -#### 💡 Explanation: +#### 💡 ‫ توضیح: -* According to [Python language reference](https://docs.python.org/3/reference/simple_stmts.html#assignment-statements), assignment statements have the form +* ‫ طبق [مرجع زبان پایتون](https://docs.python.org/3/reference/simple_stmts.html#assignment-statements)، دستورات انتساب فرم زیر را دارند: ``` (target_list "=")+ (expression_list | yield_expression) ``` - and + و -> An assignment statement evaluates the expression list (remember that this can be a single expression or a comma-separated list, the latter yielding a tuple) and assigns the single resulting object to each of the target lists, from left to right. +> ‫ یک دستور انتساب ابتدا فهرست عبارت‌ها (expression list) را ارزیابی می‌کند (توجه کنید این عبارت می‌تواند یک عبارت تکی یا فهرستی از عبارت‌ها جداشده با ویرگول باشد که دومی به یک تاپل منجر می‌شود)، سپس شیء حاصل را به هریک از اهداف انتساب از **چپ به راست** تخصیص می‌دهد. -* The `+` in `(target_list "=")+` means there can be **one or more** target lists. In this case, target lists are `a, b` and `a[b]` (note the expression list is exactly one, which in our case is `{}, 5`). +* ‫ علامت `+` در `(target_list "=")+` به این معناست که می‌توان **یک یا چند** هدف انتساب داشت. در این حالت، اهداف انتساب ما `a, b` و `a[b]` هستند (توجه کنید که عبارت ارزیابی‌شده دقیقاً یکی است، که در اینجا `{}` و `5` است). -* After the expression list is evaluated, its value is unpacked to the target lists from **left to right**. So, in our case, first the `{}, 5` tuple is unpacked to `a, b` and we now have `a = {}` and `b = 5`. +* ‫ پس از ارزیابی عبارت، نتیجه از **چپ به راست** به اهداف انتساب داده می‌شود. در این مثال ابتدا تاپل `({}, 5)` به `a, b` باز می‌شود، بنابراین `a = {}` و `b = 5` خواهیم داشت. -* `a` is now assigned to `{}`, which is a mutable object. +* ‫ حالا `a` یک شیء قابل تغییر (mutable) است (`{}`). -* The second target list is `a[b]` (you may expect this to throw an error because both `a` and `b` have not been defined in the statements before. But remember, we just assigned `a` to `{}` and `b` to `5`). +* ‫ هدف انتساب بعدی `a[b]` است (شاید انتظار داشته باشید که اینجا خطا بگیریم زیرا پیش از این هیچ مقداری برای `a` و `b` مشخص نشده است؛ اما به یاد داشته باشید که در گام قبل به `a` مقدار `{}` و به `b` مقدار `5` دادیم). -* Now, we are setting the key `5` in the dictionary to the tuple `({}, 5)` creating a circular reference (the `{...}` in the output refers to the same object that `a` is already referencing). Another simpler example of circular reference could be +* ‫ اکنون، کلید `5` در دیکشنری به تاپل `({}, 5)` مقداردهی می‌شود و یک مرجع دوری (Circular Reference) ایجاد می‌کند (علامت `{...}` در خروجی به همان شیئی اشاره دارد که قبلاً توسط `a` به آن ارجاع داده شده است). یک مثال ساده‌تر از مرجع دوری می‌تواند به این صورت باشد: ```py >>> some_list = some_list[0] = [0] >>> some_list @@ -2060,14 +2050,15 @@ a, b = a[b] = {}, 5 >>> some_list[0][0][0][0][0][0] == some_list True ``` - Similar is the case in our example (`a[b][0]` is the same object as `a`) + ‫ در مثال ما نیز شرایط مشابه است (`a[b][0]` همان شیئی است که `a` به آن اشاره دارد). -* So to sum it up, you can break the example down to + +* ‫ بنابراین برای جمع‌بندی، می‌توانید مثال بالا را به این صورت ساده کنید: ```py a, b = {}, 5 a[b] = a, b ``` - And the circular reference can be justified by the fact that `a[b][0]` is the same object as `a` + ‫ و مرجع دوری به این دلیل قابل توجیه است که `a[b][0]` همان شیئی است که `a` به آن اشاره دارد. ```py >>> a[b][0] is a True @@ -2076,7 +2067,7 @@ a, b = a[b] = {}, 5 --- -### ▶ Exceeds the limit for integer string conversion +### ▶ ‫ از حد مجاز برای تبدیل رشته به عدد صحیح فراتر می‌رود ```py >>> # Python 3.10.6 >>> int("2" * 5432) @@ -2085,7 +2076,7 @@ a, b = a[b] = {}, 5 >>> int("2" * 5432) ``` -**Output:** +‫ **خروجی:** ```py >>> # Python 3.10.6 222222222222222222222222222222222222222222222222222222222222222... @@ -2098,15 +2089,16 @@ ValueError: Exceeds the limit (4300) for integer string conversion: to increase the limit. ``` -#### 💡 Explanation: -This call to `int()` works fine in Python 3.10.6 and raises a ValueError in Python 3.10.8. Note that Python can still work with large integers. The error is only raised when converting between integers and strings. +#### 💡 ‫ توضیح: +‫ فراخوانی تابع `int()` در نسخه‌ی Python 3.10.6 به‌خوبی کار می‌کند اما در نسخه‌ی Python 3.10.8 منجر به خطای `ValueError` می‌شود. توجه کنید که پایتون همچنان قادر به کار با اعداد صحیح بزرگ است. این خطا تنها هنگام تبدیل اعداد صحیح به رشته یا برعکس رخ می‌دهد. -Fortunately, you can increase the limit for the allowed number of digits when you expect an operation to exceed it. To do this, you can use one of the following: -- The -X int_max_str_digits command-line flag -- The set_int_max_str_digits() function from the sys module -- The PYTHONINTMAXSTRDIGITS environment variable +‫ خوشبختانه می‌توانید در صورت انتظار عبور از این حد مجاز، مقدار آن را افزایش دهید. برای انجام این کار می‌توانید از یکی از روش‌های زیر استفاده کنید: -[Check the documentation](https://docs.python.org/3/library/stdtypes.html#int-max-str-digits) for more details on changing the default limit if you expect your code to exceed this value. +- ‫ استفاده از فلگ خط فرمان `-X int_max_str_digits` +- ‫ تابع `set_int_max_str_digits()` از ماژول `sys` +- ‫ متغیر محیطی `PYTHONINTMAXSTRDIGITS` + +‫ برای جزئیات بیشتر درباره‌ی تغییر مقدار پیش‌فرض این حد مجاز، [مستندات رسمی پایتون](https://docs.python.org/3/library/stdtypes.html#int-max-str-digits) را مشاهده کنید. --- From 0fcad66357611da88e664ecab918afb2ab790870 Mon Sep 17 00:00:00 2001 From: Mohamad Reza Date: Fri, 4 Apr 2025 01:22:36 +0330 Subject: [PATCH 15/33] update farsi translations for section 1, and delete the temp file --- translations/fa-farsi/README.md | 406 +++++----- translations/fa-farsi/section1-temp.md | 1007 ------------------------ 2 files changed, 206 insertions(+), 1207 deletions(-) delete mode 100644 translations/fa-farsi/section1-temp.md diff --git a/translations/fa-farsi/README.md b/translations/fa-farsi/README.md index d913359..2dbaa0c 100644 --- a/translations/fa-farsi/README.md +++ b/translations/fa-farsi/README.md @@ -47,33 +47,33 @@ - [▶ اول از همه! \*](#-اول-از-همه-) - [💡 توضیحات](#-توضیحات) - [▶ بعضی وقت‌ها رشته‌ها می‌توانند دردسرساز شوند](#-بعضی-وقتها-رشتهها-میتوانند-دردسرساز-شوند) - - [💡 Explanation:](#-explanation) - - [▶ Be careful with chained operations](#-be-careful-with-chained-operations) - - [💡 Explanation:](#-explanation-1) - - [▶ How not to use `is` operator](#-how-not-to-use-is-operator) - - [💡 Explanation:](#-explanation-2) - - [▶ Hash brownies](#-hash-brownies) - - [💡 Explanation](#-explanation-3) - - [▶ Deep down, we're all the same.](#-deep-down-were-all-the-same) - - [💡 Explanation:](#-explanation-4) - - [▶ Disorder within order \*](#-disorder-within-order-) - - [💡 Explanation:](#-explanation-5) - - [▶ Keep trying... \*](#-keep-trying-) - - [💡 Explanation:](#-explanation-6) - - [▶ For what?](#-for-what) - - [💡 Explanation:](#-explanation-7) - - [▶ Evaluation time discrepancy](#-evaluation-time-discrepancy) - - [💡 Explanation](#-explanation-8) - - [▶ `is not ...` is not `is (not ...)`](#-is-not--is-not-is-not-) - - [💡 Explanation](#-explanation-9) - - [▶ A tic-tac-toe where X wins in the first attempt!](#-a-tic-tac-toe-where-x-wins-in-the-first-attempt) - - [💡 Explanation:](#-explanation-10) - - [▶ Schrödinger's variable \*](#-schrödingers-variable-) - - [💡 Explanation:](#-explanation-11) - - [▶ The chicken-egg problem \*](#-the-chicken-egg-problem-) - - [💡 Explanation](#-explanation-12) - - [▶ Subclass relationships](#-subclass-relationships) - - [💡 Explanation:](#-explanation-13) + - [💡 توضیح:](#-توضیح) + - [▶ مراقب عملیات‌های زنجیره‌ای باشید](#-مراقب-عملیاتهای-زنجیرهای-باشید) + - [💡 توضیحات:](#-توضیحات-1) + - [▶ چطور از عملگر `is` استفاده نکنیم](#-چطور-از-عملگر-is-استفاده-نکنیم) + - [💡 توضیحات:](#-توضیحات-2) + - [▶ کلیدهای هش](#-کلیدهای-هش) + - [💡 توضیحات](#-توضیحات-3) + - [▶ در عمق وجود همه ما یکسان هستیم](#-در-عمق-وجود-همه-ما-یکسان-هستیم) + - [💡 توضیحات:](#-توضیحات-4) + - [▶ بی‌نظمی در خود نظم \*](#-بینظمی-در-خود-نظم-) + - [💡 توضیحات:](#-توضیحات-5) + - [▶ تلاش کن... \*](#-تلاش-کن-) + - [💡 توضیحات:](#-توضیحات-6) + - [▶ برای چی؟](#-برای-چی) + - [💡 توضیحات:](#-توضیحات-7) + - [▶ اختلاف زمانی در محاسبه](#-اختلاف-زمانی-در-محاسبه) + - [💡 توضیحات](#-توضیحات-8) + - [▶ هر گردی، گردو نیست](#-هر-گردی-گردو-نیست) + - [💡 توضیحات](#-توضیحات-9) + - [▶ یک بازی دوز که توش X همون اول برنده میشه!](#-یک-بازی-دوز-که-توش-X-همون-اول-برنده-میشه) + - [💡 توضیحات:](#-توضیحات-10) + - [▶ متغیر شرودینگر \*](#-متغیر-شرودینگر-) + - [💡 توضیحات:](#-توضیحات-11) + - [▶ اول مرغ بوده یا تخم مرغ؟ \*](#-اول-مرغ-بوده-یا-تخم-مرغ-) + - [💡 توضیحات](#-توضیحات-12) + - [▶ روابط بین زیرمجموعه کلاس‌ها](#-روابط-بین-زیرمجموعه-کلاسها) + - [💡 توضیحات:](#-توضیحات-13) - [▶ ‫ برابری و هویت متدها](#--برابری-و-هویت-متدها) - [💡 ‫ توضیحات](#--توضیحات) - [▶ ‫ آل-ترو-یشن \*](#--آل-ترو-یشن-) @@ -370,7 +370,7 @@ if a := some_func(): >>> a = "some_string" >>> id(a) 140420665652016 ->>> id("some" + "_" + "string") # دقت کنید که هردو ID یکی هستند. +>>> id("some" + "_" + "string") # دقت کنید که هردو شناسه یکسانند. 140420665652016 ``` @@ -420,15 +420,16 @@ True False ``` -Makes sense, right? +منطقیه، نه؟ + +#### 💡 توضیحات: ++ در قطعه‌کد اول و دوم، رفتار کد به دلیل یک بهینه سازی در CPython است (به نام داوطلب سازی رشته‌ها) که باعث می‌شود از برخی مقادیر غیرقابل تغییر، به جای مقداردهی مجدد، دوباره استفاده شود. ++ بیشتر متغیرهایی که به‌این صورت جایگزین می‌شوند، در حافظه دستگاه به مقدار داوطلب خود اشاره می‌کنند (تا از حافظه کمتری استفاده شود) ++ در قطعه‌کدهای بالا، رشته‌ها به‌صورت غیرمستقیم داوطلب می‌شوند. تصمیم اینکه رشته‌ها چه زمانی به صورت غیرمستقیم داوطلب شوند به نحوه پیاده‌سازی و مقداردهی آن‌ها بستگی دارد. برخی قوانین وجود دارند تا بتوانیم داوطلب شدن یا نشدن یک رشته را حدس بزنیم: + * همه رشته‌ها با طول صفر یا یک داوطلب می‌شوند. + * رشته‌ها در زمان کامپایل داوطلب می‌شوند (`'wtf'` داوطلب می‌شود اما `''.join(['w', 't', 'f'])` داوطلب نمی‌شود) + * رشته‌هایی که از حروف ASCII ، اعداد صحیح و آندرلاین تشکیل نشده‌باشند داوطلب نمی‌شود. به همین دلیل `'wtf!'` به خاطر وجود `'!'` داوطلب نشد. پیاده‌سازی این قانون در CPython در [اینجا](https://github.com/python/cpython/blob/3.6/Objects/codeobject.c#L19) قرار دارد. -#### 💡 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](https://github.com/python/cpython/blob/3.6/Objects/codeobject.c#L19)

@@ -437,22 +438,22 @@ Makes sense, right?

-+ 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](https://github.com/satwikkansal/wtfpython/issues/100) 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](https://en.wikipedia.org/wiki/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](https://github.com/python/cpython/blob/3.6/Python/peephole.c#L288) 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](https://bugs.python.org/issue11549). ++ زمانی که `"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) بیشتر درمورد این تغییرات بخوانید. --- -### ▶ Be careful with chained operations +### ▶ مراقب عملیات‌های زنجیره‌ای باشید ```py ->>> (False == False) in [False] # makes sense +>>> (False == False) in [False] # منطقیه False ->>> False == (False in [False]) # makes sense +>>> False == (False in [False]) # منطقیه False ->>> False == False in [False] # now what? +>>> False == False in [False] # حالا چی؟ True >>> True is False == False @@ -468,31 +469,30 @@ False False ``` -#### 💡 Explanation: +#### 💡 توضیحات: -As per https://docs.python.org/3/reference/expressions.html#comparisons +طبق 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 است. فقط دقت کنید که هر عبارت یک بار ارزیابی می‌شود. -> 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. +شاید چنین رفتاری برای شما احمقانه به نظر بیاد ولی برای عملیات‌هایی مثل `a == b == c` و `0 <= x <= 100` عالی عمل می‌کنه. -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 +* عبارت `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 #not relevant for this example, but just for fun + >>> True + 1 # مربوط به این بخش نیست ولی همینجوری گذاشتم 2 ``` - So, `1 < 1` evaluates to `False` + پس عبارت `True < 1` معادل عبارت `1 < 1` می‌شود که در کل معادل `False` است. --- -### ▶ How not to use `is` operator +### ▶ چطور از عملگر `is` استفاده نکنیم -The following is a very famous example present all over the internet. +عبارت پایین خیلی معروفه و تو کل اینترنت موجوده. 1\. @@ -523,7 +523,7 @@ True ``` 3\. -**Output** +**خروجی** ```py >>> a, b = 257, 257 @@ -531,7 +531,7 @@ True True ``` -**Output (Python 3.7.x specifically)** +**خروجی (مخصوص نسخه‌های (x).۳.۷)** ```py >>> a, b = 257, 257 @@ -539,25 +539,25 @@ True False ``` -#### 💡 Explanation: +#### 💡 توضیحات: -**The difference between `is` and `==`** +**فرض بین عملگرهای `is` و `==`** -* `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, +* عملگر `is` بررسی میکنه که دو متغیر در حافظه دستگاه به یک شیء اشاره میکنند یا نه (یعنی شناسه متغیرها رو با هم تطبیق میده). +* عملگر `==` مقدار متغیرها رو با هم مقایسه میکنه و یکسان بودنشون رو بررسی میکنه. +* پس `is` برای معادل بودن متغیرها در حافظه دستگاه و `==` برای معادل بودن مقادیر استفاده میشه. یه مثال برای شفاف سازی بیشتر: ```py >>> class A: pass - >>> A() is A() # These are two empty objects at two different memory locations. + >>> A() is A() # این‌ها دو شیء خالی هستند که در دو جای مختلف در حافظه قرار دارند. False ``` -**`256` is an existing object but `257` isn't** +**عدد `256` از قبل تو حافظه قرار داده شده ولی `257` نه؟** -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. +وقتی پایتون رو اجرا می‌کنید اعداد از `-5` تا `256` در حافظه ذخیره میشن. چون این اعداد خیلی پرکاربرد هستند پس منطقیه که اون‌ها رو در حافظه دستگاه، آماده داشته باشیم. -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. :-) +نقل قول از https://docs.python.org/3/c-api/long.html +> در پیاده سازی فعلی یک آرایه از اشیاء عددی صحیح برای تمام اعداد صحیح بین `-5` تا `256` نگه‌داری می‌شود. وقتی شما یک عدد صحیح در این بازه به مقداردهی می‌کنید، فقط یک ارجاع به آن عدد که از قبل در حافظه ذخیره شده است دریافت می‌کنید. پس تغییر مقدار عدد 1 باید ممکن باشد. که در این مورد من به رفتار پایتون شک دارم تعریف‌نشده است. :-) ```py >>> id(256) @@ -578,13 +578,13 @@ Quoting from https://docs.python.org/3/c-api/long.html 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. +در اینجا مفسر وقتی عبارت `y = 257` رو اجرا میکنه، به اندازه کافی زیرکانه عمل نمیکنه که تشخیص بده که ما یک عدد صحیح با مقدار `257` در حافظه ذخیره کرده‌ایم، پس به ساختن یک شیء جدید در حافظه ادامه میده. -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, +یک بهینه سازی مشابه شامل حال مقادیر **غیرقابل تغییر** دیگه مانند تاپل‌های خالی هم میشه. از اونجایی که لیست‌ها قابل تغییرند، عبارت `[] is []` مقدار `False` رو برمیگردونه و عبارت `() is ()` مقدار `True` رو برمیگردونه. به همین دلیله که قطعه کد دوم چنین رفتاری داره. بریم سراغ سومی. -**Both `a` and `b` refer to the same object when initialized with same value in the same line.** +**متغیرهای `a` و `b` وقتی در یک خط با مقادیر یکسانی مقداردهی میشن، هردو به یک شیء در حافظه اشاره میکنن** -**Output** +**خروجی** ```py >>> a, b = 257, 257 @@ -600,9 +600,9 @@ Similar optimization applies to other **immutable** objects like empty tuples as 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. +* وقتی a و b در یک خط با `257` مقداردهی میشن، مفسر پایتون یک شیء برای یکی از متغیرها در حافظه میسازه و متغیر دوم رو در حافظه به اون ارجاع میده. اگه این کار رو تو دو خط جدا از هم انجام بدید، درواقع مفسر پایتون از وجود مقدار `257` به عنوان یک شیء، "خبر نداره". -* 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, +* این یک بهینه سازی توسط کامپایلر هست و مخصوصا در محیط تعاملی به کار برده میشه. وقتی شما دو خط رو در یک مفسر زنده وارد می‌کنید، اون‌ها به صورت جداگانه کامپایل میشن، به همین دلیل بهینه سازی به صورت جداگانه برای هرکدوم اعمال میشه. اگر بخواهید این مثال رو در یک فایل `.py` امتحان کنید، رفتار متفاوتی می‌بینید زیرا فایل به صورت کلی و یک‌جا کامپایل میشه. این بهینه سازی محدود به اعداد صحیح نیست و برای انواع داده‌های غیرقابل تغییر دیگه مانند رشته‌ها (مثال "رشته‌ها می‌توانند دردسرساز شوند" رو ببینید) و اعداد اعشاری هم اعمال میشه. ```py >>> a, b = 257.0, 257.0 @@ -610,12 +610,12 @@ Similar optimization applies to other **immutable** objects like empty tuples as 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](https://github.com/satwikkansal/wtfpython/issues/100) for updates. +* چرا این برای پایتون ۳.۷ کار نکرد؟ دلیل انتزاعیش اینه که چنین بهینه‌سازی‌های کامپایلری وابسته به پیاده‌سازی هستن (یعنی بسته به نسخه، و نوع سیستم‌عامل و چیزهای دیگه تغییر میکنن). من هنوز پیگیرم که بدونم که کدوم تغییر تو پیاده‌سازی باعث همچین مشکلاتی میشه، می‌تونید برای خبرهای بیشتر این [موضوع](https://github.com/satwikkansal/wtfpython/issues/100) رو نگاه کنید. --- -### ▶ Hash brownies +### ▶ کلیدهای هش 1\. ```py @@ -625,12 +625,12 @@ some_dict[5.0] = "Ruby" some_dict[5] = "Python" ``` -**Output:** +**خروجی:** ```py >>> some_dict[5.5] "JavaScript" ->>> some_dict[5.0] # "Python" destroyed the existence of "Ruby"? +>>> some_dict[5.0] # رشته ("Python")، رشته ("Ruby") رو از بین برد؟ "Python" >>> some_dict[5] "Python" @@ -642,12 +642,11 @@ complex "Python" ``` -So, why is Python all over the place? +خب، چرا Python همه جارو گرفت؟ -#### 💡 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` شیءهای متمایزی از نوع‌های متفاوتی هستند ولی از اون جایی که مقدارشون با هم برابره، نمیتونن داخل یه `dict` به عنوان کلید جدا از هم باشن (حتی به عنوان مقادیر داخل یه `set` نمیتونن باشن). وقتی بخواید داخل یه دیکشنری جست‌وجو کنید، به محض اینکه یکی از این داده‌ها رو وارد کنید، مقدار نگاشته‌شده به کلیدی که مقدار برابر با اون داده داره ولی نوعش متفاوته، با موفقیت برگردونده میشه (به جای اینکه به ارور `KeyError` بردخورد کنید.). ```py >>> 5 == 5.0 == 5 + 0j True @@ -660,7 +659,7 @@ So, why is Python all over the place? >>> (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] = "Python"` رو اجرا می‌کنید، پایتون دنبال کلیدی با مقدار یکسان می‌گرده که اینجا ما داریم `5.0 -> "Ruby"` و مقدار نگاشته‌شده به این کلید در دیکشنری رو با مقدار جدید جایگزین میکنه و کلید رو همونجوری که هست باقی میذاره. ```py >>> some_dict {5.0: 'Ruby'} @@ -668,51 +667,50 @@ So, why is Python all over the place? >>> 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. +* خب پس چطوری میتونیم مقدار خود کلید رو به `5` تغییر بدیم (جای `5.0`)؟ راستش ما نمیتونیم این کار رو درجا انجام بدیم، ولی میتونیم اول اون کلید رو پاک کنیم (`del some_dict[5.0]`) و بعد کلیدی که میخوایم رو قرار بدیم (`some_dict[5]`) تا بتونیم عدد صحیح `5` رو به جای عدد اعشاری `5.0` به عنوان کلید داخل دیکشنری داشته باشیم. درکل خیلی کم پیش میاد که بخوایم چنین کاری کنیم. -* 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](https://docs.python.org/3/reference/datamodel.html#object.__hash__) here), `5`, `5.0`, and `5 + 0j` have the same hash value. +* پایتون چطوری توی دیکشنری که کلید `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 ``` - **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](https://en.wikipedia.org/wiki/Collision_(computer_science)), and degrades the constant-time performance that hashing usually provides.) + **توجه:** برعکس این قضیه لزوما درست نیست. شیءهای میتونن هش های یکسانی داشته باشند ولی مقادیر نابرابری داشته باشند. (این باعث به وجود اومدن پدیده‌ای معروف [تصادم هش]() میشه)، در این صورت توابع هش عملکرد خودشون رو کندتر از حالت عادی انجام می‌دهند. --- -### ▶ Deep down, we're all the same. +### ▶ در عمق وجود همه ما یکسان هستیم ```py class WTF: pass ``` -**Output:** +**خروجی:** ```py ->>> WTF() == WTF() # two different instances can't be equal +>>> WTF() == WTF() # دو نمونه متفاوت از یک کلاس نمیتونند برابر هم باشند False ->>> WTF() is WTF() # identities are also different +>>> WTF() is WTF() # شناسه‌ها هم متفاوتند False ->>> hash(WTF()) == hash(WTF()) # hashes _should_ be different as well +>>> hash(WTF()) == hash(WTF()) # هش‌ها هم _باید_ متفاوت باشند 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. +#### 💡 توضیحات: +* وقتی `id` صدا زده شد، پایتون یک شیء با کلاس `WTF` ساخت و اون رو به تابع `id` داد. تابع `id` شناسه این شیء رو میگیره (درواقع آدرس اون شیء در حافظه دستگاه) و شیء رو حذف میکنه. +* وقتی این کار رو دو بار متوالی انجام بدیم، پایتون آدرس یکسانی رو به شیء دوم اختصاص میده. از اونجایی که (در CPython) تابع `id` از آدرس شیءها توی حافظه به عنوان شناسه برای اون‌ها استفاده میکنه، پس شناسه این دو شیء یکسانه. +* پس، شناسه یک شیء تا زمانی که اون شیء وجود داره، منحصربه‌فرده. بعد از اینکه اون شیء حذف میشه یا قبل از اینکه اون شیء به وجود بیاد، چیز دیگه‌ای میتونه اون شناسه رو داشته باشه. +* ولی چرا با عملگر `is` مقدار `False` رو دریافت کردیم؟ بیاید با یه قطعه‌کد ببینیم دلیلش رو. ```py class WTF(object): def __init__(self): print("I") def __del__(self): print("D") ``` - **Output:** + **خروجی:** ```py >>> WTF() is WTF() I @@ -727,11 +725,12 @@ True D True ``` - As you may observe, the order in which the objects are destroyed is what made all the difference here. + همونطور که مشاهده می‌کنید، ترتیب حذف شدن شیءها باعث تفاوت میشه. --- -### ▶ Disorder within order * + +### ▶ بی‌نظمی در خود نظم * ```py from collections import OrderedDict @@ -747,36 +746,36 @@ another_ordered_dict[2] = 'b'; another_ordered_dict[1] = 'a'; class DictWithHash(dict): """ - A dict that also implements __hash__ magic. + یک dict که تابع جادویی __hash__ هم توش پیاده شده. """ __hash__ = lambda self: 0 class OrderedDictWithHash(OrderedDict): """ - An OrderedDict that also implements __hash__ magic. + یک OrderedDict که تابع جادویی __hash__ هم توش پیاده شده. """ __hash__ = lambda self: 0 ``` -**Output** +**خروجی** ```py ->>> dictionary == ordered_dict # If a == b +>>> dictionary == ordered_dict # اگر مقدار اولی با دومی برابره True ->>> dictionary == another_ordered_dict # and b == c +>>> dictionary == another_ordered_dict # و مقدار اولی با سومی برابره True ->>> ordered_dict == another_ordered_dict # then why isn't c == a ?? +>>> ordered_dict == another_ordered_dict # پس چرا مقدار دومی با سومی برابر نیست؟ 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 "", line 1, in TypeError: unhashable type: 'dict' -# Makes sense since dict don't have __hash__ implemented, let's use -# our wrapper classes. +# منطقیه چون dict ها __hash__ توشون پیاده‌سازی نشده. پس بیاید از +# کلاس‌هایی که خودمون درست کردیم استفاده کنیم. >>> dictionary = DictWithHash() >>> dictionary[1] = 'a'; dictionary[2] = 'b'; >>> ordered_dict = OrderedDictWithHash() @@ -785,22 +784,21 @@ TypeError: unhashable type: 'dict' >>> 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 +>>> len({ordered_dict, another_ordered_dict, dictionary}) # ترتیب رو عوض می‌کنیم 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](https://docs.python.org/3/library/collections.html#ordereddict-objects) - - > 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, - ```py +- دلیل اینکه این مقایسه بین متغیرهای `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) # these are the mapping objects from the snippets above + >>> some_set.add(dictionary) # این شیء‌ها از قطعه‌کدهای بالا هستند. >>> ordered_dict in some_set True >>> some_set.add(ordered_dict) @@ -825,11 +823,13 @@ What is going on here? >>> 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`. + + پس بی‌ثباتی تو این رفتار به خاطر اینه که مقدار `another_ordered_dict in another_set` برابر با `False` هست چون `ordered_dict` از قبل داخل `another_set` هست و همونطور که قبلا مشاهده کردید، مقدار `ordered_dict == another_ordered_dict` برابر با `False` هست. --- -### ▶ Keep trying... * + +### ▶ تلاش کن... * ```py def some_func(): @@ -845,13 +845,14 @@ def another_func(): finally: print("Finally!") -def one_more_func(): # A gotcha! +def one_more_func(): 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) @@ -860,7 +861,7 @@ def one_more_func(): # A gotcha! print("Zero division error occurred", e) ``` -**Output:** +**خروجی:** ```py >>> some_func() @@ -881,16 +882,16 @@ 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. +- وقتی یک عبارت `return`، `break` یا `continue` داخل بخش `try` از یک عبارت "try...finally" اجرا میشه، بخش `fianlly` هم هنگام خارج شدن اجرا میشه. +- مقدار بازگشتی یک تابع از طریق آخرین عبارت `return` که داخل تابع اجرا میشه، مشخص میشه. از اونجایی که بخش `finally` همیشه اجرا میشه، عبارت `return` که داخل بخش `finally` هست آخرین عبارتیه که اجرا میشه. +- نکته اینجاست که اگه بخش داخل بخش `finally` یک عبارت `return` یا `break` اجرا بشه، `exception` موقتی که ذخیره شده، رها میشه. --- -### ▶ For what? +### ▶ برای چی؟ ```py some_string = "wtf" @@ -899,27 +900,26 @@ for i, some_dict[i] in enumerate(some_string): i = 10 ``` -**Output:** +**خروجی:** ```py ->>> some_dict # An indexed dict appears. +>>> some_dict # یک دیکشنری مرتب‌شده نمایان میشه. {0: 'w', 1: 't', 2: 'f'} ``` -#### 💡 Explanation: - -* A `for` statement is defined in the [Python grammar](https://docs.python.org/3/reference/grammar.html) as: +#### 💡 توضیحات: +* یک حلقه `for` در [گرامر پایتون](https://docs.python.org/3/reference/grammar.html) این طور تعریف میشه: ``` 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: + به طوری که `exprlist` یک هدف برای مقداردهیه. این یعنی، معادل عبارت `{exprlist} = {next_value}` **برای هر شیء داخل `testlist` اجرا می‌شود**. + یک مثال جالب برای نشون دادن این تعریف: ```py for i in range(4): print(i) i = 10 ``` - **Output:** + **خروجی:** ``` 0 1 @@ -927,13 +927,13 @@ for i, some_dict[i] in enumerate(some_string): 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). + - عبارت مقداردهی `i = 10` به خاطر نحوه کار کردن حلقه‌ها، هیچوقت باعث تغییر در تکرار حلقه نمیشه. قبل از شروع هر تکرار، مقدار بعدی که توسط شیء قابل تکرار (که در اینجا `range(4)` است) ارائه میشه، از بسته خارج میشه و به متغیرهای لیست هدف (که در اینجا `i` است) مقداردهی میشه. -* 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: +* تابع `enumerate(some_string)`، یک متغیر `i` (که یک شمارنده اقزایشی است) و یک حرف از حروف رشته `some_string` رو در هر تکرار برمیگردونه. و بعدش برای کلید `i` (تازه مقداردهی‌شده) در دیکشنری `some_dict`، مقدار اون حرف رو تنظیم می‌کنه. بازشده این حلقه می‌تونه مانند مثال زیر ساده بشه: ```py >>> i, some_dict[i] = (0, 'w') >>> i, some_dict[i] = (1, 't') @@ -943,20 +943,20 @@ for i, some_dict[i] in enumerate(some_string): --- -### ▶ Evaluation time discrepancy +### ▶ اختلاف زمانی در محاسبه 1\. ```py array = [1, 8, 15] -# A typical generator expression +# یک عبارت تولیدکننده عادی gen = (x for x in array if array.count(x) > 0) array = [2, 8, 22] ``` -**Output:** +**خروجی:** ```py ->>> print(list(gen)) # Where did the other values go? +>>> print(list(gen)) # پس بقیه مقدارها کجا رفتن؟ [8] ``` @@ -972,7 +972,7 @@ gen_2 = (x for x in array_2) array_2[:] = [1,2,3,4,5] ``` -**Output:** +**خروجی:** ```py >>> print(list(gen_1)) [1, 2, 3, 4] @@ -992,27 +992,27 @@ array_3 = [4, 5, 6] array_4 = [400, 500, 600] ``` -**Output:** +**خروجی:** ```py >>> print(list(gen)) [401, 501, 601, 402, 502, 602, 403, 503, 603] ``` -#### 💡 Explanation +#### 💡 توضیحات -- In a [generator](https://wiki.python.org/moin/Generators) 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](https://www.python.org/dev/peps/pep-0289/#the-details) - - > Only the outermost for-expression is evaluated immediately, the other expressions are deferred until the generator is run. +- در یک عبارت [تولیدکننده](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` بلافاصله محاسبه میشه و باقی عبارت‌ها به تعویق انداخته میشن تا زمانی که تولیدکننده اجرا بشه. --- -### ▶ `is not ...` is not `is (not ...)` +### ▶ هر گردی، گردو نیست ```py >>> 'something' is not None @@ -1021,25 +1021,25 @@ True 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`. +#### 💡 توضیحات +- عملگر `is not` یک عملگر باینری واحده و رفتارش متفاوت تر از استفاده `is` و `not` به صورت جداگانه‌ست. +- عملگر `is not` مقدار `False` رو برمیگردونه اگر متغیرها در هردو سمت این عملگر به شیء یکسانی اشاره کنند و درغیر این صورت، مقدار `True` برمیگردونه +- در مثال بالا، عبارت `(not None)` برابره با مقدار `True` از اونجایی که مقدار `None` در زمینه boolean به `False` تبدیل میشه. پس کل عبارت معادل عبارت `'something' is True` میشه. --- -### ▶ A tic-tac-toe where X wins in the first attempt! + +### ▶ یک بازی دوز که توش X همون اول برنده میشه! ```py -# Let's initialize a row +# بیاید یک سطر تشکیل بدیم row = [""] * 3 #row i['', '', ''] -# Let's make a board +# حالا بیاید تخته بازی رو ایجاد کنیم board = [row] * 3 ``` -**Output:** +**خروجی:** ```py >>> board @@ -1053,11 +1053,11 @@ board = [row] * 3 [['X', '', ''], ['X', '', ''], ['X', '', '']] ``` -We didn't assign three `"X"`s, did we? +ما که سه‌تا `"X"` نذاشتیم. گذاشتیم مگه؟ -#### 💡 Explanation: +#### 💡 توضیحات: -When we initialize `row` variable, this visualization explains what happens in the memory +وقتی متغیر `row` رو تشکیل میدیم، تصویر زیر نشون میده که چه اتفاقی در حافظه دستگاه میافته.

@@ -1067,7 +1067,7 @@ When we initialize `row` variable, this visualization explains what happens in t

-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`) +و وقتی متغیر `board` رو با ضرب کردن متغیر `row` تشکیل میدیم، تصویر زیر به صورت کلی نشون میده که چه اتفاقی در حافظه میافته (هر کدوم از عناصر `board[0]`، `board[1]` و `board[2]` در حافظه به لیست یکسانی به نشانی `row` اشاره میکنند).

@@ -1077,7 +1077,7 @@ And when the `board` is initialized by multiplying the `row`, this is what happe

-We can avoid this scenario here by not using `row` variable to generate `board`. (Asked in [this](https://github.com/satwikkansal/wtfpython/issues/68) issue). +ما می‌تونیم با استفاده نکردن از متغیر `row` برای تولید متغیر `board` از این سناریو پرهیز کنیم. (در [این](https://github.com/satwikkansal/wtfpython/issues/68) موضوع پرسیده شده). ```py >>> board = [['']*3 for _ in range(3)] @@ -1088,7 +1088,8 @@ We can avoid this scenario here by not using `row` variable to generate `board`. --- -### ▶ Schrödinger's variable * + +### ▶ متغیر شرودینگر * @@ -1104,7 +1105,7 @@ for x in range(7): funcs_results = [func() for func in funcs] ``` -**Output (Python version):** +**خروجی:** ```py >>> results [0, 1, 2, 3, 4, 5, 6] @@ -1112,7 +1113,7 @@ funcs_results = [func() for func in funcs] [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. +مقدار `x` در هر تکرار حلقه قبل از اضافه کردن `some_func` به لیست `funcs` متفاوت بود، ولی همه توابع در خارج از حلقه مقدار `6` رو برمیگردونند. 2. @@ -1122,14 +1123,16 @@ The values of `x` were different in every iteration prior to appending `some_fun [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: +#### 💡 توضیحات: +* وقتی یک تابع رو در داخل یک حلقه تعریف می‌کنیم که در بدنه‌اش از متغیر اون حلقه استفاده شده، بست این تابع به *متغیر* وصله، نه *مقدار* اون. تابع به جای اینکه از مقدار `x` در زمان تعریف تابع استفاده کنه، در زمینه اطرافش دنبال `x` می‌گرده. پس همه این توابع از آخرین مقداری که به متغیر `x` مقداردهی شده برای محاسباتشون استفاده می‌کنند. ما می‌تونیم ببینیم که این توابع از متغیر `x` که در زمینه اطرافشون (*نه* از متغیر محلی) هست، استفاده می‌کنند، به این صورت: + ```py >>> 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` یک متغیر سراسریه (گلوبال)، ما می‌تونیم مقداری که توابع داخل `funcs` دنبالشون می‌گردند و برمیگردونند رو با به‌روز کردن `x` تغییر بدیم: ```py >>> x = 42 @@ -1137,7 +1140,7 @@ Since `x` is a global value, we can change the value that the `funcs` will looku [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. +* برای رسیدن به رفتار موردنظر شما می‌تونید متغیر حلقه رو به عنوان یک متغیر اسم‌دار به تابع بدید. **چرا در این صورت کار می‌کنه؟** چون اینجوری یک متغیر در دامنه خود تابع تعریف میشه. تابع دیگه دنبال مقدار `x` در دامنه اطراف (سراسری) نمی‌گرده ولی یک متغیر محلی برای ذخیره کردن مقدار `x` در اون لحظه می‌سازه. ```py funcs = [] @@ -1147,7 +1150,7 @@ for x in range(7): funcs.append(some_func) ``` -**Output:** +**خروجی:** ```py >>> funcs_results = [func() for func in funcs] @@ -1155,7 +1158,7 @@ for x in range(7): [0, 1, 2, 3, 4, 5, 6] ``` -It is not longer using the `x` in the global scope: +دیگه از متغیر `x` در دامنه سراسری استفاده نمی‌کنه: ```py >>> inspect.getclosurevars(funcs[0]) @@ -1164,7 +1167,8 @@ ClosureVars(nonlocals={}, globals={}, builtins={}, unbound=set()) --- -### ▶ The chicken-egg problem * + +### ▶ اول مرغ بوده یا تخم مرغ؟ * 1\. ```py @@ -1176,7 +1180,7 @@ True True ``` -So which is the "ultimate" base class? There's more to the confusion by the way, +پس کدوم کلاس پایه "نهایی" هست؟ راستی سردرگمی بیشتری هم تو راهه. 2\. @@ -1202,21 +1206,23 @@ False ``` -#### 💡 Explanation +#### 💡 توضیحات -- `type` is a [metaclass](https://realpython.com/python-metaclasses/) 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. +- در پایتون، `type` یک [متاکلاس](https://realpython.com/python-metaclasses/) است. +- در پایتون **همه چیز** یک `object` است، که کلاس‌ها و همچنین نمونه‌هاشون (یا همان instance های کلاس‌ها) هم شامل این موضوع میشن. +- کلاس `type` یک متاکلاسه برای کلاس `object` و همه کلاس‌ها (همچنین کلاس `type`) به صورت مستقیم یا غیرمستقیم از کلاس `object` ارث بری کرده است. +- هیچ کلاس پایه واقعی بین کلاس‌های `object` و `type` وجود نداره. سردرگمی که در قطعه‌کدهای بالا به وجود اومده، به خاطر اینه که ما به این روابط (یعنی `issubclass` و `isinstance`) از دیدگاه کلاس‌های پایتون فکر می‌کنیم. رابطه بین `object` و `type` رو در پایتون خالص نمیشه بازتولید کرد. برای اینکه دقیق‌تر باشیم، رابطه‌های زیر در پایتون خالص نمی‌تونند بازتولید بشن. + + کلاس A یک نمونه از کلاس B، و کلاس B یک نمونه از کلاس A باشه. + + کلاس A یک نمونه از خودش باشه. +- +- این روابط بین `object` و `type` (که هردو نمونه یکدیگه و همچنین خودشون باشند) به خاطر "تقلب" در مرحله پیاده‌سازی، وجود دارند. --- -### ▶ Subclass relationships + +### ▶ روابط بین زیرمجموعه کلاس‌ها -**Output:** +**خروجی:** ```py >>> from collections.abc import Hashable >>> issubclass(list, object) @@ -1227,14 +1233,14 @@ True 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`) +ما انتظار داشتیم که روابط بین زیرکلاس‌ها، انتقالی باشند، درسته؟ (یعنی اگه `A` زیرکلاس `B` باشه و `B` هم زیرکلاس `C` باشه، کلس `A` __باید__ زیرکلاس `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](https://www.naftaliharris.com/blog/python-subclass-intransitivity/). +* روابط بین زیرکلاس‌ها در پایتون لزوما انتقالی نیستند. همه مجازند که تابع `__subclasscheck__` دلخواه خودشون رو در یک متاکلاس تعریف کنند. +* وقتی عبارت `issubclass(cls, Hashable)` اجرا میشه، برنامه دنبال یک تابع "غیر نادرست" (یا non-Falsy) در `cls` یا هرچیزی که ازش ارث‌بری می‌کنه، می‌گرده. +* از اونجایی که `object` قابل هش شدنه، ولی `list` این‌طور نیست، رابطه انتقالی شکسته میشه. +* توضیحات با جزئیات بیشتر [اینجا](https://www.naftaliharris.com/blog/python-subclass-intransitivity/) پیدا میشه. --- diff --git a/translations/fa-farsi/section1-temp.md b/translations/fa-farsi/section1-temp.md deleted file mode 100644 index 7c37b26..0000000 --- a/translations/fa-farsi/section1-temp.md +++ /dev/null @@ -1,1007 +0,0 @@ -## بخش: ذهن خود را به چالش بکشید! - -### ▶ اول از همه! * - - - - -به دلایلی، عملگر "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) قرار دارد. - -

- - - - Shows a string interning process. - -

- -+ زمانی که `"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) این طور تعریف میشه: - ``` - for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite] - ``` - به طوری که `exprlist` یک هدف برای مقداردهیه. این یعنی، معادل عبارت `{exprlist} = {next_value}` **برای هر شیء داخل `testlist` اجرا می‌شود**. - یک مثال جالب برای نشون دادن این تعریف: - ```py - for i in range(4): - print(i) - i = 10 - ``` - - **خروجی:** - ``` - 0 - 1 - 2 - 3 - ``` - - آیا انتظار داشتید که حلقه فقط یک بار اجرا بشه؟ - - **💡 توضیحات:** - - - عبارت مقداردهی `i = 10` به خاطر نحوه کار کردن حلقه‌ها، هیچوقت باعث تغییر در تکرار حلقه نمیشه. قبل از شروع هر تکرار، مقدار بعدی که توسط شیء قابل تکرار (که در اینجا `range(4)` است) ارائه میشه، از بسته خارج میشه و به متغیرهای لیست هدف (که در اینجا `i` است) مقداردهی میشه. - -* تابع `enumerate(some_string)`، یک متغیر `i` (که یک شمارنده اقزایشی است) و یک حرف از حروف رشته `some_string` رو در هر تکرار برمیگردونه. و بعدش برای کلید `i` (تازه مقداردهی‌شده) در دیکشنری `some_dict`، مقدار اون حرف رو تنظیم می‌کنه. بازشده این حلقه می‌تونه مانند مثال زیر ساده بشه: - ```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` رو تشکیل میدیم، تصویر زیر نشون میده که چه اتفاقی در حافظه دستگاه میافته. - -

- - - - Shows a memory segment after row is initialized. - -

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

- - - - Shows a memory segment after board is initialized. - -

- -ما می‌تونیم با استفاده نکردن از متغیر `row` برای تولید متغیر `board` از این سناریو پرهیز کنیم. (در [این](https://github.com/satwikkansal/wtfpython/issues/68) موضوع پرسیده شده). - -```py ->>> board = [['']*3 for _ in range(3)] ->>> board[0][0] = "X" ->>> board -[['X', '', ''], ['', '', ''], ['', '', '']] -``` - ---- - - -### ▶ متغیر شرودینگر * - - - -```py -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] -``` - -**خروجی:** -```py ->>> results -[0, 1, 2, 3, 4, 5, 6] ->>> funcs_results -[6, 6, 6, 6, 6, 6, 6] -``` - -مقدار `x` در هر تکرار حلقه قبل از اضافه کردن `some_func` به لیست `funcs` متفاوت بود، ولی همه توابع در خارج از حلقه مقدار `6` رو برمیگردونند. - -2. - -```py ->>> powers_of_x = [lambda x: x**i for i in range(10)] ->>> [f(2) for f in powers_of_x] -[512, 512, 512, 512, 512, 512, 512, 512, 512, 512] -``` - -#### 💡 توضیحات: -* وقتی یک تابع رو در داخل یک حلقه تعریف می‌کنیم که در بدنه‌اش از متغیر اون حلقه استفاده شده، بست این تابع به *متغیر* وصله، نه *مقدار* اون. تابع به جای اینکه از مقدار `x` در زمان تعریف تابع استفاده کنه، در زمینه اطرافش دنبال `x` می‌گرده. پس همه این توابع از آخرین مقداری که به متغیر `x` مقداردهی شده برای محاسباتشون استفاده می‌کنند. ما می‌تونیم ببینیم که این توابع از متغیر `x` که در زمینه اطرافشون (*نه* از متغیر محلی) هست، استفاده می‌کنند، به این صورت: - -```py ->>> import inspect ->>> inspect.getclosurevars(funcs[0]) -ClosureVars(nonlocals={}, globals={'x': 6}, builtins={}, unbound=set()) -``` - -از اونجایی که `x` یک متغیر سراسریه (گلوبال)، ما می‌تونیم مقداری که توابع داخل `funcs` دنبالشون می‌گردند و برمیگردونند رو با به‌روز کردن `x` تغییر بدیم: - -```py ->>> x = 42 ->>> [func() for func in funcs] -[42, 42, 42, 42, 42, 42, 42] -``` - -* برای رسیدن به رفتار موردنظر شما می‌تونید متغیر حلقه رو به عنوان یک متغیر اسم‌دار به تابع بدید. **چرا در این صورت کار می‌کنه؟** چون اینجوری یک متغیر در دامنه خود تابع تعریف میشه. تابع دیگه دنبال مقدار `x` در دامنه اطراف (سراسری) نمی‌گرده ولی یک متغیر محلی برای ذخیره کردن مقدار `x` در اون لحظه می‌سازه. - -```py -funcs = [] -for x in range(7): - def some_func(x=x): - return x - funcs.append(some_func) -``` - -**خروجی:** - -```py ->>> funcs_results = [func() for func in funcs] ->>> funcs_results -[0, 1, 2, 3, 4, 5, 6] -``` - -دیگه از متغیر `x` در دامنه سراسری استفاده نمی‌کنه: - -```py ->>> inspect.getclosurevars(funcs[0]) -ClosureVars(nonlocals={}, globals={}, builtins={}, unbound=set()) -``` - ---- - - -### ▶ اول مرغ بوده یا تخم مرغ؟ * - -1\. -```py ->>> isinstance(3, int) -True ->>> isinstance(type, object) -True ->>> isinstance(object, type) -True -``` - -پس کدوم کلاس پایه "نهایی" هست؟ راستی سردرگمی بیشتری هم تو راهه. - -2\. - -```py ->>> class A: pass ->>> isinstance(A, A) -False ->>> isinstance(type, type) -True ->>> isinstance(object, object) -True -``` - -3\. - -```py ->>> issubclass(int, object) -True ->>> issubclass(type, object) -True ->>> issubclass(object, type) -False -``` - - -#### 💡 توضیحات - -- در پایتون، `type` یک [متاکلاس](https://realpython.com/python-metaclasses/) است. -- در پایتون **همه چیز** یک `object` است، که کلاس‌ها و همچنین نمونه‌هاشون (یا همان instance های کلاس‌ها) هم شامل این موضوع میشن. -- کلاس `type` یک متاکلاسه برای کلاس `object` و همه کلاس‌ها (همچنین کلاس `type`) به صورت مستقیم یا غیرمستقیم از کلاس `object` ارث بری کرده است. -- هیچ کلاس پایه واقعی بین کلاس‌های `object` و `type` وجود نداره. سردرگمی که در قطعه‌کدهای بالا به وجود اومده، به خاطر اینه که ما به این روابط (یعنی `issubclass` و `isinstance`) از دیدگاه کلاس‌های پایتون فکر می‌کنیم. رابطه بین `object` و `type` رو در پایتون خالص نمیشه بازتولید کرد. برای اینکه دقیق‌تر باشیم، رابطه‌های زیر در پایتون خالص نمی‌تونند بازتولید بشن. - + کلاس A یک نمونه از کلاس B، و کلاس B یک نمونه از کلاس A باشه. - + کلاس A یک نمونه از خودش باشه. -- -- این روابط بین `object` و `type` (که هردو نمونه یکدیگه و همچنین خودشون باشند) به خاطر "تقلب" در مرحله پیاده‌سازی، وجود دارند. - ---- - - -### ▶ روابط بین زیرمجموعه کلاس‌ها - -**خروجی:** -```py ->>> from collections.abc import Hashable ->>> issubclass(list, object) -True ->>> issubclass(object, Hashable) -True ->>> issubclass(list, Hashable) -False -``` - -ما انتظار داشتیم که روابط بین زیرکلاس‌ها، انتقالی باشند، درسته؟ (یعنی اگه `A` زیرکلاس `B` باشه و `B` هم زیرکلاس `C` باشه، کلس `A` __باید__ زیرکلاس `C` باشه) - -#### 💡 توضیحات: - -* روابط بین زیرکلاس‌ها در پایتون لزوما انتقالی نیستند. همه مجازند که تابع `__subclasscheck__` دلخواه خودشون رو در یک متاکلاس تعریف کنند. -* وقتی عبارت `issubclass(cls, Hashable)` اجرا میشه، برنامه دنبال یک تابع "غیر نادرست" (یا non-Falsy) در `cls` یا هرچیزی که ازش ارث‌بری می‌کنه، می‌گرده. -* از اونجایی که `object` قابل هش شدنه، ولی `list` این‌طور نیست، رابطه انتقالی شکسته میشه. -* توضیحات با جزئیات بیشتر [اینجا](https://www.naftaliharris.com/blog/python-subclass-intransitivity/) پیدا میشه. - ---- From 2fe5f3d07fa4bfe31afee0b67e4a8e98abf95bac Mon Sep 17 00:00:00 2001 From: Leo Alavi Date: Sat, 5 Apr 2025 21:02:23 +0200 Subject: [PATCH 16/33] Remove explanations from ToC --- translations/fa-farsi/README.md | 63 --------------------------------- 1 file changed, 63 deletions(-) diff --git a/translations/fa-farsi/README.md b/translations/fa-farsi/README.md index 2dbaa0c..65a2370 100644 --- a/translations/fa-farsi/README.md +++ b/translations/fa-farsi/README.md @@ -45,134 +45,71 @@ - [👀 مثال‌ها](#-مثالها) - [بخش: ذهن خود را به چالش بکشید!](#بخش-ذهن-خود-را-به-چالش-بکشید) - [▶ اول از همه! \*](#-اول-از-همه-) - - [💡 توضیحات](#-توضیحات) - [▶ بعضی وقت‌ها رشته‌ها می‌توانند دردسرساز شوند](#-بعضی-وقتها-رشتهها-میتوانند-دردسرساز-شوند) - - [💡 توضیح:](#-توضیح) - [▶ مراقب عملیات‌های زنجیره‌ای باشید](#-مراقب-عملیاتهای-زنجیرهای-باشید) - - [💡 توضیحات:](#-توضیحات-1) - [▶ چطور از عملگر `is` استفاده نکنیم](#-چطور-از-عملگر-is-استفاده-نکنیم) - - [💡 توضیحات:](#-توضیحات-2) - [▶ کلیدهای هش](#-کلیدهای-هش) - - [💡 توضیحات](#-توضیحات-3) - [▶ در عمق وجود همه ما یکسان هستیم](#-در-عمق-وجود-همه-ما-یکسان-هستیم) - - [💡 توضیحات:](#-توضیحات-4) - [▶ بی‌نظمی در خود نظم \*](#-بینظمی-در-خود-نظم-) - - [💡 توضیحات:](#-توضیحات-5) - [▶ تلاش کن... \*](#-تلاش-کن-) - - [💡 توضیحات:](#-توضیحات-6) - [▶ برای چی؟](#-برای-چی) - - [💡 توضیحات:](#-توضیحات-7) - [▶ اختلاف زمانی در محاسبه](#-اختلاف-زمانی-در-محاسبه) - - [💡 توضیحات](#-توضیحات-8) - [▶ هر گردی، گردو نیست](#-هر-گردی-گردو-نیست) - - [💡 توضیحات](#-توضیحات-9) - [▶ یک بازی دوز که توش X همون اول برنده میشه!](#-یک-بازی-دوز-که-توش-X-همون-اول-برنده-میشه) - - [💡 توضیحات:](#-توضیحات-10) - [▶ متغیر شرودینگر \*](#-متغیر-شرودینگر-) - - [💡 توضیحات:](#-توضیحات-11) - [▶ اول مرغ بوده یا تخم مرغ؟ \*](#-اول-مرغ-بوده-یا-تخم-مرغ-) - - [💡 توضیحات](#-توضیحات-12) - [▶ روابط بین زیرمجموعه کلاس‌ها](#-روابط-بین-زیرمجموعه-کلاسها) - - [💡 توضیحات:](#-توضیحات-13) - [▶ ‫ برابری و هویت متدها](#--برابری-و-هویت-متدها) - - [💡 ‫ توضیحات](#--توضیحات) - [▶ ‫ آل-ترو-یشن \*](#--آل-ترو-یشن-) - - [💡 Explanation:](#-explanation-14) - - [💡 ‫ توضیح:](#--توضیح) - [▶ ‫ رشته‌ها و بک‌اسلش‌ها](#--رشتهها-و-بکاسلشها) - - [💡 ‫ توضیح:](#--توضیح-1) - [▶ ‫ گره نیست، نَه!](#--گره-نیست-نَه) - - [💡 Explanation:](#-explanation-15) - [▶ رشته‌های نیمه سه‌نقل‌قولی](#-رشتههای-نیمه-سهنقلقولی) - - [💡 ‫ توضیح:](#--توضیح-2) - [▶ ‫ مشکل بولین ها چیست؟](#--مشکل-بولین-ها-چیست) - - [💡 ‫ توضیحات:](#--توضیحات-1) - [▶ ‫ ویژگی‌های کلاس و ویژگی‌های نمونه](#--ویژگیهای-کلاس-و-ویژگیهای-نمونه) - - [💡 ‫ توضیح:](#--توضیح-3) - [▶ yielding None](#-yielding-none) - - [💡 Explanation:](#-explanation-16) - [▶ Yielding from... return! \*](#-yielding-from-return-) - - [💡 ‫ توضیح:](#--توضیح-4) - [▶ ‫ بازتاب‌ناپذیری \*](#--بازتابناپذیری-) - - [💡 توضیحات:](#-توضیحات-1) - [▶ ‫ تغییر دادن اشیای تغییرناپذیر!](#--تغییر-دادن-اشیای-تغییرناپذیر) - - [💡 ‫ توضیحات:](#--توضیحات-2) - [▶ ‫ متغیری که از اسکوپ بیرونی ناپدید می‌شود](#--متغیری-که-از-اسکوپ-بیرونی-ناپدید-میشود) - - [💡 ‫ توضیحات:](#--توضیحات-3) - [▶ ‫ تبدیل اسرارآمیز نوع کلید](#--تبدیل-اسرارآمیز-نوع-کلید) - - [💡 ‫ توضیحات:](#--توضیحات-4) - [▶ ‫ ببینیم می‌توانید این را حدس بزنید؟](#--ببینیم-میتوانید-این-را-حدس-بزنید) - - [💡 ‫ توضیح:](#--توضیح-5) - [▶ ‫ از حد مجاز برای تبدیل رشته به عدد صحیح فراتر می‌رود](#--از-حد-مجاز-برای-تبدیل-رشته-به-عدد-صحیح-فراتر-میرود) - - [💡 ‫ توضیح:](#--توضیح-6) - [‫ بخش: شیب‌های لغزنده](#-بخش-شیبهای-لغزنده) - [▶ ‫ تغییر یک دیکشنری هنگام پیمایش روی آن](#--تغییر-یک-دیکشنری-هنگام-پیمایش-روی-آن) - - [‫ 💡 توضیح:](#--توضیح-7) - [▶ عملیات سرسختانه‌ی `del`](#-عملیات-سرسختانهی-del) - - [‫ 💡 توضیح:](#--توضیح-8) - [▶ ‫ متغیری که از حوزه خارج است](#--متغیری-که-از-حوزه-خارج-است) - - [‫ 💡 توضیح:](#--توضیح-9) - [▶ ‫ حذف المان‌های لیست در حین پیمایش](#--حذف-المانهای-لیست-در-حین-پیمایش) - - [💡 Explanation:](#-explanation-17) - [▶ ‫ زیپِ دارای اتلاف برای پیمایشگرها \*](#--زیپِ-دارای-اتلاف-برای-پیمایشگرها-) - - [‫ 💡 توضیحات:](#--توضیحات-5) - [▶ ‫ نشت کردن متغیرهای حلقه!](#--نشت-کردن-متغیرهای-حلقه) - - [💡 ‫ توضیحات:](#--توضیحات-6) - [▶ ‫ مراقب آرگومان‌های تغییرپذیر پیش‌فرض باشید!](#--مراقب-آرگومانهای-تغییرپذیر-پیشفرض-باشید) - - [💡 ‫ توضیحات:](#--توضیحات-7) - [▶ ‫ گرفتن استثناها (Exceptions)](#--گرفتن-استثناها-exceptions) - - [💡 ‫ توضیحات](#--توضیحات-8) - [▶ ‫ عملوندهای یکسان، داستانی متفاوت!](#--عملوندهای-یکسان-داستانی-متفاوت) - - [💡 ‫ توضیحات:](#--توضیحات-9) - [▶ ‫ تفکیک نام‌ها با نادیده گرفتن حوزه‌ی کلاس](#--تفکیک-نامها-با-نادیده-گرفتن-حوزهی-کلاس) - - [💡 ‫ توضیحات](#--توضیحات-10) - [▶ ‫ گرد کردن به روش بانکدار \*](#--گرد-کردن-به-روش-بانکدار-) - - [💡 ‫ توضیحات:](#--توضیحات-11) - [▶ ‫ سوزن‌هایی در انبار کاه \*](#--سوزنهایی-در-انبار-کاه-) - - [💡 ‫ توضیحات:](#--توضیحات-12) - [▶ ‫ تقسیم‌ها \*](#--تقسیمها-) - - [💡 ‫ توضیحات:](#--توضیحات-13) - [▶ واردسازی‌های عمومی \*](#-واردسازیهای-عمومی-) - - [💡 ‫ توضیحات:](#--توضیحات-14) - [▶ ‫ همه چیز مرتب شده؟ \*](#--همه-چیز-مرتب-شده-) - - [💡 ‫ توضیحات:](#--توضیحات-15) - [▶ ‫ زمان نیمه‌شب وجود ندارد؟](#--زمان-نیمهشب-وجود-ندارد) - - [💡 ‫ توضیحات:](#--توضیحات-16) - [‫ بخش: گنجینه‌های پنهان!](#-بخش-گنجینههای-پنهان) - [▶ ‫ خب پایتون، می‌توانی کاری کنی پرواز کنم؟](#--خب-پایتون-میتوانی-کاری-کنی-پرواز-کنم) - - [‫ 💡 توضیح:](#--توضیح-10) - [▶ ‫ `goto`، ولی چرا؟](#--goto-ولی-چرا) - - [‫ 💡 توضیح:](#--توضیح-11) - [▶ ‫ خودتان را آماده کنید!](#--خودتان-را-آماده-کنید) - - [‫ 💡 توضیح:](#--توضیح-12) - [▶ ‫ بیایید با «عمو زبان مهربان برای همیشه» آشنا شویم](#--بیایید-با-عمو-زبان-مهربان-برای-همیشه-آشنا-شویم) - - [‫ 💡 توضیح:](#--توضیح-13) - [▶ ‫ حتی پایتون هم می‌داند که عشق پیچیده است](#--حتی-پایتون-هم-میداند-که-عشق-پیچیده-است) - - [‫ 💡 توضیح:](#--توضیح-14) - [▶ ‫ بله، این واقعاً وجود دارد!](#--بله-این-واقعاً-وجود-دارد) - - [‫ 💡 توضیح:](#--توضیح-15) - [▶ Ellipsis \*](#-ellipsis-) - - [‫ 💡توضیح](#-توضیح) - [▶ ‫ بی‌نهایت (`Inpinity`)](#--بینهایت-inpinity) - - [‫ 💡 توضیح:](#--توضیح-16) - [▶ ‫ بیایید خرابکاری کنیم](#--بیایید-خرابکاری-کنیم) - - [‫ 💡 توضیح:](#--توضیح-17) - [‫ بخش: ظاهرها فریبنده‌اند!](#-بخش-ظاهرها-فریبندهاند) - [▶ ‫ خطوط را رد می‌کند؟](#--خطوط-را-رد-میکند) - - [‫ 💡 توضیح](#--توضیح-18) - [▶ ‫ تله‌پورت کردن](#--تلهپورت-کردن) - - [‫ 💡 توضیح:](#--توضیح-19) - [▶ ‫ خب، یک جای کار مشکوک است...](#--خب-یک-جای-کار-مشکوک-است) - - [‫ 💡 توضیح](#--توضیح-20) - [بخش: متفرقه](#بخش-متفرقه) - [‫ ▶ `+=` سریع‌تر است](#---سریعتر-است) - - [‫ 💡 توضیح:](#---توضیح) - [‫ ▶ بیایید یک رشته‌ی بزرگ بسازیم!](#--بیایید-یک-رشتهی-بزرگ-بسازیم) - - [💡 توضیحات](#-توضیحات-2) - [▶ ‫ کُند کردن جستجوها در `dict` \*](#---کُند-کردن-جستجوها-در-dict-) - - [‫ 💡 توضیح:](#---توضیح-1) - [‫ ▶ حجیم کردن دیکشنری نمونه‌ها (`instance dicts`) \*](#--حجیم-کردن-دیکشنری-نمونهها-instance-dicts-) - - [💡 توضیح:](#-توضیح-1) - [‫ ▶ موارد جزئی \*](#---موارد-جزئی-) - [‫ مشارکت](#-مشارکت) - [‫ تقدیر و تشکر](#-تقدیر-و-تشکر) From ec35d8ec141159f31a95b503454bbb7b1b776034 Mon Sep 17 00:00:00 2001 From: Leo Alavi Date: Sat, 5 Apr 2025 21:04:37 +0200 Subject: [PATCH 17/33] Remove RTL char --- translations/fa-farsi/README.md | 862 ++++++++++++++++---------------- 1 file changed, 431 insertions(+), 431 deletions(-) diff --git a/translations/fa-farsi/README.md b/translations/fa-farsi/README.md index 65a2370..376bd74 100644 --- a/translations/fa-farsi/README.md +++ b/translations/fa-farsi/README.md @@ -1181,7 +1181,7 @@ False --- -### ▶ ‫ برابری و هویت متدها +### ▶ برابری و هویت متدها 1. @@ -1199,7 +1199,7 @@ class SomeClass: pass ``` -‫ **خروجی:** +**خروجی:** ```py >>> print(SomeClass.method is SomeClass.method) True @@ -1211,8 +1211,8 @@ True True ``` -‫ با دوبار دسترسی به `classm`، یک شیء برابر دریافت می‌کنیم، اما *همان* شیء نیست؟ بیایید ببینیم -‫ چه اتفاقی برای نمونه‌های `SomeClass` می‌افتد: +با دوبار دسترسی به `classm`، یک شیء برابر دریافت می‌کنیم، اما *همان* شیء نیست؟ بیایید ببینیم +چه اتفاقی برای نمونه‌های `SomeClass` می‌افتد: 2. ```py @@ -1220,7 +1220,7 @@ o1 = SomeClass() o2 = SomeClass() ``` -‫ **خروجی:** +**خروجی:** ```py >>> print(o1.method == o2.method) False @@ -1236,41 +1236,41 @@ True True ``` -‫ دسترسی به `classm` یا `method` دو بار، اشیایی برابر اما نه *یکسان* را برای همان نمونه از `SomeClass` ایجاد می‌کند. +دسترسی به `classm` یا `method` دو بار، اشیایی برابر اما نه *یکسان* را برای همان نمونه از `SomeClass` ایجاد می‌کند. -#### 💡 ‫ توضیحات -* ‫ تابع‌ها [وصاف](https://docs.python.org/3/howto/descriptor.html) هستند. هر زمان که تابعی به عنوان یک ویژگی فراخوانی شود، وصف فعال می‌شود و یک شیء متد ایجاد می‌کند که تابع را به شیء صاحب آن ویژگی "متصل" می‌کند. اگر این متد فراخوانی شود، تابع را با ارسال ضمنی شیء متصل‌شده به عنوان اولین آرگومان صدا می‌زند (به این ترتیب است که `self` را به عنوان اولین آرگومان دریافت می‌کنیم، با وجود اینکه آن را به‌طور صریح ارسال نکرده‌ایم). +#### 💡 توضیحات +* تابع‌ها [وصاف](https://docs.python.org/3/howto/descriptor.html) هستند. هر زمان که تابعی به عنوان یک ویژگی فراخوانی شود، وصف فعال می‌شود و یک شیء متد ایجاد می‌کند که تابع را به شیء صاحب آن ویژگی "متصل" می‌کند. اگر این متد فراخوانی شود، تابع را با ارسال ضمنی شیء متصل‌شده به عنوان اولین آرگومان صدا می‌زند (به این ترتیب است که `self` را به عنوان اولین آرگومان دریافت می‌کنیم، با وجود اینکه آن را به‌طور صریح ارسال نکرده‌ایم). ```py >>> o1.method > ``` -* ‫ دسترسی به ویژگی چندین بار، هر بار یک شیء متد جدید ایجاد می‌کند! بنابراین عبارت `o1.method is o1.method` هرگز درست (truthy) نیست. با این حال، دسترسی به تابع‌ها به عنوان ویژگی‌های کلاس (و نه نمونه) متد ایجاد نمی‌کند؛ بنابراین عبارت `SomeClass.method is SomeClass.method` درست است. +* دسترسی به ویژگی چندین بار، هر بار یک شیء متد جدید ایجاد می‌کند! بنابراین عبارت `o1.method is o1.method` هرگز درست (truthy) نیست. با این حال، دسترسی به تابع‌ها به عنوان ویژگی‌های کلاس (و نه نمونه) متد ایجاد نمی‌کند؛ بنابراین عبارت `SomeClass.method is SomeClass.method` درست است. ```py >>> SomeClass.method ``` -* ‫ `classmethod` توابع را به متدهای کلاس تبدیل می‌کند. متدهای کلاس وصاف‌هایی هستند که هنگام دسترسی، یک شیء متد ایجاد می‌کنند که به *کلاس* (نوع) شیء متصل می‌شود، نه خود شیء. +* `classmethod` توابع را به متدهای کلاس تبدیل می‌کند. متدهای کلاس وصاف‌هایی هستند که هنگام دسترسی، یک شیء متد ایجاد می‌کنند که به *کلاس* (نوع) شیء متصل می‌شود، نه خود شیء. ```py >>> o1.classm > ``` -* ‫ برخلاف توابع، `classmethod`‌ها هنگام دسترسی به عنوان ویژگی‌های کلاس نیز یک شیء متد ایجاد می‌کنند (که در این حالت به خود کلاس متصل می‌شوند، نه نوع آن). بنابراین عبارت `SomeClass.classm is SomeClass.classm` نادرست (falsy) است. +* برخلاف توابع، `classmethod`‌ها هنگام دسترسی به عنوان ویژگی‌های کلاس نیز یک شیء متد ایجاد می‌کنند (که در این حالت به خود کلاس متصل می‌شوند، نه نوع آن). بنابراین عبارت `SomeClass.classm is SomeClass.classm` نادرست (falsy) است. ```py >>> SomeClass.classm > ``` -* ‫ یک شیء متد زمانی برابر در نظر گرفته می‌شود که هم تابع‌ها برابر باشند و هم شیءهای متصل‌شده یکسان باشند. بنابراین عبارت `o1.method == o1.method` درست (truthy) است، هرچند که آن‌ها در حافظه شیء یکسانی نیستند. -* ‫ `staticmethod` توابع را به یک وصف "بدون عملیات" (no-op) تبدیل می‌کند که تابع را به همان صورت بازمی‌گرداند. هیچ شیء متدی ایجاد نمی‌شود، بنابراین مقایسه با `is` نیز درست (truthy) است. +* یک شیء متد زمانی برابر در نظر گرفته می‌شود که هم تابع‌ها برابر باشند و هم شیءهای متصل‌شده یکسان باشند. بنابراین عبارت `o1.method == o1.method` درست (truthy) است، هرچند که آن‌ها در حافظه شیء یکسانی نیستند. +* `staticmethod` توابع را به یک وصف "بدون عملیات" (no-op) تبدیل می‌کند که تابع را به همان صورت بازمی‌گرداند. هیچ شیء متدی ایجاد نمی‌شود، بنابراین مقایسه با `is` نیز درست (truthy) است. ```py >>> o1.staticm >>> SomeClass.staticm ``` -* ‫ ایجاد شیءهای "متد" جدید در هر بار فراخوانی متدهای نمونه و نیاز به اصلاح آرگومان‌ها برای درج `self`، عملکرد را به شدت تحت تأثیر قرار می‌داد. +* ایجاد شیءهای "متد" جدید در هر بار فراخوانی متدهای نمونه و نیاز به اصلاح آرگومان‌ها برای درج `self`، عملکرد را به شدت تحت تأثیر قرار می‌داد. CPython 3.7 [این مشکل را حل کرد](https://bugs.python.org/issue26110) با معرفی opcodeهای جدیدی که فراخوانی متدها را بدون ایجاد شیء متد موقتی مدیریت می‌کنند. این به شرطی است که تابع دسترسی‌یافته واقعاً فراخوانی شود، بنابراین قطعه‌کدهای اینجا تحت تأثیر قرار نمی‌گیرند و همچنان متد ایجاد می‌کنند :) -### ▶ ‫ آل-ترو-یشن * +### ▶ آل-ترو-یشن * @@ -1288,11 +1288,11 @@ False True ``` -‫ چرا این تغییر درست-نادرسته؟ +چرا این تغییر درست-نادرسته؟ #### 💡 Explanation: -- ‫ پیاده‌سازی تابع `all` معادل است با +- پیاده‌سازی تابع `all` معادل است با - ```py def all(iterable): @@ -1302,15 +1302,15 @@ True return True ``` -- ‫ `all([])` مقدار `True` را برمی‌گرداند چون iterable خالی است. -- ‫ `all([[]])` مقدار `False` را برمی‌گرداند چون آرایه‌ی داده‌شده یک عنصر دارد، یعنی `[]`، و در پایتون، لیست خالی مقدار falsy دارد. -- ‫ `all([[[]]])` و نسخه‌های بازگشتی بالاتر همیشه `True` هستند. دلیلش این است که عنصر واحد آرایه‌ی داده‌شده (`[[...]]`) دیگر خالی نیست، و لیست‌هایی که دارای مقدار باشند، truthy در نظر گرفته می‌شوند. +- `all([])` مقدار `True` را برمی‌گرداند چون iterable خالی است. +- `all([[]])` مقدار `False` را برمی‌گرداند چون آرایه‌ی داده‌شده یک عنصر دارد، یعنی `[]`، و در پایتون، لیست خالی مقدار falsy دارد. +- `all([[[]]])` و نسخه‌های بازگشتی بالاتر همیشه `True` هستند. دلیلش این است که عنصر واحد آرایه‌ی داده‌شده (`[[...]]`) دیگر خالی نیست، و لیست‌هایی که دارای مقدار باشند، truthy در نظر گرفته می‌شوند. --- -### ▶ ‫ کاما‌ی شگفت‌انگیز +### ▶ کاما‌ی شگفت‌انگیز -‫ **خروجی (< 3.6):** +**خروجی (< 3.6):** ```py >>> def f(x, y,): @@ -1332,17 +1332,17 @@ SyntaxError: invalid syntax SyntaxError: invalid syntax ``` -#### 💡 ‫ توضیح: +#### 💡 توضیح: -- ‫ کامای انتهایی همیشه در لیست پارامترهای رسمی یک تابع در پایتون قانونی نیست. -- ‫ در پایتون، لیست آرگومان‌ها تا حدی با کاماهای ابتدایی و تا حدی با کاماهای انتهایی تعریف می‌شود. این تضاد باعث ایجاد موقعیت‌هایی می‌شود که در آن یک کاما در وسط گیر می‌افتد و هیچ قانونی آن را نمی‌پذیرد. -- ‫ **نکته:** مشکل کامای انتهایی در [پایتون ۳.۶ رفع شده است](https://bugs.python.org/issue9232). توضیحات در [این پست](https://bugs.python.org/issue9232#msg248399) به‌طور خلاصه کاربردهای مختلف کاماهای انتهایی در پایتون را بررسی می‌کند. +- کامای انتهایی همیشه در لیست پارامترهای رسمی یک تابع در پایتون قانونی نیست. +- در پایتون، لیست آرگومان‌ها تا حدی با کاماهای ابتدایی و تا حدی با کاماهای انتهایی تعریف می‌شود. این تضاد باعث ایجاد موقعیت‌هایی می‌شود که در آن یک کاما در وسط گیر می‌افتد و هیچ قانونی آن را نمی‌پذیرد. +- **نکته:** مشکل کامای انتهایی در [پایتون ۳.۶ رفع شده است](https://bugs.python.org/issue9232). توضیحات در [این پست](https://bugs.python.org/issue9232#msg248399) به‌طور خلاصه کاربردهای مختلف کاماهای انتهایی در پایتون را بررسی می‌کند. --- -### ▶ ‫ رشته‌ها و بک‌اسلش‌ها +### ▶ رشته‌ها و بک‌اسلش‌ها -‫ **خروجی:** +**خروجی:** ```py >>> print("\"") " @@ -1360,14 +1360,14 @@ SyntaxError: EOL while scanning string literal True ``` -#### 💡 ‫ توضیح: +#### 💡 توضیح: -- ‫ در یک رشته‌ی معمولی در پایتون، بک‌اسلش برای فرار دادن (escape) نویسه‌هایی استفاده می‌شود که ممکن است معنای خاصی داشته باشند (مانند تک‌نقل‌قول، دوتا‌نقل‌قول، و خودِ بک‌اسلش). +- در یک رشته‌ی معمولی در پایتون، بک‌اسلش برای فرار دادن (escape) نویسه‌هایی استفاده می‌شود که ممکن است معنای خاصی داشته باشند (مانند تک‌نقل‌قول، دوتا‌نقل‌قول، و خودِ بک‌اسلش). ```py >>> "wt\"f" 'wt"f' ``` -- ‫ در یک رشته‌ی خام (raw string literal) که با پیشوند `r` مشخص می‌شود، بک‌اسلش‌ها خودشان به همان شکل منتقل می‌شوند، به‌همراه رفتار فرار دادن نویسه‌ی بعدی. +- در یک رشته‌ی خام (raw string literal) که با پیشوند `r` مشخص می‌شود، بک‌اسلش‌ها خودشان به همان شکل منتقل می‌شوند، به‌همراه رفتار فرار دادن نویسه‌ی بعدی. ```py >>> r'wt\"f' == 'wt\\"f' True @@ -1379,18 +1379,18 @@ True >>> print(r"\\n") '\\n' ``` -- ‫ در یک رشته‌ی خام (raw string) که با پیشوند `r` مشخص می‌شود، بک‌اسلش‌ها خودشان به همان صورت منتقل می‌شوند، همراه با رفتاری که کاراکتر بعدی را فرار می‌دهد (escape می‌کند). +- در یک رشته‌ی خام (raw string) که با پیشوند `r` مشخص می‌شود، بک‌اسلش‌ها خودشان به همان صورت منتقل می‌شوند، همراه با رفتاری که کاراکتر بعدی را فرار می‌دهد (escape می‌کند). --- -### ▶ ‫ گره نیست، نَه! +### ▶ گره نیست، نَه! ```py x = True y = False ``` -‫ **خروجی:** +**خروجی:** ```py >>> not x == y True @@ -1403,16 +1403,16 @@ 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` صادر می‌شود. +* تقدم عملگرها بر نحوه‌ی ارزیابی یک عبارت تأثیر می‌گذارد، و در پایتون، عملگر `==` تقدم بالاتری نسبت به عملگر `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` صادر می‌شود. --- ### ▶ رشته‌های نیمه سه‌نقل‌قولی -‫ **خروجی:** +**خروجی:** ```py >>> print('wtfpython''') wtfpython @@ -1427,19 +1427,19 @@ wtfpython SyntaxError: EOF while scanning triple-quoted string literal ``` -#### 💡 ‫ توضیح: -+ ‫ پایتون از الحاق ضمنی [رشته‌های متنی](https://docs.python.org/3/reference/lexical_analysis.html#string-literal-concatenation) پشتیبانی می‌کند. برای مثال، +#### 💡 توضیح: ++ پایتون از الحاق ضمنی [رشته‌های متنی](https://docs.python.org/3/reference/lexical_analysis.html#string-literal-concatenation) پشتیبانی می‌کند. برای مثال، ``` >>> print("wtf" "python") wtfpython >>> print("wtf" "") # or "wtf""" wtf ``` -+ ‫ `'''` و `"""` نیز جداکننده‌های رشته‌ای در پایتون هستند که باعث ایجاد SyntaxError می‌شوند، چون مفسر پایتون هنگام اسکن رشته‌ای که با سه‌نقل‌قول آغاز شده، انتظار یک سه‌نقل‌قول پایانی به‌عنوان جداکننده را دارد. ++ `'''` و `"""` نیز جداکننده‌های رشته‌ای در پایتون هستند که باعث ایجاد SyntaxError می‌شوند، چون مفسر پایتون هنگام اسکن رشته‌ای که با سه‌نقل‌قول آغاز شده، انتظار یک سه‌نقل‌قول پایانی به‌عنوان جداکننده را دارد. --- -### ▶ ‫ مشکل بولین ها چیست؟ +### ▶ مشکل بولین ها چیست؟ 1\. @@ -1457,7 +1457,7 @@ for item in mixed_list: booleans_found_so_far += 1 ``` -‫ **خروجی:** +**خروجی:** ```py >>> integers_found_so_far 4 @@ -1485,7 +1485,7 @@ def tell_truth(): print("I have lost faith in truth!") ``` -‫ **خروجی (< 3.x):** +**خروجی (< 3.x):** ```py >>> tell_truth() @@ -1494,9 +1494,9 @@ I have lost faith in truth! -#### 💡 ‫ توضیحات: +#### 💡 توضیحات: -* ‫ در پایتون، `bool` زیرکلاسی از `int` است +* در پایتون، `bool` زیرکلاسی از `int` است ```py >>> issubclass(bool, int) @@ -1505,7 +1505,7 @@ I have lost faith in truth! False ``` -* ‫ و بنابراین، `True` و `False` نمونه‌هایی از `int` هستند +* و بنابراین، `True` و `False` نمونه‌هایی از `int` هستند ```py >>> isinstance(True, int) True @@ -1513,7 +1513,7 @@ I have lost faith in truth! True ``` -* ‫ مقدار عددی `True` برابر با `1` و مقدار عددی `False` برابر با `0` است. +* مقدار عددی `True` برابر با `1` و مقدار عددی `False` برابر با `0` است. ```py >>> int(True) 1 @@ -1521,15 +1521,15 @@ I have lost faith in truth! 0 ``` -* ‫ این پاسخ در StackOverflow را ببینید: [answer](https://stackoverflow.com/a/8169049/4354153) برای توضیح منطقی پشت این موضوع. +* این پاسخ در StackOverflow را ببینید: [answer](https://stackoverflow.com/a/8169049/4354153) برای توضیح منطقی پشت این موضوع. -* ‫ در ابتدا، پایتون نوع `bool` نداشت (کاربران از 0 برای false و مقادیر غیر صفر مثل 1 برای true استفاده می‌کردند). `True`، `False` و نوع `bool` در نسخه‌های 2.x اضافه شدند، اما برای سازگاری با نسخه‌های قبلی، `True` و `False` نمی‌توانستند به عنوان ثابت تعریف شوند. آن‌ها فقط متغیرهای توکار (built-in) بودند و امکان تغییر مقدارشان وجود داشت. +* در ابتدا، پایتون نوع `bool` نداشت (کاربران از 0 برای false و مقادیر غیر صفر مثل 1 برای true استفاده می‌کردند). `True`، `False` و نوع `bool` در نسخه‌های 2.x اضافه شدند، اما برای سازگاری با نسخه‌های قبلی، `True` و `False` نمی‌توانستند به عنوان ثابت تعریف شوند. آن‌ها فقط متغیرهای توکار (built-in) بودند و امکان تغییر مقدارشان وجود داشت. -* ‫ پایتون ۳ با نسخه‌های قبلی ناسازگار بود، این مشکل سرانجام رفع شد، و بنابراین قطعه‌کد آخر در نسخه‌های Python 3.x کار نخواهد کرد! +* پایتون ۳ با نسخه‌های قبلی ناسازگار بود، این مشکل سرانجام رفع شد، و بنابراین قطعه‌کد آخر در نسخه‌های Python 3.x کار نخواهد کرد! --- -### ▶ ‫ ویژگی‌های کلاس و ویژگی‌های نمونه +### ▶ ویژگی‌های کلاس و ویژگی‌های نمونه 1\. ```py @@ -1573,7 +1573,7 @@ class SomeClass: self.another_list += [x] ``` -‫ **خروجی:** +**خروجی:** ```py >>> some_obj = SomeClass(420) @@ -1592,10 +1592,10 @@ True True ``` -#### 💡 ‫ توضیح: +#### 💡 توضیح: -* ‫ متغیرهای کلاس و متغیرهای نمونه‌های کلاس درونی به‌صورت دیکشنری‌هایی از شیء کلاس مدیریت می‌شوند. اگر نام متغیری در دیکشنری کلاس جاری پیدا نشود، کلاس‌های والد برای آن جست‌وجو می‌شوند. -* ‫ عملگر `+=` شیء قابل‌تغییر (mutable) را به‌صورت درجا (in-place) تغییر می‌دهد بدون اینکه شیء جدیدی ایجاد کند. بنابراین، تغییر ویژگی یک نمونه بر نمونه‌های دیگر و همچنین ویژگی کلاس تأثیر می‌گذارد. +* متغیرهای کلاس و متغیرهای نمونه‌های کلاس درونی به‌صورت دیکشنری‌هایی از شیء کلاس مدیریت می‌شوند. اگر نام متغیری در دیکشنری کلاس جاری پیدا نشود، کلاس‌های والد برای آن جست‌وجو می‌شوند. +* عملگر `+=` شیء قابل‌تغییر (mutable) را به‌صورت درجا (in-place) تغییر می‌دهد بدون اینکه شیء جدیدی ایجاد کند. بنابراین، تغییر ویژگی یک نمونه بر نمونه‌های دیگر و همچنین ویژگی کلاس تأثیر می‌گذارد. --- @@ -1645,14 +1645,14 @@ def some_func(x): yield from range(x) ``` -‫ **خروجی (> 3.3):** +**خروجی (> 3.3):** ```py >>> list(some_func(3)) [] ``` -‫ چی شد که `"wtf"` ناپدید شد؟ آیا به خاطر اثر خاصی از `yield from` است؟ بیایید این موضوع را بررسی کنیم، +چی شد که `"wtf"` ناپدید شد؟ آیا به خاطر اثر خاصی از `yield from` است؟ بیایید این موضوع را بررسی کنیم، 2\. @@ -1665,24 +1665,24 @@ def some_func(x): yield i ``` -‫ **خروجی:** +**خروجی:** ```py >>> list(some_func(3)) [] ``` -‫ همان نتیجه، این یکی هم کار نکرد. +همان نتیجه، این یکی هم کار نکرد. -#### 💡 ‫ توضیح: +#### 💡 توضیح: -+ ‫ از پایتون نسخه ۳.۳ به بعد، امکان استفاده از عبارت `return` همراه با مقدار در داخل ژنراتورها فراهم شد (نگاه کنید به [PEP380](https://www.python.org/dev/peps/pep-0380/)). [مستندات رسمی](https://www.python.org/dev/peps/pep-0380/#enhancements-to-stopiteration) می‌گویند: ++ از پایتون نسخه ۳.۳ به بعد، امکان استفاده از عبارت `return` همراه با مقدار در داخل ژنراتورها فراهم شد (نگاه کنید به [PEP380](https://www.python.org/dev/peps/pep-0380/)). [مستندات رسمی](https://www.python.org/dev/peps/pep-0380/#enhancements-to-stopiteration) می‌گویند: -> ‫ "... `return expr` در یک ژنراتور باعث می‌شود که هنگام خروج از ژنراتور، `StopIteration(expr)` ایجاد شود." +> "... `return expr` در یک ژنراتور باعث می‌شود که هنگام خروج از ژنراتور، `StopIteration(expr)` ایجاد شود." -+ ‫ در حالت `some_func(3)`، استثنای `StopIteration` در ابتدای اجرا به دلیل وجود دستور `return` رخ می‌دهد. این استثنا به‌طور خودکار درون پوشش `list(...)` و حلقه `for` گرفته می‌شود. بنابراین، دو قطعه‌کد بالا منجر به یک لیست خالی می‌شوند. ++ در حالت `some_func(3)`، استثنای `StopIteration` در ابتدای اجرا به دلیل وجود دستور `return` رخ می‌دهد. این استثنا به‌طور خودکار درون پوشش `list(...)` و حلقه `for` گرفته می‌شود. بنابراین، دو قطعه‌کد بالا منجر به یک لیست خالی می‌شوند. -+ ‫ برای اینکه مقدار `["wtf"]` را از ژنراتور `some_func` بگیریم، باید استثنای `StopIteration` را خودمان مدیریت کنیم، ++ برای اینکه مقدار `["wtf"]` را از ژنراتور `some_func` بگیریم، باید استثنای `StopIteration` را خودمان مدیریت کنیم، ```py try: @@ -1698,7 +1698,7 @@ def some_func(x): --- -### ▶ ‫ بازتاب‌ناپذیری * +### ▶ بازتاب‌ناپذیری * @@ -1711,7 +1711,7 @@ c = float('-iNf') # این رشته‌ها نسبت به حروف بزرگ و d = float('nan') ``` -‫ **خروجی:** +**خروجی:** ```py >>> a @@ -1753,9 +1753,9 @@ True #### 💡 توضیحات: -- ‫ `'inf'` و `'nan'` رشته‌هایی خاص هستند (نسبت به حروف بزرگ و کوچک حساس نیستند) که وقتی به‌طور صریح به نوع `float` تبدیل شوند، به ترتیب برای نمایش "بی‌نهایت" ریاضی و "عدد نیست" استفاده می‌شوند. +- `'inf'` و `'nan'` رشته‌هایی خاص هستند (نسبت به حروف بزرگ و کوچک حساس نیستند) که وقتی به‌طور صریح به نوع `float` تبدیل شوند، به ترتیب برای نمایش "بی‌نهایت" ریاضی و "عدد نیست" استفاده می‌شوند. -- ‫ از آنجا که طبق استاندارد IEEE، `NaN != NaN`، پایبندی به این قانون فرض بازتاب‌پذیری (reflexivity) یک عنصر در مجموعه‌ها را در پایتون نقض می‌کند؛ یعنی اگر `x` عضوی از مجموعه‌ای مثل `list` باشد، پیاده‌سازی‌هایی مانند مقایسه، بر اساس این فرض هستند که `x == x`. به دلیل همین فرض، ابتدا هویت (identity) دو عنصر مقایسه می‌شود (چون سریع‌تر است) و فقط زمانی مقادیر مقایسه می‌شوند که هویت‌ها متفاوت باشند. قطعه‌کد زیر موضوع را روشن‌تر می‌کند، +- از آنجا که طبق استاندارد IEEE، `NaN != NaN`، پایبندی به این قانون فرض بازتاب‌پذیری (reflexivity) یک عنصر در مجموعه‌ها را در پایتون نقض می‌کند؛ یعنی اگر `x` عضوی از مجموعه‌ای مثل `list` باشد، پیاده‌سازی‌هایی مانند مقایسه، بر اساس این فرض هستند که `x == x`. به دلیل همین فرض، ابتدا هویت (identity) دو عنصر مقایسه می‌شود (چون سریع‌تر است) و فقط زمانی مقادیر مقایسه می‌شوند که هویت‌ها متفاوت باشند. قطعه‌کد زیر موضوع را روشن‌تر می‌کند، ```py >>> x = float('nan') @@ -1768,24 +1768,24 @@ True (False, False) ``` - ‫ از آنجا که هویت‌های `x` و `y` متفاوت هستند، مقادیر آن‌ها در نظر گرفته می‌شوند که آن‌ها نیز متفاوت‌اند؛ بنابراین مقایسه این بار `False` را برمی‌گرداند. + از آنجا که هویت‌های `x` و `y` متفاوت هستند، مقادیر آن‌ها در نظر گرفته می‌شوند که آن‌ها نیز متفاوت‌اند؛ بنابراین مقایسه این بار `False` را برمی‌گرداند. -- ‫ خواندنی جالب: [بازتاب‌پذیری و دیگر ارکان تمدن](https://bertrandmeyer.com/2010/02/06/reflexivity-and-other-pillars-of-civilization/) +- خواندنی جالب: [بازتاب‌پذیری و دیگر ارکان تمدن](https://bertrandmeyer.com/2010/02/06/reflexivity-and-other-pillars-of-civilization/) --- -### ▶ ‫ تغییر دادن اشیای تغییرناپذیر! +### ▶ تغییر دادن اشیای تغییرناپذیر! -‫ این موضوع ممکن است بدیهی به نظر برسد اگر با نحوه‌ی کار ارجاع‌ها در پایتون آشنا باشید. +این موضوع ممکن است بدیهی به نظر برسد اگر با نحوه‌ی کار ارجاع‌ها در پایتون آشنا باشید. ```py some_tuple = ("A", "tuple", "with", "values") another_tuple = ([1, 2], [3, 4], [5, 6]) ``` -‫ **خروجی:** +**خروجی:** ```py >>> some_tuple[2] = "change this" TypeError: 'tuple' object does not support item assignment @@ -1800,20 +1800,20 @@ TypeError: 'tuple' object does not support item assignment اما من فکر می‌کردم تاپل‌ها تغییرناپذیر هستند... -#### 💡 ‫ توضیحات: +#### 💡 توضیحات: -* ‫ نقل‌قول از https://docs.python.org/3/reference/datamodel.html +* نقل‌قول از https://docs.python.org/3/reference/datamodel.html - > ‫ دنباله‌های تغییرناپذیر - ‫ شیئی از نوع دنباله‌ی تغییرناپذیر، پس از ایجاد دیگر قابل تغییر نیست. (اگر شیء شامل ارجاع‌هایی به اشیای دیگر باشد، این اشیای دیگر ممکن است قابل تغییر باشند و تغییر کنند؛ اما مجموعه‌ی اشیایی که مستقیماً توسط یک شیء تغییرناپذیر ارجاع داده می‌شوند، نمی‌تواند تغییر کند.) + > دنباله‌های تغییرناپذیر + شیئی از نوع دنباله‌ی تغییرناپذیر، پس از ایجاد دیگر قابل تغییر نیست. (اگر شیء شامل ارجاع‌هایی به اشیای دیگر باشد، این اشیای دیگر ممکن است قابل تغییر باشند و تغییر کنند؛ اما مجموعه‌ی اشیایی که مستقیماً توسط یک شیء تغییرناپذیر ارجاع داده می‌شوند، نمی‌تواند تغییر کند.) -* ‫ عملگر `+=` لیست را به‌صورت درجا (in-place) تغییر می‌دهد. تخصیص به یک عضو کار نمی‌کند، اما زمانی که استثنا ایجاد می‌شود، عضو موردنظر پیش از آن به‌صورت درجا تغییر کرده است. -* ‫ همچنین توضیحی در [پرسش‌های متداول رسمی پایتون](https://docs.python.org/3/faq/programming.html#why-does-a-tuple-i-item-raise-an-exception-when-the-addition-works) وجود دارد. +* عملگر `+=` لیست را به‌صورت درجا (in-place) تغییر می‌دهد. تخصیص به یک عضو کار نمی‌کند، اما زمانی که استثنا ایجاد می‌شود، عضو موردنظر پیش از آن به‌صورت درجا تغییر کرده است. +* همچنین توضیحی در [پرسش‌های متداول رسمی پایتون](https://docs.python.org/3/faq/programming.html#why-does-a-tuple-i-item-raise-an-exception-when-the-addition-works) وجود دارد. --- -### ▶ ‫ متغیری که از اسکوپ بیرونی ناپدید می‌شود +### ▶ متغیری که از اسکوپ بیرونی ناپدید می‌شود ```py @@ -1827,7 +1827,7 @@ except Exception as e: **Output (Python 2.x):** ```py >>> print(e) -# ‫ چیزی چاپ نمی شود. +# چیزی چاپ نمی شود. ``` **Output (Python 3.x):** @@ -1836,17 +1836,17 @@ except Exception as e: NameError: name 'e' is not defined ``` -#### 💡 ‫ توضیحات: -* ‫ منبع: [مستندات رسمی پایتون](https://docs.python.org/3/reference/compound_stmts.html#except) +#### 💡 توضیحات: +* منبع: [مستندات رسمی پایتون](https://docs.python.org/3/reference/compound_stmts.html#except) -‫ هنگامی که یک استثنا (Exception) با استفاده از کلمه‌ی کلیدی `as` به متغیری تخصیص داده شود، این متغیر در انتهای بلاکِ `except` پاک می‌شود. این رفتار مشابه کد زیر است: +هنگامی که یک استثنا (Exception) با استفاده از کلمه‌ی کلیدی `as` به متغیری تخصیص داده شود، این متغیر در انتهای بلاکِ `except` پاک می‌شود. این رفتار مشابه کد زیر است: ```py except E as N: foo ``` - ‫ به این شکل ترجمه شده باشد: + به این شکل ترجمه شده باشد: ```py except E as N: @@ -1856,9 +1856,9 @@ NameError: name 'e' is not defined del N ``` -‫ این بدان معناست که استثنا باید به نام دیگری انتساب داده شود تا بتوان پس از پایان بند `except` به آن ارجاع داد. استثناها پاک می‌شوند چون با داشتن «ردیابی» (traceback) ضمیمه‌شده، یک چرخه‌ی مرجع (reference cycle) با قاب پشته (stack frame) تشکیل می‌دهند که باعث می‌شود تمام متغیرهای محلی (locals) در آن قاب تا زمان پاکسازی حافظه (garbage collection) باقی بمانند. +این بدان معناست که استثنا باید به نام دیگری انتساب داده شود تا بتوان پس از پایان بند `except` به آن ارجاع داد. استثناها پاک می‌شوند چون با داشتن «ردیابی» (traceback) ضمیمه‌شده، یک چرخه‌ی مرجع (reference cycle) با قاب پشته (stack frame) تشکیل می‌دهند که باعث می‌شود تمام متغیرهای محلی (locals) در آن قاب تا زمان پاکسازی حافظه (garbage collection) باقی بمانند. -* ‫ در پایتون، بندها (`clauses`) حوزه‌ی مستقل ندارند. در مثال بالا، همه‌چیز در یک حوزه‌ی واحد قرار دارد، و متغیر `e` در اثر اجرای بند `except` حذف می‌شود. این موضوع در مورد توابع صادق نیست، زیرا توابع حوزه‌های داخلی جداگانه‌ای دارند. مثال زیر این نکته را نشان می‌دهد: +* در پایتون، بندها (`clauses`) حوزه‌ی مستقل ندارند. در مثال بالا، همه‌چیز در یک حوزه‌ی واحد قرار دارد، و متغیر `e` در اثر اجرای بند `except` حذف می‌شود. این موضوع در مورد توابع صادق نیست، زیرا توابع حوزه‌های داخلی جداگانه‌ای دارند. مثال زیر این نکته را نشان می‌دهد: ```py @@ -1870,7 +1870,7 @@ NameError: name 'e' is not defined y = [5, 4, 3] ``` - ‫ **خروجی:** + **خروجی:** ```py >>> f(x) UnboundLocalError: local variable 'x' referenced before assignment @@ -1882,9 +1882,9 @@ NameError: name 'e' is not defined [5, 4, 3] ``` -* ‫ در پایتون نسخه‌ی ۲.x، نام متغیر `e` به یک نمونه از `Exception()` انتساب داده می‌شود، بنابراین وقتی سعی کنید آن را چاپ کنید، چیزی نمایش داده نمی‌شود. +* در پایتون نسخه‌ی ۲.x، نام متغیر `e` به یک نمونه از `Exception()` انتساب داده می‌شود، بنابراین وقتی سعی کنید آن را چاپ کنید، چیزی نمایش داده نمی‌شود. - ‫ **خروجی (Python 2.x):** + **خروجی (Python 2.x):** ```py >>> e Exception() @@ -1895,7 +1895,7 @@ NameError: name 'e' is not defined --- -### ▶ ‫ تبدیل اسرارآمیز نوع کلید +### ▶ تبدیل اسرارآمیز نوع کلید ```py class SomeClass(str): @@ -1904,7 +1904,7 @@ class SomeClass(str): some_dict = {'s': 42} ``` -‫ **خروجی:** +**خروجی:** ```py >>> type(list(some_dict.keys())[0]) str @@ -1916,12 +1916,12 @@ str str ``` -#### 💡 ‫ توضیحات: +#### 💡 توضیحات: -* ‫ هر دو شیء `s` و رشته‌ی `"s"` به دلیل ارث‌بری `SomeClass` از متد `__hash__` کلاس `str`، هش یکسانی دارند. -* ‫ عبارت `SomeClass("s") == "s"` به دلیل ارث‌بری `SomeClass` از متد `__eq__` کلاس `str` برابر با `True` ارزیابی می‌شود. -* ‫ از آنجا که این دو شیء هش یکسان و برابری دارند، به عنوان یک کلید مشترک در دیکشنری در نظر گرفته می‌شوند. -* ‫ برای رسیدن به رفتار دلخواه، می‌توانیم متد `__eq__` را در کلاس `SomeClass` بازتعریف کنیم. +* هر دو شیء `s` و رشته‌ی `"s"` به دلیل ارث‌بری `SomeClass` از متد `__hash__` کلاس `str`، هش یکسانی دارند. +* عبارت `SomeClass("s") == "s"` به دلیل ارث‌بری `SomeClass` از متد `__eq__` کلاس `str` برابر با `True` ارزیابی می‌شود. +* از آنجا که این دو شیء هش یکسان و برابری دارند، به عنوان یک کلید مشترک در دیکشنری در نظر گرفته می‌شوند. +* برای رسیدن به رفتار دلخواه، می‌توانیم متد `__eq__` را در کلاس `SomeClass` بازتعریف کنیم. ```py class SomeClass(str): def __eq__(self, other): @@ -1931,14 +1931,14 @@ str and super().__eq__(other) ) - # ‫ هنگامی که متد __eq__ را به‌طور دلخواه تعریف می‌کنیم، پایتون دیگر متد __hash__ را به صورت خودکار به ارث نمی‌برد، - # ‫ بنابراین باید متد __hash__ را نیز مجدداً تعریف کنیم. + # هنگامی که متد __eq__ را به‌طور دلخواه تعریف می‌کنیم، پایتون دیگر متد __hash__ را به صورت خودکار به ارث نمی‌برد، + # بنابراین باید متد __hash__ را نیز مجدداً تعریف کنیم. __hash__ = str.__hash__ some_dict = {'s':42} ``` - ‫ **خروجی:** + **خروجی:** ```py >>> s = SomeClass('s') >>> some_dict[s] = 40 @@ -1951,37 +1951,37 @@ str --- -### ▶ ‫ ببینیم می‌توانید این را حدس بزنید؟ +### ▶ ببینیم می‌توانید این را حدس بزنید؟ ```py a, b = a[b] = {}, 5 ``` -‫ **خروجی:** +**خروجی:** ```py >>> a {5: ({...}, 5)} ``` -#### 💡 ‫ توضیح: +#### 💡 توضیح: -* ‫ طبق [مرجع زبان پایتون](https://docs.python.org/3/reference/simple_stmts.html#assignment-statements)، دستورات انتساب فرم زیر را دارند: +* طبق [مرجع زبان پایتون](https://docs.python.org/3/reference/simple_stmts.html#assignment-statements)، دستورات انتساب فرم زیر را دارند: ``` (target_list "=")+ (expression_list | yield_expression) ``` و -> ‫ یک دستور انتساب ابتدا فهرست عبارت‌ها (expression list) را ارزیابی می‌کند (توجه کنید این عبارت می‌تواند یک عبارت تکی یا فهرستی از عبارت‌ها جداشده با ویرگول باشد که دومی به یک تاپل منجر می‌شود)، سپس شیء حاصل را به هریک از اهداف انتساب از **چپ به راست** تخصیص می‌دهد. +> یک دستور انتساب ابتدا فهرست عبارت‌ها (expression list) را ارزیابی می‌کند (توجه کنید این عبارت می‌تواند یک عبارت تکی یا فهرستی از عبارت‌ها جداشده با ویرگول باشد که دومی به یک تاپل منجر می‌شود)، سپس شیء حاصل را به هریک از اهداف انتساب از **چپ به راست** تخصیص می‌دهد. -* ‫ علامت `+` در `(target_list "=")+` به این معناست که می‌توان **یک یا چند** هدف انتساب داشت. در این حالت، اهداف انتساب ما `a, b` و `a[b]` هستند (توجه کنید که عبارت ارزیابی‌شده دقیقاً یکی است، که در اینجا `{}` و `5` است). +* علامت `+` در `(target_list "=")+` به این معناست که می‌توان **یک یا چند** هدف انتساب داشت. در این حالت، اهداف انتساب ما `a, b` و `a[b]` هستند (توجه کنید که عبارت ارزیابی‌شده دقیقاً یکی است، که در اینجا `{}` و `5` است). -* ‫ پس از ارزیابی عبارت، نتیجه از **چپ به راست** به اهداف انتساب داده می‌شود. در این مثال ابتدا تاپل `({}, 5)` به `a, b` باز می‌شود، بنابراین `a = {}` و `b = 5` خواهیم داشت. +* پس از ارزیابی عبارت، نتیجه از **چپ به راست** به اهداف انتساب داده می‌شود. در این مثال ابتدا تاپل `({}, 5)` به `a, b` باز می‌شود، بنابراین `a = {}` و `b = 5` خواهیم داشت. -* ‫ حالا `a` یک شیء قابل تغییر (mutable) است (`{}`). +* حالا `a` یک شیء قابل تغییر (mutable) است (`{}`). -* ‫ هدف انتساب بعدی `a[b]` است (شاید انتظار داشته باشید که اینجا خطا بگیریم زیرا پیش از این هیچ مقداری برای `a` و `b` مشخص نشده است؛ اما به یاد داشته باشید که در گام قبل به `a` مقدار `{}` و به `b` مقدار `5` دادیم). +* هدف انتساب بعدی `a[b]` است (شاید انتظار داشته باشید که اینجا خطا بگیریم زیرا پیش از این هیچ مقداری برای `a` و `b` مشخص نشده است؛ اما به یاد داشته باشید که در گام قبل به `a` مقدار `{}` و به `b` مقدار `5` دادیم). -* ‫ اکنون، کلید `5` در دیکشنری به تاپل `({}, 5)` مقداردهی می‌شود و یک مرجع دوری (Circular Reference) ایجاد می‌کند (علامت `{...}` در خروجی به همان شیئی اشاره دارد که قبلاً توسط `a` به آن ارجاع داده شده است). یک مثال ساده‌تر از مرجع دوری می‌تواند به این صورت باشد: +* اکنون، کلید `5` در دیکشنری به تاپل `({}, 5)` مقداردهی می‌شود و یک مرجع دوری (Circular Reference) ایجاد می‌کند (علامت `{...}` در خروجی به همان شیئی اشاره دارد که قبلاً توسط `a` به آن ارجاع داده شده است). یک مثال ساده‌تر از مرجع دوری می‌تواند به این صورت باشد: ```py >>> some_list = some_list[0] = [0] >>> some_list @@ -1993,15 +1993,15 @@ a, b = a[b] = {}, 5 >>> some_list[0][0][0][0][0][0] == some_list True ``` - ‫ در مثال ما نیز شرایط مشابه است (`a[b][0]` همان شیئی است که `a` به آن اشاره دارد). + در مثال ما نیز شرایط مشابه است (`a[b][0]` همان شیئی است که `a` به آن اشاره دارد). -* ‫ بنابراین برای جمع‌بندی، می‌توانید مثال بالا را به این صورت ساده کنید: +* بنابراین برای جمع‌بندی، می‌توانید مثال بالا را به این صورت ساده کنید: ```py a, b = {}, 5 a[b] = a, b ``` - ‫ و مرجع دوری به این دلیل قابل توجیه است که `a[b][0]` همان شیئی است که `a` به آن اشاره دارد. + و مرجع دوری به این دلیل قابل توجیه است که `a[b][0]` همان شیئی است که `a` به آن اشاره دارد. ```py >>> a[b][0] is a True @@ -2010,7 +2010,7 @@ a, b = a[b] = {}, 5 --- -### ▶ ‫ از حد مجاز برای تبدیل رشته به عدد صحیح فراتر می‌رود +### ▶ از حد مجاز برای تبدیل رشته به عدد صحیح فراتر می‌رود ```py >>> # Python 3.10.6 >>> int("2" * 5432) @@ -2019,7 +2019,7 @@ a, b = a[b] = {}, 5 >>> int("2" * 5432) ``` -‫ **خروجی:** +**خروجی:** ```py >>> # Python 3.10.6 222222222222222222222222222222222222222222222222222222222222222... @@ -2032,24 +2032,24 @@ ValueError: Exceeds the limit (4300) for integer string conversion: to increase the limit. ``` -#### 💡 ‫ توضیح: -‫ فراخوانی تابع `int()` در نسخه‌ی Python 3.10.6 به‌خوبی کار می‌کند اما در نسخه‌ی Python 3.10.8 منجر به خطای `ValueError` می‌شود. توجه کنید که پایتون همچنان قادر به کار با اعداد صحیح بزرگ است. این خطا تنها هنگام تبدیل اعداد صحیح به رشته یا برعکس رخ می‌دهد. +#### 💡 توضیح: +فراخوانی تابع `int()` در نسخه‌ی Python 3.10.6 به‌خوبی کار می‌کند اما در نسخه‌ی Python 3.10.8 منجر به خطای `ValueError` می‌شود. توجه کنید که پایتون همچنان قادر به کار با اعداد صحیح بزرگ است. این خطا تنها هنگام تبدیل اعداد صحیح به رشته یا برعکس رخ می‌دهد. -‫ خوشبختانه می‌توانید در صورت انتظار عبور از این حد مجاز، مقدار آن را افزایش دهید. برای انجام این کار می‌توانید از یکی از روش‌های زیر استفاده کنید: +خوشبختانه می‌توانید در صورت انتظار عبور از این حد مجاز، مقدار آن را افزایش دهید. برای انجام این کار می‌توانید از یکی از روش‌های زیر استفاده کنید: -- ‫ استفاده از فلگ خط فرمان `-X int_max_str_digits` -- ‫ تابع `set_int_max_str_digits()` از ماژول `sys` -- ‫ متغیر محیطی `PYTHONINTMAXSTRDIGITS` +- استفاده از فلگ خط فرمان `-X int_max_str_digits` +- تابع `set_int_max_str_digits()` از ماژول `sys` +- متغیر محیطی `PYTHONINTMAXSTRDIGITS` -‫ برای جزئیات بیشتر درباره‌ی تغییر مقدار پیش‌فرض این حد مجاز، [مستندات رسمی پایتون](https://docs.python.org/3/library/stdtypes.html#int-max-str-digits) را مشاهده کنید. +برای جزئیات بیشتر درباره‌ی تغییر مقدار پیش‌فرض این حد مجاز، [مستندات رسمی پایتون](https://docs.python.org/3/library/stdtypes.html#int-max-str-digits) را مشاهده کنید. --- -## ‫ بخش: شیب‌های لغزنده +## بخش: شیب‌های لغزنده -### ▶ ‫ تغییر یک دیکشنری هنگام پیمایش روی آن +### ▶ تغییر یک دیکشنری هنگام پیمایش روی آن ```py x = {0: None} @@ -2060,7 +2060,7 @@ for i in x: print(i) ``` -‫ **خروجی (پایتون 2.7تا پایتون 3.5):** +**خروجی (پایتون 2.7تا پایتون 3.5):** ``` 0 @@ -2073,15 +2073,15 @@ for i in x: 7 ``` -‫ بله، دقیقاً **هشت** مرتبه اجرا می‌شود و سپس متوقف می‌شود. +بله، دقیقاً **هشت** مرتبه اجرا می‌شود و سپس متوقف می‌شود. -#### ‫ 💡 توضیح: +#### 💡 توضیح: -- ‫ پیمایش روی یک دیکشنری در حالی که همزمان آن را ویرایش می‌کنید پشتیبانی نمی‌شود. -- ‫ هشت بار اجرا می‌شود چون در آن لحظه دیکشنری برای نگهداری کلیدهای بیشتر تغییر اندازه می‌دهد (ما هشت ورودی حذف داریم، بنابراین تغییر اندازه لازم است). این در واقع یک جزئیات پیاده‌سازی است. -- ‫ اینکه کلیدهای حذف‌شده چگونه مدیریت می‌شوند و چه زمانی تغییر اندازه اتفاق می‌افتد ممکن است در پیاده‌سازی‌های مختلف پایتون متفاوت باشد. -- ‫ بنابراین در نسخه‌های دیگر پایتون (به جز Python 2.7 - Python 3.5)، تعداد ممکن است متفاوت از ۸ باشد (اما هر چه که باشد، در هر بار اجرا یکسان خواهد بود). می‌توانید برخی مباحث پیرامون این موضوع را [اینجا](https://github.com/satwikkansal/wtfpython/issues/53) یا در این [رشته‌ی StackOverflow](https://stackoverflow.com/questions/44763802/bug-in-python-dict) مشاهده کنید. -- ‫ از نسخه‌ی Python 3.7.6 به بعد، در صورت تلاش برای انجام این کار، خطای `RuntimeError: dictionary keys changed during iteration` را دریافت خواهید کرد. +- پیمایش روی یک دیکشنری در حالی که همزمان آن را ویرایش می‌کنید پشتیبانی نمی‌شود. +- هشت بار اجرا می‌شود چون در آن لحظه دیکشنری برای نگهداری کلیدهای بیشتر تغییر اندازه می‌دهد (ما هشت ورودی حذف داریم، بنابراین تغییر اندازه لازم است). این در واقع یک جزئیات پیاده‌سازی است. +- اینکه کلیدهای حذف‌شده چگونه مدیریت می‌شوند و چه زمانی تغییر اندازه اتفاق می‌افتد ممکن است در پیاده‌سازی‌های مختلف پایتون متفاوت باشد. +- بنابراین در نسخه‌های دیگر پایتون (به جز Python 2.7 - Python 3.5)، تعداد ممکن است متفاوت از ۸ باشد (اما هر چه که باشد، در هر بار اجرا یکسان خواهد بود). می‌توانید برخی مباحث پیرامون این موضوع را [اینجا](https://github.com/satwikkansal/wtfpython/issues/53) یا در این [رشته‌ی StackOverflow](https://stackoverflow.com/questions/44763802/bug-in-python-dict) مشاهده کنید. +- از نسخه‌ی Python 3.7.6 به بعد، در صورت تلاش برای انجام این کار، خطای `RuntimeError: dictionary keys changed during iteration` را دریافت خواهید کرد. --- @@ -2095,7 +2095,7 @@ class SomeClass: print("Deleted!") ``` -‫ **خروجی:** +**خروجی:** 1\. ```py >>> x = SomeClass() @@ -2105,7 +2105,7 @@ class SomeClass: Deleted! ``` -‫ «خُب، بالاخره حذف شد.» احتمالاً حدس زده‌اید چه چیزی جلوی فراخوانی `__del__` را در اولین تلاشی که برای حذف `x` داشتیم، گرفته بود. بیایید مثال را پیچیده‌تر کنیم. +«خُب، بالاخره حذف شد.» احتمالاً حدس زده‌اید چه چیزی جلوی فراخوانی `__del__` را در اولین تلاشی که برای حذف `x` داشتیم، گرفته بود. بیایید مثال را پیچیده‌تر کنیم. 2\. ```py @@ -2120,17 +2120,17 @@ Deleted! {'__builtins__': , 'SomeClass': , '__package__': None, '__name__': '__main__', '__doc__': None} ``` -‫ «باشه، حالا حذف شد» :confused: +«باشه، حالا حذف شد» :confused: -#### ‫ 💡 توضیح: -- ‫ عبارت `del x` مستقیماً باعث فراخوانی `x.__del__()` نمی‌شود. -- ‫ وقتی به دستور `del x` می‌رسیم، پایتون نام `x` را از حوزه‌ی فعلی حذف کرده و شمارنده‌ی مراجع شیٔ‌ای که `x` به آن اشاره می‌کرد را یک واحد کاهش می‌دهد. فقط وقتی شمارنده‌ی مراجع شیٔ به صفر برسد، تابع `__del__()` فراخوانی می‌شود. -- ‫ در خروجی دوم، متد `__del__()` فراخوانی نشد چون دستور قبلی (`>>> y`) در مفسر تعاملی یک ارجاع دیگر به شیٔ ایجاد کرده بود (به صورت خاص، متغیر جادویی `_` به مقدار آخرین عبارت غیر `None` در REPL اشاره می‌کند). بنابراین مانع از رسیدن شمارنده‌ی مراجع به صفر در هنگام اجرای `del y` شد. -- ‫ فراخوانی `globals` (یا هر چیزی که نتیجه‌اش `None` نباشد) باعث می‌شود که `_` به نتیجه‌ی جدید اشاره کند و ارجاع قبلی از بین برود. حالا شمارنده‌ی مراجع به صفر می‌رسد و عبارت «Deleted!» (حذف شد!) نمایش داده می‌شود. +#### 💡 توضیح: +- عبارت `del x` مستقیماً باعث فراخوانی `x.__del__()` نمی‌شود. +- وقتی به دستور `del x` می‌رسیم، پایتون نام `x` را از حوزه‌ی فعلی حذف کرده و شمارنده‌ی مراجع شیٔ‌ای که `x` به آن اشاره می‌کرد را یک واحد کاهش می‌دهد. فقط وقتی شمارنده‌ی مراجع شیٔ به صفر برسد، تابع `__del__()` فراخوانی می‌شود. +- در خروجی دوم، متد `__del__()` فراخوانی نشد چون دستور قبلی (`>>> y`) در مفسر تعاملی یک ارجاع دیگر به شیٔ ایجاد کرده بود (به صورت خاص، متغیر جادویی `_` به مقدار آخرین عبارت غیر `None` در REPL اشاره می‌کند). بنابراین مانع از رسیدن شمارنده‌ی مراجع به صفر در هنگام اجرای `del y` شد. +- فراخوانی `globals` (یا هر چیزی که نتیجه‌اش `None` نباشد) باعث می‌شود که `_` به نتیجه‌ی جدید اشاره کند و ارجاع قبلی از بین برود. حالا شمارنده‌ی مراجع به صفر می‌رسد و عبارت «Deleted!» (حذف شد!) نمایش داده می‌شود. --- -### ▶ ‫ متغیری که از حوزه خارج است +### ▶ متغیری که از حوزه خارج است 1\. @@ -2160,7 +2160,7 @@ def another_closure_func(): return another_inner_func() ``` -‫ **خروجی:** +**خروجی:** ```py >>> some_func() 1 @@ -2173,9 +2173,9 @@ UnboundLocalError: local variable 'a' referenced before assignment UnboundLocalError: local variable 'a' referenced before assignment ``` -#### ‫ 💡 توضیح: -* ‫ وقتی در محدوده (Scope) یک تابع به متغیری مقداردهی می‌کنید، آن متغیر در همان حوزه محلی تعریف می‌شود. بنابراین `a` در تابع `another_func` تبدیل به متغیر محلی می‌شود، اما پیش‌تر در همان حوزه مقداردهی نشده است، و این باعث خطا می‌شود. -* ‫ برای تغییر متغیر سراسری `a` در تابع `another_func`، باید از کلیدواژه‌ی `global` استفاده کنیم. +#### 💡 توضیح: +* وقتی در محدوده (Scope) یک تابع به متغیری مقداردهی می‌کنید، آن متغیر در همان حوزه محلی تعریف می‌شود. بنابراین `a` در تابع `another_func` تبدیل به متغیر محلی می‌شود، اما پیش‌تر در همان حوزه مقداردهی نشده است، و این باعث خطا می‌شود. +* برای تغییر متغیر سراسری `a` در تابع `another_func`، باید از کلیدواژه‌ی `global` استفاده کنیم. ```py def another_func() global a @@ -2188,8 +2188,8 @@ UnboundLocalError: local variable 'a' referenced before assignment >>> another_func() 2 ``` -* ‫ در تابع `another_closure_func`، متغیر `a` در حوزه‌ی `another_inner_func` محلی می‌شود ولی پیش‌تر در آن حوزه مقداردهی نشده است. به همین دلیل خطا می‌دهد. -* ‫ برای تغییر متغیر حوزه‌ی بیرونی `a` در `another_inner_func`، باید از کلیدواژه‌ی `nonlocal` استفاده کنیم. دستور `nonlocal` به مفسر می‌گوید که متغیر را در نزدیک‌ترین حوزه‌ی بیرونی (به‌جز حوزه‌ی global) جستجو کند. +* در تابع `another_closure_func`، متغیر `a` در حوزه‌ی `another_inner_func` محلی می‌شود ولی پیش‌تر در آن حوزه مقداردهی نشده است. به همین دلیل خطا می‌دهد. +* برای تغییر متغیر حوزه‌ی بیرونی `a` در `another_inner_func`، باید از کلیدواژه‌ی `nonlocal` استفاده کنیم. دستور `nonlocal` به مفسر می‌گوید که متغیر را در نزدیک‌ترین حوزه‌ی بیرونی (به‌جز حوزه‌ی global) جستجو کند. ```py def another_func(): a = 1 @@ -2200,17 +2200,17 @@ UnboundLocalError: local variable 'a' referenced before assignment return another_inner_func() ``` - ‫ **خروجی:** + **خروجی:** ```py >>> another_func() 2 ``` -* ‫ کلیدواژه‌های `global` و `nonlocal` به مفسر پایتون می‌گویند که متغیر جدیدی را تعریف نکند و به جای آن در حوزه‌های بیرونی (سراسری یا میانجی) آن را بیابد. -* ‫ برای مطالعه‌ی بیشتر در مورد نحوه‌ی کار فضای نام‌ها و مکانیزم تعیین حوزه‌ها در پایتون، می‌توانید این [مقاله کوتاه ولی عالی](https://sebastianraschka.com/Articles/2014_python_scope_and_namespaces.html) را بخوانید. +* کلیدواژه‌های `global` و `nonlocal` به مفسر پایتون می‌گویند که متغیر جدیدی را تعریف نکند و به جای آن در حوزه‌های بیرونی (سراسری یا میانجی) آن را بیابد. +* برای مطالعه‌ی بیشتر در مورد نحوه‌ی کار فضای نام‌ها و مکانیزم تعیین حوزه‌ها در پایتون، می‌توانید این [مقاله کوتاه ولی عالی](https://sebastianraschka.com/Articles/2014_python_scope_and_namespaces.html) را بخوانید. --- -### ▶ ‫ حذف المان‌های لیست در حین پیمایش +### ▶ حذف المان‌های لیست در حین پیمایش ```py list_1 = [1, 2, 3, 4] @@ -2243,11 +2243,11 @@ for idx, item in enumerate(list_4): [2, 4] ``` -‫ می‌توانید حدس بزنید چرا خروجی `[2, 4]` است؟ +می‌توانید حدس بزنید چرا خروجی `[2, 4]` است؟ #### 💡 Explanation: -* ‫ هیچ‌وقت ایده‌ی خوبی نیست که شیئی را که روی آن پیمایش می‌کنید تغییر دهید. روش درست این است که روی یک کپی از آن شیء پیمایش کنید؛ در این‌جا `list_3[:]` دقیقاً همین کار را می‌کند. +* هیچ‌وقت ایده‌ی خوبی نیست که شیئی را که روی آن پیمایش می‌کنید تغییر دهید. روش درست این است که روی یک کپی از آن شیء پیمایش کنید؛ در این‌جا `list_3[:]` دقیقاً همین کار را می‌کند. ```py >>> some_list = [1, 2, 3, 4] @@ -2257,21 +2257,21 @@ for idx, item in enumerate(list_4): 139798779601192 ``` -‫ **تفاوت بین `del`، `remove` و `pop`:** -* ‫ `del var_name` فقط اتصال `var_name` را از فضای نام محلی یا سراسری حذف می‌کند (به همین دلیل است که `list_1` تحت تأثیر قرار نمی‌گیرد). -* ‫ متد `remove` اولین مقدار مطابق را حذف می‌کند، نه یک اندیس خاص را؛ اگر مقدار مورد نظر پیدا نشود، خطای `ValueError` ایجاد می‌شود. -* ‫ متد `pop` عنصری را در یک اندیس مشخص حذف کرده و آن را برمی‌گرداند؛ اگر اندیس نامعتبری مشخص شود، خطای `IndexError` ایجاد می‌شود. +**تفاوت بین `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` به طور کامل نادیده گرفته می‌شود. این اتفاق مشابه برای هر عنصر یک‌درمیان در طول پیمایش لیست رخ خواهد داد. +**چرا خروجی `[2, 4]` است؟** +- پیمایش لیست به صورت اندیس به اندیس انجام می‌شود، و هنگامی که عدد `1` را از `list_2` یا `list_4` حذف می‌کنیم، محتوای لیست به `[2, 3, 4]` تغییر می‌کند. در این حالت عناصر باقی‌مانده به سمت چپ جابه‌جا شده و جایگاهشان تغییر می‌کند؛ یعنی عدد `2` در اندیس 0 و عدد `3` در اندیس 1 قرار می‌گیرد. از آنجا که در مرحله بعدی حلقه به سراغ اندیس 1 می‌رود (که اکنون مقدار آن `3` است)، عدد `2` به طور کامل نادیده گرفته می‌شود. این اتفاق مشابه برای هر عنصر یک‌درمیان در طول پیمایش لیست رخ خواهد داد. -* ‫ برای توضیح بیشتر این مثال، این [تاپیک StackOverflow](https://stackoverflow.com/questions/45946228/what-happens-when-you-try-to-delete-a-list-element-while-iterating-over-it) را ببینید. -* ‫ همچنین برای نمونه مشابهی مربوط به دیکشنری‌ها در پایتون، این [تاپیک مفید StackOverflow](https://stackoverflow.com/questions/45877614/how-to-change-all-the-dictionary-keys-in-a-for-loop-with-d-items) را ببینید. +* برای توضیح بیشتر این مثال، این [تاپیک StackOverflow](https://stackoverflow.com/questions/45946228/what-happens-when-you-try-to-delete-a-list-element-while-iterating-over-it) را ببینید. +* همچنین برای نمونه مشابهی مربوط به دیکشنری‌ها در پایتون، این [تاپیک مفید StackOverflow](https://stackoverflow.com/questions/45877614/how-to-change-all-the-dictionary-keys-in-a-for-loop-with-d-items) را ببینید. --- -### ▶ ‫ زیپِ دارای اتلاف برای پیمایشگرها * +### ▶ زیپِ دارای اتلاف برای پیمایشگرها * ```py @@ -2288,11 +2288,11 @@ for idx, item in enumerate(list_4): >>> list(zip(numbers_iter, remaining)) [(4, 3), (5, 4), (6, 5)] ``` -‫ عنصر `3` از لیست `numbers` چه شد؟ +عنصر `3` از لیست `numbers` چه شد؟ -#### ‫ 💡 توضیحات: +#### 💡 توضیحات: -- ‫ بر اساس [مستندات](https://docs.python.org/3.3/library/functions.html#zip) پایتون، پیاده‌سازی تقریبی تابع `zip` به شکل زیر است: +- بر اساس [مستندات](https://docs.python.org/3.3/library/functions.html#zip) پایتون، پیاده‌سازی تقریبی تابع `zip` به شکل زیر است: ```py def zip(*iterables): sentinel = object() @@ -2305,9 +2305,9 @@ for idx, item in enumerate(list_4): result.append(elem) yield tuple(result) ``` -- ‫ بنابراین این تابع تعداد دلخواهی از اشیای قابل پیمایش (*iterable*) را دریافت می‌کند، و با فراخوانی تابع `next` روی آن‌ها، هر یک از عناصرشان را به لیست `result` اضافه می‌کند. این فرایند زمانی متوقف می‌شود که اولین پیمایشگر به انتها برسد. -- ‫ نکته مهم اینجاست که هر زمان یکی از پیمایشگرها به پایان برسد، عناصر موجود در لیست `result` نیز دور ریخته می‌شوند. این دقیقاً همان اتفاقی است که برای عدد `3` در `numbers_iter` رخ داد. -- ‫ روش صحیح برای انجام عملیات بالا با استفاده از تابع `zip` چنین است: +- بنابراین این تابع تعداد دلخواهی از اشیای قابل پیمایش (*iterable*) را دریافت می‌کند، و با فراخوانی تابع `next` روی آن‌ها، هر یک از عناصرشان را به لیست `result` اضافه می‌کند. این فرایند زمانی متوقف می‌شود که اولین پیمایشگر به انتها برسد. +- نکته مهم اینجاست که هر زمان یکی از پیمایشگرها به پایان برسد، عناصر موجود در لیست `result` نیز دور ریخته می‌شوند. این دقیقاً همان اتفاقی است که برای عدد `3` در `numbers_iter` رخ داد. +- روش صحیح برای انجام عملیات بالا با استفاده از تابع `zip` چنین است: ```py >>> numbers = list(range(7)) >>> numbers_iter = iter(numbers) @@ -2316,11 +2316,11 @@ for idx, item in enumerate(list_4): >>> list(zip(remaining, numbers_iter)) [(3, 3), (4, 4), (5, 5), (6, 6)] ``` - ‫ اولین آرگومانِ تابع `zip` باید پیمایشگری باشد که کمترین تعداد عنصر را دارد. + اولین آرگومانِ تابع `zip` باید پیمایشگری باشد که کمترین تعداد عنصر را دارد. --- -### ▶ ‫ نشت کردن متغیرهای حلقه! +### ▶ نشت کردن متغیرهای حلقه! 1\. ```py @@ -2330,13 +2330,13 @@ for x in range(7): print(x, ': x in global') ``` -‫ **خروجی:** +**خروجی:** ```py 6 : for x inside loop 6 : x in global ``` -‫ اما متغیر `x` هرگز خارج از محدوده (scope) حلقه `for` تعریف نشده بود... +اما متغیر `x` هرگز خارج از محدوده (scope) حلقه `for` تعریف نشده بود... 2\. ```py @@ -2348,7 +2348,7 @@ for x in range(7): print(x, ': x in global') ``` -‫ **خروجی:** +**خروجی:** ```py 6 : for x inside loop 6 : x in global @@ -2356,7 +2356,7 @@ print(x, ': x in global') 3\. -‫ **خروجی (Python 2.x):** +**خروجی (Python 2.x):** ```py >>> x = 1 >>> print([x for x in range(5)]) @@ -2365,7 +2365,7 @@ print(x, ': x in global') 4 ``` -‫ **خروجی (Python 3.x):** +**خروجی (Python 3.x):** ```py >>> x = 1 >>> print([x for x in range(5)]) @@ -2374,17 +2374,17 @@ print(x, ': x in global') 1 ``` -#### 💡 ‫ توضیحات: +#### 💡 توضیحات: -- ‫ در پایتون، حلقه‌های `for` از حوزه (*scope*) فعلی که در آن قرار دارند استفاده می‌کنند و متغیرهای تعریف‌شده در حلقه حتی بعد از اتمام حلقه نیز باقی می‌مانند. این قاعده حتی در مواردی که متغیر حلقه پیش‌تر در فضای نام سراسری (*global namespace*) تعریف شده باشد نیز صدق می‌کند؛ در چنین حالتی، متغیر موجود مجدداً به مقدار جدید متصل می‌شود. +- در پایتون، حلقه‌های `for` از حوزه (*scope*) فعلی که در آن قرار دارند استفاده می‌کنند و متغیرهای تعریف‌شده در حلقه حتی بعد از اتمام حلقه نیز باقی می‌مانند. این قاعده حتی در مواردی که متغیر حلقه پیش‌تر در فضای نام سراسری (*global namespace*) تعریف شده باشد نیز صدق می‌کند؛ در چنین حالتی، متغیر موجود مجدداً به مقدار جدید متصل می‌شود. -- ‫ تفاوت‌های موجود در خروجی مفسرهای Python 2.x و Python 3.x در مثال مربوط به «لیست‌های ادراکی» (*list comprehension*) به دلیل تغییراتی است که در مستند [«تغییرات جدید در Python 3.0»](https://docs.python.org/3/whatsnew/3.0.html) آمده است: +- تفاوت‌های موجود در خروجی مفسرهای Python 2.x و Python 3.x در مثال مربوط به «لیست‌های ادراکی» (*list comprehension*) به دلیل تغییراتی است که در مستند [«تغییرات جدید در Python 3.0»](https://docs.python.org/3/whatsnew/3.0.html) آمده است: - > ‫ «لیست‌های ادراکی دیگر فرم نحوی `[... for var in item1, item2, ...]` را پشتیبانی نمی‌کنند و به جای آن باید از `[... for var in (item1, item2, ...)]` استفاده شود. همچنین توجه داشته باشید که لیست‌های ادراکی در Python 3.x معنای متفاوتی دارند: آن‌ها از لحاظ معنایی به بیان ساده‌تر، مشابه یک عبارت تولیدکننده (*generator expression*) درون تابع `list()` هستند و در نتیجه، متغیرهای کنترل حلقه دیگر به فضای نام بیرونی نشت نمی‌کنند.» + > «لیست‌های ادراکی دیگر فرم نحوی `[... for var in item1, item2, ...]` را پشتیبانی نمی‌کنند و به جای آن باید از `[... for var in (item1, item2, ...)]` استفاده شود. همچنین توجه داشته باشید که لیست‌های ادراکی در Python 3.x معنای متفاوتی دارند: آن‌ها از لحاظ معنایی به بیان ساده‌تر، مشابه یک عبارت تولیدکننده (*generator expression*) درون تابع `list()` هستند و در نتیجه، متغیرهای کنترل حلقه دیگر به فضای نام بیرونی نشت نمی‌کنند.» --- -### ▶ ‫ مراقب آرگومان‌های تغییرپذیر پیش‌فرض باشید! +### ▶ مراقب آرگومان‌های تغییرپذیر پیش‌فرض باشید! ```py @@ -2393,7 +2393,7 @@ def some_func(default_arg=[]): return default_arg ``` -‫ **خروجی:** +**خروجی:** ```py >>> some_func() ['some_string'] @@ -2405,9 +2405,9 @@ def some_func(default_arg=[]): ['some_string', 'some_string', 'some_string'] ``` -#### 💡 ‫ توضیحات: +#### 💡 توضیحات: -- ‫ آرگومان‌های تغییرپذیر پیش‌فرض در توابع پایتون، هر بار که تابع فراخوانی می‌شود مقداردهی نمی‌شوند؛ بلکه مقداردهی آنها تنها یک بار در زمان تعریف تابع انجام می‌شود و مقدار اختصاص‌یافته به آن‌ها به عنوان مقدار پیش‌فرض برای فراخوانی‌های بعدی استفاده خواهد شد. هنگامی که به صراحت مقدار `[]` را به عنوان آرگومان به `some_func` ارسال کردیم، مقدار پیش‌فرض برای متغیر `default_arg` مورد استفاده قرار نگرفت، بنابراین تابع همان‌طور که انتظار داشتیم عمل کرد. +- آرگومان‌های تغییرپذیر پیش‌فرض در توابع پایتون، هر بار که تابع فراخوانی می‌شود مقداردهی نمی‌شوند؛ بلکه مقداردهی آنها تنها یک بار در زمان تعریف تابع انجام می‌شود و مقدار اختصاص‌یافته به آن‌ها به عنوان مقدار پیش‌فرض برای فراخوانی‌های بعدی استفاده خواهد شد. هنگامی که به صراحت مقدار `[]` را به عنوان آرگومان به `some_func` ارسال کردیم، مقدار پیش‌فرض برای متغیر `default_arg` مورد استفاده قرار نگرفت، بنابراین تابع همان‌طور که انتظار داشتیم عمل کرد. ```py def some_func(default_arg=[]): @@ -2415,7 +2415,7 @@ def some_func(default_arg=[]): return default_arg ``` - ‫ **خروجی:** + **خروجی:** ```py >>> some_func.__defaults__ # مقادیر پیشفرض این تابع را نمایش می دهد. ([],) @@ -2430,7 +2430,7 @@ def some_func(default_arg=[]): (['some_string', 'some_string'],) ``` -- ‫ یک روش رایج برای جلوگیری از باگ‌هایی که به دلیل آرگومان‌های تغییرپذیر رخ می‌دهند، این است که مقدار پیش‌فرض را `None` قرار داده و سپس درون تابع بررسی کنیم که آیا مقداری به آن آرگومان ارسال شده است یا خیر. مثال: +- یک روش رایج برای جلوگیری از باگ‌هایی که به دلیل آرگومان‌های تغییرپذیر رخ می‌دهند، این است که مقدار پیش‌فرض را `None` قرار داده و سپس درون تابع بررسی کنیم که آیا مقداری به آن آرگومان ارسال شده است یا خیر. مثال: ```py def some_func(default_arg=None): @@ -2442,31 +2442,31 @@ def some_func(default_arg=[]): --- -### ▶ ‫ گرفتن استثناها (Exceptions) +### ▶ گرفتن استثناها (Exceptions) ```py some_list = [1, 2, 3] try: - # ‫ این باید یک `IndexError` ایجاد کند + # این باید یک `IndexError` ایجاد کند print(some_list[4]) except IndexError, ValueError: print("Caught!") try: - # ‫ این باید یک `ValueError` ایجاد کند + # این باید یک `ValueError` ایجاد کند some_list.remove(4) except IndexError, ValueError: print("Caught again!") ``` -‫ **خروجی (Python 2.x):** +**خروجی (Python 2.x):** ```py Caught! ValueError: list.remove(x): x not in list ``` -‫ **خروجی (Python 3.x):** +**خروجی (Python 3.x):** ```py File "", line 3 except IndexError, ValueError: @@ -2474,7 +2474,7 @@ ValueError: list.remove(x): x not in list 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, ```py @@ -2486,12 +2486,12 @@ SyntaxError: invalid syntax print("Caught again!") print(e) ``` - ‫ **خروجی (Python 2.x):** + **خروجی (Python 2.x):** ``` Caught again! list.remove(x): x not in list ``` - ‫ **خروجی (Python 3.x):** + **خروجی (Python 3.x):** ```py File "", line 4 except (IndexError, ValueError), e: @@ -2509,7 +2509,7 @@ SyntaxError: invalid syntax print("Caught again!") print(e) ``` - ‫ **خروجی:** + **خروجی:** ``` Caught again! list.remove(x): x not in list @@ -2517,7 +2517,7 @@ SyntaxError: invalid syntax --- -### ▶ ‫ عملوندهای یکسان، داستانی متفاوت! +### ▶ عملوندهای یکسان، داستانی متفاوت! 1\. ```py @@ -2526,7 +2526,7 @@ b = a a = a + [5, 6, 7, 8] ``` -‫ **خروجی:** +**خروجی:** ```py >>> a [1, 2, 3, 4, 5, 6, 7, 8] @@ -2541,7 +2541,7 @@ b = a a += [5, 6, 7, 8] ``` -‫ **خروجی:** +**خروجی:** ```py >>> a [1, 2, 3, 4, 5, 6, 7, 8] @@ -2549,16 +2549,16 @@ a += [5, 6, 7, 8] [1, 2, 3, 4, 5, 6, 7, 8] ``` -#### 💡 ‫ توضیحات: -* ‫ عملگر `a += b` همیشه همانند `a = a + b` رفتار نمی‌کند. کلاس‌ها *ممکن است* عملگرهای *`op=`* را به گونه‌ای متفاوت پیاده‌سازی کنند، و لیست‌ها نیز چنین می‌کنند. +#### 💡 توضیحات: +* عملگر `a += b` همیشه همانند `a = a + b` رفتار نمی‌کند. کلاس‌ها *ممکن است* عملگرهای *`op=`* را به گونه‌ای متفاوت پیاده‌سازی کنند، و لیست‌ها نیز چنین می‌کنند. -* ‫ عبارت `a = a + [5,6,7,8]` یک لیست جدید ایجاد می‌کند و مرجع `a` را به این لیست جدید اختصاص می‌دهد، بدون آنکه `b` را تغییر دهد. +* عبارت `a = a + [5,6,7,8]` یک لیست جدید ایجاد می‌کند و مرجع `a` را به این لیست جدید اختصاص می‌دهد، بدون آنکه `b` را تغییر دهد. -* ‫ عبارت `a += [5,6,7,8]` در واقع به تابعی معادل «extend» ترجمه می‌شود که روی لیست اصلی عمل می‌کند؛ بنابراین `a` و `b` همچنان به همان لیست اشاره می‌کنند که به‌صورت درجا (in-place) تغییر کرده است. +* عبارت `a += [5,6,7,8]` در واقع به تابعی معادل «extend» ترجمه می‌شود که روی لیست اصلی عمل می‌کند؛ بنابراین `a` و `b` همچنان به همان لیست اشاره می‌کنند که به‌صورت درجا (in-place) تغییر کرده است. --- -### ▶ ‫ تفکیک نام‌ها با نادیده گرفتن حوزه‌ی کلاس +### ▶ تفکیک نام‌ها با نادیده گرفتن حوزه‌ی کلاس 1\. ```py @@ -2568,7 +2568,7 @@ class SomeClass: y = (x for i in range(10)) ``` -‫ **خروجی:** +**خروجی:** ```py >>> list(SomeClass.y)[0] 5 @@ -2582,28 +2582,28 @@ class SomeClass: y = [x for i in range(10)] ``` -‫ **خروجی (Python 2.x):** +**خروجی (Python 2.x):** ```py >>> SomeClass.y[0] 17 ``` -‫ **خروجی (Python 3.x):** +**خروجی (Python 3.x):** ```py >>> SomeClass.y[0] 5 ``` -#### 💡 ‫ توضیحات -- ‫ حوزه‌هایی که درون تعریف کلاس تو در تو هستند، نام‌های تعریف‌شده در سطح کلاس را نادیده می‌گیرند. -- ‫ عبارت‌های جنراتور (generator expressions) حوزه‌ی مختص به خود دارند. -- ‫ از پایتون نسخه‌ی ۳ به بعد، لیست‌های فشرده (list comprehensions) نیز حوزه‌ی مختص به خود دارند. +#### 💡 توضیحات +- حوزه‌هایی که درون تعریف کلاس تو در تو هستند، نام‌های تعریف‌شده در سطح کلاس را نادیده می‌گیرند. +- عبارت‌های جنراتور (generator expressions) حوزه‌ی مختص به خود دارند. +- از پایتون نسخه‌ی ۳ به بعد، لیست‌های فشرده (list comprehensions) نیز حوزه‌ی مختص به خود دارند. --- -### ▶ ‫ گرد کردن به روش بانکدار * +### ▶ گرد کردن به روش بانکدار * -‫ بیایید یک تابع ساده برای به‌دست‌آوردن عنصر میانی یک لیست پیاده‌سازی کنیم: +بیایید یک تابع ساده برای به‌دست‌آوردن عنصر میانی یک لیست پیاده‌سازی کنیم: ```py def get_middle(some_list): mid_index = round(len(some_list) / 2) @@ -2623,11 +2623,11 @@ def get_middle(some_list): >>> round(len([1,2,3,4,5]) / 2) # چرا? 2 ``` -‫ به نظر می‌رسد که پایتون عدد ۲٫۵ را به ۲ گرد کرده است. +به نظر می‌رسد که پایتون عدد ۲٫۵ را به ۲ گرد کرده است. -#### 💡 ‫ توضیحات: +#### 💡 توضیحات: -- ‫ این یک خطای مربوط به دقت اعداد اعشاری نیست؛ بلکه این رفتار عمدی است. از پایتون نسخه 3.0 به بعد، تابع `round()` از [گرد کردن بانکی](https://en.wikipedia.org/wiki/Rounding#Rounding_half_to_even) استفاده می‌کند که در آن کسرهای `.5` به نزدیک‌ترین عدد **زوج** گرد می‌شوند: +- این یک خطای مربوط به دقت اعداد اعشاری نیست؛ بلکه این رفتار عمدی است. از پایتون نسخه 3.0 به بعد، تابع `round()` از [گرد کردن بانکی](https://en.wikipedia.org/wiki/Rounding#Rounding_half_to_even) استفاده می‌کند که در آن کسرهای `.5` به نزدیک‌ترین عدد **زوج** گرد می‌شوند: ```py >>> round(0.5) @@ -2645,17 +2645,17 @@ def get_middle(some_list): 2.0 ``` -- ‫ این روشِ پیشنهادی برای گرد کردن کسرهای `.5` مطابق با استاندارد [IEEE 754](https://en.wikipedia.org/wiki/IEEE_754#Rounding_rules) است. با این حال، روش دیگر (گرد کردن به سمت دور از صفر) اغلب در مدارس آموزش داده می‌شود؛ بنابراین، «گرد کردن بانکی» احتمالا چندان شناخته‌شده نیست. همچنین، برخی از رایج‌ترین زبان‌های برنامه‌نویسی (مانند جاوااسکریپت، جاوا، C/C++‎، روبی و راست) نیز از گرد کردن بانکی استفاده نمی‌کنند. به همین دلیل این موضوع همچنان مختص پایتون بوده و ممکن است باعث سردرگمی هنگام گرد کردن کسرها شود. -- ‫ برای اطلاعات بیشتر به [مستندات تابع `round()`](https://docs.python.org/3/library/functions.html#round) یا [این بحث در Stack Overflow](https://stackoverflow.com/questions/10825926/python-3-x-rounding-behavior) مراجعه کنید. -- ‫ توجه داشته باشید که `get_middle([1])` فقط به این دلیل مقدار 1 را بازگرداند که اندیس آن `round(0.5) - 1 = 0 - 1 = -1` بود و در نتیجه آخرین عنصر لیست را برمی‌گرداند. +- این روشِ پیشنهادی برای گرد کردن کسرهای `.5` مطابق با استاندارد [IEEE 754](https://en.wikipedia.org/wiki/IEEE_754#Rounding_rules) است. با این حال، روش دیگر (گرد کردن به سمت دور از صفر) اغلب در مدارس آموزش داده می‌شود؛ بنابراین، «گرد کردن بانکی» احتمالا چندان شناخته‌شده نیست. همچنین، برخی از رایج‌ترین زبان‌های برنامه‌نویسی (مانند جاوااسکریپت، جاوا، C/C++‎، روبی و راست) نیز از گرد کردن بانکی استفاده نمی‌کنند. به همین دلیل این موضوع همچنان مختص پایتون بوده و ممکن است باعث سردرگمی هنگام گرد کردن کسرها شود. +- برای اطلاعات بیشتر به [مستندات تابع `round()`](https://docs.python.org/3/library/functions.html#round) یا [این بحث در Stack Overflow](https://stackoverflow.com/questions/10825926/python-3-x-rounding-behavior) مراجعه کنید. +- توجه داشته باشید که `get_middle([1])` فقط به این دلیل مقدار 1 را بازگرداند که اندیس آن `round(0.5) - 1 = 0 - 1 = -1` بود و در نتیجه آخرین عنصر لیست را برمی‌گرداند. --- -### ▶ ‫ سوزن‌هایی در انبار کاه * +### ▶ سوزن‌هایی در انبار کاه * -‫ من تا به امروز حتی یک برنامه‌نویس باتجربهٔ پایتون را ندیده‌ام که حداقل با یکی از سناریوهای زیر مواجه نشده باشد: +من تا به امروز حتی یک برنامه‌نویس باتجربهٔ پایتون را ندیده‌ام که حداقل با یکی از سناریوهای زیر مواجه نشده باشد: 1\. @@ -2663,7 +2663,7 @@ def get_middle(some_list): x, y = (0, 1) if True else None, None ``` -‫ **خروجی:** +**خروجی:** ```py >>> x, y # چیزی که توقع داریم. (0, 1) @@ -2685,7 +2685,7 @@ t = () print(t) ``` -‫ **خروجی:** +**خروجی:** ```py one @@ -2713,26 +2713,26 @@ ten_words_list = [ ] ``` -‫ **خروجی** +**خروجی** ```py >>> len(ten_words_list) 9 ``` -4\. ‫ عدم تأکید کافی +4\. عدم تأکید کافی ```py a = "python" b = "javascript" ``` -‫ **خروجی:** +**خروجی:** ```py -# ‫ دستور assert همراه با پیام خطای assertion +# دستور assert همراه با پیام خطای assertion >>> assert(a == b, "Both languages are different") -# ‫ هیچ AssertionError ای رخ نمی‌دهد +# هیچ AssertionError ای رخ نمی‌دهد ``` 5\. @@ -2749,7 +2749,7 @@ some_list = some_list.append(4) some_dict = some_dict.update({"key_4": 4}) ``` -‫ **خروجی:** +**خروجی:** ```py >>> print(some_list) @@ -2776,7 +2776,7 @@ def similar_recursive_func(a): return a ``` -‫ **خروجی:** +**خروجی:** ```py >>> some_recursive_func([5, 0]) @@ -2785,22 +2785,22 @@ def similar_recursive_func(a): 4 ``` -#### 💡 ‫ توضیحات: -* ‫ برای مورد ۱، عبارت صحیح برای رفتار مورد انتظار این است: +#### 💡 توضیحات: +* برای مورد ۱، عبارت صحیح برای رفتار مورد انتظار این است: `x, y = (0, 1) if True else (None, None)` -* ‫ برای مورد ۲، عبارت صحیح برای رفتار مورد انتظار این است: +* برای مورد ۲، عبارت صحیح برای رفتار مورد انتظار این است: ‫`t = ('one',)` یا `t = 'one',` (ویرگول از قلم افتاده است). در غیر این صورت مفسر `t` را به عنوان یک `str` در نظر گرفته و به صورت کاراکتر به کاراکتر روی آن پیمایش می‌کند. -* ‫ علامت `()` یک توکن خاص است و نشان‌دهنده‌ی یک `tuple` خالی است. +* علامت `()` یک توکن خاص است و نشان‌دهنده‌ی یک `tuple` خالی است. -* ‫ در مورد ۳، همان‌طور که احتمالاً متوجه شدید، بعد از عنصر پنجم (`"that"`) یک ویرگول از قلم افتاده است. بنابراین با الحاق ضمنی رشته‌ها، +* در مورد ۳، همان‌طور که احتمالاً متوجه شدید، بعد از عنصر پنجم (`"that"`) یک ویرگول از قلم افتاده است. بنابراین با الحاق ضمنی رشته‌ها، ```py >>> ten_words_list ['some', 'very', 'big', 'list', 'thatconsists', 'of', 'exactly', 'ten', 'words'] ``` -* ‫ در قطعه‌ی چهارم هیچ `AssertionError`ای رخ نداد؛ زیرا به جای ارزیابی عبارت تکی `a == b`، کل یک تاپل ارزیابی شده است. قطعه‌ی کد زیر این موضوع را روشن‌تر می‌کند: +* در قطعه‌ی چهارم هیچ `AssertionError`ای رخ نداد؛ زیرا به جای ارزیابی عبارت تکی `a == b`، کل یک تاپل ارزیابی شده است. قطعه‌ی کد زیر این موضوع را روشن‌تر می‌کند: ```py >>> a = "python" @@ -2819,16 +2819,16 @@ def similar_recursive_func(a): AssertionError: Values are not equal ``` -* ‫ در قطعه‌ی پنجم، بیشتر متدهایی که اشیای ترتیبی (Sequence) یا نگاشت‌ها (Mapping) را تغییر می‌دهند (مانند `list.append`، `dict.update`، `list.sort` و غیره)، شیء اصلی را به‌صورت درجا (in-place) تغییر داده و مقدار `None` برمی‌گردانند. منطق پشت این تصمیم، بهبود عملکرد با جلوگیری از کپی کردن شیء است (به این [منبع](https://docs.python.org/3/faq/design.html#why-doesn-t-list-sort-return-the-sorted-list) مراجعه کنید). +* در قطعه‌ی پنجم، بیشتر متدهایی که اشیای ترتیبی (Sequence) یا نگاشت‌ها (Mapping) را تغییر می‌دهند (مانند `list.append`، `dict.update`، `list.sort` و غیره)، شیء اصلی را به‌صورت درجا (in-place) تغییر داده و مقدار `None` برمی‌گردانند. منطق پشت این تصمیم، بهبود عملکرد با جلوگیری از کپی کردن شیء است (به این [منبع](https://docs.python.org/3/faq/design.html#why-doesn-t-list-sort-return-the-sorted-list) مراجعه کنید). -* ‫ قطعه‌ی آخر نیز نسبتاً واضح است؛ شیء تغییرپذیر (mutable)، مثل `list`، می‌تواند در داخل تابع تغییر کند، درحالی‌که انتساب دوباره‌ی یک شیء تغییرناپذیر (مانند `a -= 1`) باعث تغییر مقدار اصلی آن نخواهد شد. +* قطعه‌ی آخر نیز نسبتاً واضح است؛ شیء تغییرپذیر (mutable)، مثل `list`، می‌تواند در داخل تابع تغییر کند، درحالی‌که انتساب دوباره‌ی یک شیء تغییرناپذیر (مانند `a -= 1`) باعث تغییر مقدار اصلی آن نخواهد شد. -* ‫ آگاهی از این نکات ظریف در بلندمدت می‌تواند ساعت‌ها از زمان شما برای رفع اشکال را صرفه‌جویی کند. +* آگاهی از این نکات ظریف در بلندمدت می‌تواند ساعت‌ها از زمان شما برای رفع اشکال را صرفه‌جویی کند. --- -### ▶ ‫ تقسیم‌ها * +### ▶ تقسیم‌ها * ```py >>> 'a'.split() @@ -2847,12 +2847,12 @@ def similar_recursive_func(a): 1 ``` -#### 💡 ‫ توضیحات: +#### 💡 توضیحات: -- ‫ در نگاه اول ممکن است به نظر برسد جداکننده‌ی پیش‌فرض متد `split` یک فاصله‌ی تکی (`' '`) است؛ اما مطابق با [مستندات رسمی](https://docs.python.org/3/library/stdtypes.html#str.split): - > ‫ اگر `sep` مشخص نشده یا برابر با `None` باشد، یک الگوریتم متفاوت برای جدا کردن اعمال می‌شود: رشته‌هایی از فاصله‌های متوالی به عنوان یک جداکننده‌ی واحد در نظر گرفته شده و در نتیجه، هیچ رشته‌ی خالی‌ای در ابتدا یا انتهای لیست خروجی قرار نمی‌گیرد، حتی اگر رشته‌ی اولیه دارای فاصله‌های اضافی در ابتدا یا انتها باشد. به همین دلیل، تقسیم یک رشته‌ی خالی یا رشته‌ای که فقط شامل فضای خالی است با جداکننده‌ی `None` باعث بازگشت یک لیست خالی `[]` می‌شود. - > ‫ اگر `sep` مشخص شود، جداکننده‌های متوالی در کنار هم قرار نمی‌گیرند و هر جداکننده، یک رشته‌ی خالی جدید ایجاد می‌کند. (مثلاً `'1,,2'.split(',')` مقدار `['1', '', '2']` را برمی‌گرداند.) تقسیم یک رشته‌ی خالی با یک جداکننده‌ی مشخص‌شده نیز باعث بازگشت `['']` می‌شود. -- ‫ توجه به اینکه چگونه فضای خالی در ابتدا و انتهای رشته در قطعه‌ی کد زیر مدیریت شده است، این مفهوم را روشن‌تر می‌کند: +- در نگاه اول ممکن است به نظر برسد جداکننده‌ی پیش‌فرض متد `split` یک فاصله‌ی تکی (`' '`) است؛ اما مطابق با [مستندات رسمی](https://docs.python.org/3/library/stdtypes.html#str.split): + > اگر `sep` مشخص نشده یا برابر با `None` باشد، یک الگوریتم متفاوت برای جدا کردن اعمال می‌شود: رشته‌هایی از فاصله‌های متوالی به عنوان یک جداکننده‌ی واحد در نظر گرفته شده و در نتیجه، هیچ رشته‌ی خالی‌ای در ابتدا یا انتهای لیست خروجی قرار نمی‌گیرد، حتی اگر رشته‌ی اولیه دارای فاصله‌های اضافی در ابتدا یا انتها باشد. به همین دلیل، تقسیم یک رشته‌ی خالی یا رشته‌ای که فقط شامل فضای خالی است با جداکننده‌ی `None` باعث بازگشت یک لیست خالی `[]` می‌شود. + > اگر `sep` مشخص شود، جداکننده‌های متوالی در کنار هم قرار نمی‌گیرند و هر جداکننده، یک رشته‌ی خالی جدید ایجاد می‌کند. (مثلاً `'1,,2'.split(',')` مقدار `['1', '', '2']` را برمی‌گرداند.) تقسیم یک رشته‌ی خالی با یک جداکننده‌ی مشخص‌شده نیز باعث بازگشت `['']` می‌شود. +- توجه به اینکه چگونه فضای خالی در ابتدا و انتهای رشته در قطعه‌ی کد زیر مدیریت شده است، این مفهوم را روشن‌تر می‌کند: ```py >>> ' a '.split(' ') ['', 'a', ''] @@ -2879,7 +2879,7 @@ def _another_weird_name_func(): ``` -‫ **خروجی** +**خروجی** ```py >>> from module import * @@ -2891,16 +2891,16 @@ Traceback (most recent call last): NameError: name '_another_weird_name_func' is not defined ``` -#### 💡 ‫ توضیحات: +#### 💡 توضیحات: -- ‫ اغلب توصیه می‌شود از واردسازی عمومی (wildcard imports) استفاده نکنید. اولین دلیل واضح آن این است که در این نوع واردسازی‌ها، اسامی که با زیرخط (`_`) شروع شوند، وارد نمی‌شوند. این مسئله ممکن است در زمان اجرا به خطا منجر شود. -- ‫ اگر از ساختار `from ... import a, b, c` استفاده کنیم، خطای `NameError` فوق اتفاق نمی‌افتاد. +- اغلب توصیه می‌شود از واردسازی عمومی (wildcard imports) استفاده نکنید. اولین دلیل واضح آن این است که در این نوع واردسازی‌ها، اسامی که با زیرخط (`_`) شروع شوند، وارد نمی‌شوند. این مسئله ممکن است در زمان اجرا به خطا منجر شود. +- اگر از ساختار `from ... import a, b, c` استفاده کنیم، خطای `NameError` فوق اتفاق نمی‌افتاد. ```py >>> from module import some_weird_name_func_, _another_weird_name_func >>> _another_weird_name_func() works! ``` -- ‫ اگر واقعاً تمایل دارید از واردسازی عمومی استفاده کنید، لازم است فهرستی به نام `__all__` را در ماژول خود تعریف کنید که شامل نام اشیاء عمومی (public) قابل‌دسترس هنگام واردسازی عمومی است. +- اگر واقعاً تمایل دارید از واردسازی عمومی استفاده کنید، لازم است فهرستی به نام `__all__` را در ماژول خود تعریف کنید که شامل نام اشیاء عمومی (public) قابل‌دسترس هنگام واردسازی عمومی است. ```py __all__ = ['_another_weird_name_func'] @@ -2910,7 +2910,7 @@ NameError: name '_another_weird_name_func' is not defined def _another_weird_name_func(): print("works!") ``` - ‫ **خروجی** + **خروجی** ```py >>> _another_weird_name_func() @@ -2923,7 +2923,7 @@ NameError: name '_another_weird_name_func' is not defined --- -### ▶ ‫ همه چیز مرتب شده؟ * +### ▶ همه چیز مرتب شده؟ * @@ -2939,9 +2939,9 @@ True False ``` -#### 💡 ‫ توضیحات: +#### 💡 توضیحات: -- ‫ متد `sorted` همیشه یک لیست (`list`) برمی‌گرداند، و در پایتون مقایسه‌ی لیست‌ها و تاپل‌ها (`tuple`) همیشه مقدار `False` را برمی‌گرداند. +- متد `sorted` همیشه یک لیست (`list`) برمی‌گرداند، و در پایتون مقایسه‌ی لیست‌ها و تاپل‌ها (`tuple`) همیشه مقدار `False` را برمی‌گرداند. - ```py >>> [] == tuple() @@ -2950,9 +2950,9 @@ False >>> type(x), type(sorted(x)) (tuple, list) ``` -- ‫ برخلاف متد `sorted`، متد `reversed` یک تکرارکننده (iterator) برمی‌گرداند. چرا؟ زیرا مرتب‌سازی نیاز به تغییر درجا (in-place) یا استفاده از ظرف جانبی (مانند یک لیست اضافی) دارد، در حالی که معکوس کردن می‌تواند به‌سادگی با پیمایش از اندیس آخر به اول انجام شود. +- برخلاف متد `sorted`، متد `reversed` یک تکرارکننده (iterator) برمی‌گرداند. چرا؟ زیرا مرتب‌سازی نیاز به تغییر درجا (in-place) یا استفاده از ظرف جانبی (مانند یک لیست اضافی) دارد، در حالی که معکوس کردن می‌تواند به‌سادگی با پیمایش از اندیس آخر به اول انجام شود. -- ‫ بنابراین در مقایسه‌ی `sorted(y) == sorted(y)`، فراخوانی اولِ `sorted()` تمام عناصرِ تکرارکننده‌ی `y` را مصرف می‌کند، و فراخوانی بعدی یک لیست خالی برمی‌گرداند. +- بنابراین در مقایسه‌ی `sorted(y) == sorted(y)`، فراخوانی اولِ `sorted()` تمام عناصرِ تکرارکننده‌ی `y` را مصرف می‌کند، و فراخوانی بعدی یک لیست خالی برمی‌گرداند. ```py >>> x = 7, 8, 9 @@ -2963,7 +2963,7 @@ False --- -### ▶ ‫ زمان نیمه‌شب وجود ندارد؟ +### ▶ زمان نیمه‌شب وجود ندارد؟ ```py from datetime import datetime @@ -2981,14 +2981,14 @@ if noon_time: print("Time at noon is", noon_time) ``` -‫ **خروجی (< 3.5):** +**خروجی (< 3.5):** ```py ('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." @@ -2997,29 +2997,29 @@ Before Python 3.5, the boolean value for `datetime.time` object was considered t -## ‫ بخش: گنجینه‌های پنهان! +## بخش: گنجینه‌های پنهان! -‫ این بخش شامل چند مورد جالب و کمتر شناخته‌شده درباره‌ی پایتون است که بیشتر مبتدی‌هایی مثل من از آن بی‌خبرند (البته دیگر اینطور نیست). +این بخش شامل چند مورد جالب و کمتر شناخته‌شده درباره‌ی پایتون است که بیشتر مبتدی‌هایی مثل من از آن بی‌خبرند (البته دیگر اینطور نیست). -### ▶ ‫ خب پایتون، می‌توانی کاری کنی پرواز کنم؟ +### ▶ خب پایتون، می‌توانی کاری کنی پرواز کنم؟ -‫ خب، بفرمایید +خب، بفرمایید ```py import antigravity ``` -‫ **خروجی:** +**خروجی:** Sshh... It's a super-secret. -#### ‫ 💡 توضیح: -+ ‫ ماژول `antigravity` یکی از معدود ایستر اِگ‌هایی است که توسط توسعه‌دهندگان پایتون ارائه شده است. -+ ‫ دستور `import antigravity` باعث می‌شود مرورگر وب به سمت [کمیک کلاسیک XKCD](https://xkcd.com/353/) در مورد پایتون باز شود. -+ ‫ البته موضوع عمیق‌تر است؛ در واقع یک **ایستر اگ دیگر داخل این ایستر اگ** وجود دارد. اگر به [کد منبع](https://github.com/python/cpython/blob/master/Lib/antigravity.py#L7-L17) نگاه کنید، یک تابع تعریف شده که ادعا می‌کند [الگوریتم جئوهشینگ XKCD](https://xkcd.com/426/) را پیاده‌سازی کرده است. +#### 💡 توضیح: ++ ماژول `antigravity` یکی از معدود ایستر اِگ‌هایی است که توسط توسعه‌دهندگان پایتون ارائه شده است. ++ دستور `import antigravity` باعث می‌شود مرورگر وب به سمت [کمیک کلاسیک XKCD](https://xkcd.com/353/) در مورد پایتون باز شود. ++ البته موضوع عمیق‌تر است؛ در واقع یک **ایستر اگ دیگر داخل این ایستر اگ** وجود دارد. اگر به [کد منبع](https://github.com/python/cpython/blob/master/Lib/antigravity.py#L7-L17) نگاه کنید، یک تابع تعریف شده که ادعا می‌کند [الگوریتم جئوهشینگ XKCD](https://xkcd.com/426/) را پیاده‌سازی کرده است. --- -### ▶ ‫ `goto`، ولی چرا؟ +### ▶ `goto`، ولی چرا؟ ```py @@ -3034,48 +3034,48 @@ label .breakout print("Freedom!") ``` -‫ **خروجی (پایتون ۲.۳):** +**خروجی (پایتون ۲.۳):** ```py I am trapped, please rescue! I am trapped, please rescue! Freedom! ``` -#### ‫ 💡 توضیح: -- ‫ نسخه‌ی قابل استفاده‌ای از `goto` در پایتون به عنوان یک شوخی [در اول آوریل ۲۰۰۴ معرفی شد](https://mail.python.org/pipermail/python-announce-list/2004-April/002982.html). -- ‫ نسخه‌های فعلی پایتون فاقد این ماژول هستند. -- ‫ اگرچه این ماژول واقعاً کار می‌کند، ولی لطفاً از آن استفاده نکنید. در [این صفحه](https://docs.python.org/3/faq/design.html#why-is-there-no-goto) می‌توانید دلیل عدم حضور دستور `goto` در پایتون را مطالعه کنید. +#### 💡 توضیح: +- نسخه‌ی قابل استفاده‌ای از `goto` در پایتون به عنوان یک شوخی [در اول آوریل ۲۰۰۴ معرفی شد](https://mail.python.org/pipermail/python-announce-list/2004-April/002982.html). +- نسخه‌های فعلی پایتون فاقد این ماژول هستند. +- اگرچه این ماژول واقعاً کار می‌کند، ولی لطفاً از آن استفاده نکنید. در [این صفحه](https://docs.python.org/3/faq/design.html#why-is-there-no-goto) می‌توانید دلیل عدم حضور دستور `goto` در پایتون را مطالعه کنید. --- -### ▶ ‫ خودتان را آماده کنید! +### ▶ خودتان را آماده کنید! -‫ اگر جزو افرادی هستید که دوست ندارند در پایتون برای مشخص کردن محدوده‌ها از فضای خالی (whitespace) استفاده کنند، می‌توانید با ایمپورت کردن ماژول زیر از آکولاد `{}` به سبک زبان C استفاده کنید: +اگر جزو افرادی هستید که دوست ندارند در پایتون برای مشخص کردن محدوده‌ها از فضای خالی (whitespace) استفاده کنند، می‌توانید با ایمپورت کردن ماژول زیر از آکولاد `{}` به سبک زبان C استفاده کنید: ```py from __future__ import braces ``` -‫ **خروجی:** +**خروجی:** ```py File "some_file.py", line 1 from __future__ import braces SyntaxError: not a chance ``` -‫ آکولاد؟ هرگز! اگر از این بابت ناامید شدید، بهتر است از جاوا استفاده کنید. خب، یک چیز شگفت‌آور دیگر؛ آیا می‌توانید تشخیص دهید که ارور `SyntaxError` در کجای کد ماژول `__future__` [اینجا](https://github.com/python/cpython/blob/master/Lib/__future__.py) ایجاد می‌شود؟ +آکولاد؟ هرگز! اگر از این بابت ناامید شدید، بهتر است از جاوا استفاده کنید. خب، یک چیز شگفت‌آور دیگر؛ آیا می‌توانید تشخیص دهید که ارور `SyntaxError` در کجای کد ماژول `__future__` [اینجا](https://github.com/python/cpython/blob/master/Lib/__future__.py) ایجاد می‌شود؟ -#### ‫ 💡 توضیح: -+ ‫ ماژول `__future__` معمولاً برای ارائه قابلیت‌هایی از نسخه‌های آینده پایتون به کار می‌رود. اما کلمه «future» (آینده) در این زمینه خاص، حالت طنز و کنایه دارد. -+ ‫ این مورد یک «ایستر اگ» (easter egg) است که به احساسات جامعه برنامه‌نویسان پایتون در این خصوص اشاره دارد. -+ ‫ کد مربوط به این موضوع در واقع [اینجا](https://github.com/python/cpython/blob/025eb98dc0c1dc27404df6c544fc2944e0fa9f3a/Python/future.c#L49) در فایل `future.c` قرار دارد. -+ ‫ زمانی که کامپایلر CPython با یک [عبارت future](https://docs.python.org/3.3/reference/simple_stmts.html#future-statements) مواجه می‌شود، ابتدا کد مرتبط در `future.c` را اجرا کرده و سپس آن را همانند یک دستور ایمپورت عادی در نظر می‌گیرد. +#### 💡 توضیح: ++ ماژول `__future__` معمولاً برای ارائه قابلیت‌هایی از نسخه‌های آینده پایتون به کار می‌رود. اما کلمه «future» (آینده) در این زمینه خاص، حالت طنز و کنایه دارد. ++ این مورد یک «ایستر اگ» (easter egg) است که به احساسات جامعه برنامه‌نویسان پایتون در این خصوص اشاره دارد. ++ کد مربوط به این موضوع در واقع [اینجا](https://github.com/python/cpython/blob/025eb98dc0c1dc27404df6c544fc2944e0fa9f3a/Python/future.c#L49) در فایل `future.c` قرار دارد. ++ زمانی که کامپایلر CPython با یک [عبارت future](https://docs.python.org/3.3/reference/simple_stmts.html#future-statements) مواجه می‌شود، ابتدا کد مرتبط در `future.c` را اجرا کرده و سپس آن را همانند یک دستور ایمپورت عادی در نظر می‌گیرد. --- -### ▶ ‫ بیایید با «عمو زبان مهربان برای همیشه» آشنا شویم +### ▶ بیایید با «عمو زبان مهربان برای همیشه» آشنا شویم -‫ **خروجی (Python 3.x)** +**خروجی (Python 3.x)** ```py >>> from __future__ import barry_as_FLUFL >>> "Ruby" != "Python" # شکی در این نیست. @@ -3088,16 +3088,16 @@ SyntaxError: invalid syntax True ``` -‫ حالا می‌رسیم به اصل ماجرا. +حالا می‌رسیم به اصل ماجرا. -#### ‫ 💡 توضیح: -- ‫ این مورد مربوط به [PEP-401](https://www.python.org/dev/peps/pep-0401/) است که در تاریخ ۱ آوریل ۲۰۰۹ منتشر شد (اکنون می‌دانید این یعنی چه!). -- ‫ نقل قولی از PEP-401: +#### 💡 توضیح: +- این مورد مربوط به [PEP-401](https://www.python.org/dev/peps/pep-0401/) است که در تاریخ ۱ آوریل ۲۰۰۹ منتشر شد (اکنون می‌دانید این یعنی چه!). +- نقل قولی از PEP-401: - > ‫ با توجه به اینکه عملگر نابرابری `!=` در پایتون ۳.۰ یک اشتباه وحشتناک و انگشت‌سوز (!) بوده است، عمو زبان مهربان برای همیشه (FLUFL) عملگر الماسی‌شکل `<>` را مجدداً به‌عنوان تنها روش درست برای این منظور بازگردانده است. + > با توجه به اینکه عملگر نابرابری `!=` در پایتون ۳.۰ یک اشتباه وحشتناک و انگشت‌سوز (!) بوده است، عمو زبان مهربان برای همیشه (FLUFL) عملگر الماسی‌شکل `<>` را مجدداً به‌عنوان تنها روش درست برای این منظور بازگردانده است. -- ‫ البته «عمو بَری» چیزهای بیشتری برای گفتن در این PEP داشت؛ می‌توانید آن‌ها را [اینجا](https://www.python.org/dev/peps/pep-0401/) مطالعه کنید. -- ‫ این قابلیت در محیط تعاملی به خوبی عمل می‌کند، اما در زمان اجرای کد از طریق فایل پایتون، با خطای `SyntaxError` روبرو خواهید شد (برای اطلاعات بیشتر به این [issue](https://github.com/satwikkansal/wtfpython/issues/94) مراجعه کنید). با این حال، می‌توانید کد خود را درون یک `eval` یا `compile` قرار دهید تا این قابلیت فعال شود. +- البته «عمو بَری» چیزهای بیشتری برای گفتن در این PEP داشت؛ می‌توانید آن‌ها را [اینجا](https://www.python.org/dev/peps/pep-0401/) مطالعه کنید. +- این قابلیت در محیط تعاملی به خوبی عمل می‌کند، اما در زمان اجرای کد از طریق فایل پایتون، با خطای `SyntaxError` روبرو خواهید شد (برای اطلاعات بیشتر به این [issue](https://github.com/satwikkansal/wtfpython/issues/94) مراجعه کنید). با این حال، می‌توانید کد خود را درون یک `eval` یا `compile` قرار دهید تا این قابلیت فعال شود. ```py from __future__ import barry_as_FLUFL @@ -3106,7 +3106,7 @@ True --- -### ▶ ‫ حتی پایتون هم می‌داند که عشق پیچیده است +### ▶ حتی پایتون هم می‌داند که عشق پیچیده است ```py import this @@ -3114,7 +3114,7 @@ import this Wait, what's **this**? `this` is love :heart: -‫ **خروجی:** +**خروجی:** ``` The Zen of Python, by Tim Peters @@ -3139,7 +3139,7 @@ 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! ``` -‫ این ذنِ پایتون است! +این ذنِ پایتون است! ```py >>> love = this @@ -3155,17 +3155,17 @@ True True ``` -#### ‫ 💡 توضیح: +#### 💡 توضیح: -* ‫ ماژول `this` در پایتون، یک ایستر اگ برای «ذنِ پایتون» ([PEP 20](https://www.python.org/dev/peps/pep-0020)) است. -* ‫ اگر این موضوع به‌اندازه کافی جالب است، حتماً پیاده‌سازی [this.py](https://hg.python.org/cpython/file/c3896275c0f6/Lib/this.py) را ببینید. نکته جالب این است که **کد مربوط به ذنِ پایتون، خودش اصول ذن را نقض کرده است** (و احتمالاً این تنها جایی است که چنین اتفاقی می‌افتد). -* ‫ درباره جمله `love is not True or False; love is love`، اگرچه طعنه‌آمیز است، اما خود گویاست. (اگر واضح نیست، لطفاً مثال‌های مربوط به عملگرهای `is` و `is not` را مشاهده کنید.) +* ماژول `this` در پایتون، یک ایستر اگ برای «ذنِ پایتون» ([PEP 20](https://www.python.org/dev/peps/pep-0020)) است. +* اگر این موضوع به‌اندازه کافی جالب است، حتماً پیاده‌سازی [this.py](https://hg.python.org/cpython/file/c3896275c0f6/Lib/this.py) را ببینید. نکته جالب این است که **کد مربوط به ذنِ پایتون، خودش اصول ذن را نقض کرده است** (و احتمالاً این تنها جایی است که چنین اتفاقی می‌افتد). +* درباره جمله `love is not True or False; love is love`، اگرچه طعنه‌آمیز است، اما خود گویاست. (اگر واضح نیست، لطفاً مثال‌های مربوط به عملگرهای `is` و `is not` را مشاهده کنید.) --- -### ▶ ‫ بله، این واقعاً وجود دارد! +### ▶ بله، این واقعاً وجود دارد! -‫ **عبارت `else` برای حلقه‌ها.** یک مثال معمول آن می‌تواند چنین باشد: +**عبارت `else` برای حلقه‌ها.** یک مثال معمول آن می‌تواند چنین باشد: ```py def does_exists_num(l, to_find): @@ -3202,7 +3202,7 @@ else: Try block executed successfully... ``` -#### ‫ 💡 توضیح: +#### 💡 توضیح: - عبارت `else` بعد از حلقه‌ها تنها زمانی اجرا می‌شود که در هیچ‌کدام از تکرارها (`iterations`) از دستور `break` استفاده نشده باشد. می‌توانید آن را به عنوان یک شرط «بدون شکست» (nobreak) در نظر بگیرید. - عبارت `else` پس از بلاک `try` به عنوان «عبارت تکمیل» (`completion clause`) نیز شناخته می‌شود؛ چراکه رسیدن به عبارت `else` در ساختار `try` به این معنی است که بلاک `try` بدون رخ دادن استثنا با موفقیت تکمیل شده است. @@ -3228,15 +3228,15 @@ NameError: name 'SomeRandomString' is not defined Ellipsis ``` -#### ‫ 💡توضیح -- ‫ در پایتون، `Ellipsis` یک شیء درونی (`built-in`) است که به صورت سراسری (`global`) در دسترس است و معادل `...` است. +#### 💡توضیح +- در پایتون، `Ellipsis` یک شیء درونی (`built-in`) است که به صورت سراسری (`global`) در دسترس است و معادل `...` است. ```py >>> ... Ellipsis ``` -- ‫ `Ellipsis` می‌تواند برای چندین منظور استفاده شود: - + ‫ به عنوان یک نگه‌دارنده برای کدی که هنوز نوشته نشده است (مانند دستور `pass`) - + ‫ در سینتکس برش (`slicing`) برای نمایش برش کامل در ابعاد باقی‌مانده +- `Ellipsis` می‌تواند برای چندین منظور استفاده شود: + + به عنوان یک نگه‌دارنده برای کدی که هنوز نوشته نشده است (مانند دستور `pass`) + + در سینتکس برش (`slicing`) برای نمایش برش کامل در ابعاد باقی‌مانده ```py >>> import numpy as np @@ -3253,7 +3253,7 @@ Ellipsis ] ]) ``` - ‫ بنابراین، آرایه‌ی `three_dimensional_array` ما، آرایه‌ای از آرایه‌ها از آرایه‌ها است. فرض کنیم می‌خواهیم عنصر دوم (اندیس `1`) از تمامی آرایه‌های درونی را چاپ کنیم؛ در این حالت می‌توانیم از `Ellipsis` برای عبور از تمامی ابعاد قبلی استفاده کنیم: + بنابراین، آرایه‌ی `three_dimensional_array` ما، آرایه‌ای از آرایه‌ها از آرایه‌ها است. فرض کنیم می‌خواهیم عنصر دوم (اندیس `1`) از تمامی آرایه‌های درونی را چاپ کنیم؛ در این حالت می‌توانیم از `Ellipsis` برای عبور از تمامی ابعاد قبلی استفاده کنیم: ```py >>> three_dimensional_array[:,:,1] array([[1, 3], @@ -3262,18 +3262,18 @@ Ellipsis array([[1, 3], [5, 7]]) ``` - ‫ نکته: این روش برای آرایه‌هایی با هر تعداد بُعد کار می‌کند. حتی می‌توانید از برش (`slice`) در بُعد اول و آخر استفاده کرده و ابعاد میانی را نادیده بگیرید (به صورت `n_dimensional_array[first_dim_slice, ..., last_dim_slice]`). - + ‫ در [نوع‌دهی (`type hinting`)](https://docs.python.org/3/library/typing.html) برای اشاره به بخشی از نوع (مانند `Callable[..., int]` یا `Tuple[str, ...]`) استفاده می‌شود. - + ‫ همچنین می‌توانید از `Ellipsis` به عنوان آرگومان پیش‌فرض تابع استفاده کنید (برای مواردی که می‌خواهید میان «آرگومانی ارسال نشده است» و «مقدار `None` ارسال شده است» تمایز قائل شوید). + نکته: این روش برای آرایه‌هایی با هر تعداد بُعد کار می‌کند. حتی می‌توانید از برش (`slice`) در بُعد اول و آخر استفاده کرده و ابعاد میانی را نادیده بگیرید (به صورت `n_dimensional_array[first_dim_slice, ..., last_dim_slice]`). + + در [نوع‌دهی (`type hinting`)](https://docs.python.org/3/library/typing.html) برای اشاره به بخشی از نوع (مانند `Callable[..., int]` یا `Tuple[str, ...]`) استفاده می‌شود. + + همچنین می‌توانید از `Ellipsis` به عنوان آرگومان پیش‌فرض تابع استفاده کنید (برای مواردی که می‌خواهید میان «آرگومانی ارسال نشده است» و «مقدار `None` ارسال شده است» تمایز قائل شوید). --- -### ▶ ‫ بی‌نهایت (`Inpinity`) +### ▶ بی‌نهایت (`Inpinity`) -‫ این املای کلمه تعمداً به همین شکل نوشته شده است. لطفاً برای اصلاح آن درخواست (`patch`) ارسال نکنید. +این املای کلمه تعمداً به همین شکل نوشته شده است. لطفاً برای اصلاح آن درخواست (`patch`) ارسال نکنید. -‫ **خروجی (پایتون 3.x):** +**خروجی (پایتون 3.x):** ```py >>> infinity = float('infinity') >>> hash(infinity) @@ -3282,13 +3282,13 @@ Ellipsis -314159 ``` -#### ‫ 💡 توضیح: -- ‫ هش (`hash`) مقدار بی‌نهایت برابر با 10⁵ × π است. -- ‫ نکته جالب اینکه در پایتون ۳ هشِ مقدار `float('-inf')` برابر با «-10⁵ × π» است، در حالی که در پایتون ۲ برابر با «-10⁵ × e» است. +#### 💡 توضیح: +- هش (`hash`) مقدار بی‌نهایت برابر با 10⁵ × π است. +- نکته جالب اینکه در پایتون ۳ هشِ مقدار `float('-inf')` برابر با «-10⁵ × π» است، در حالی که در پایتون ۲ برابر با «-10⁵ × e» است. --- -### ▶ ‫ بیایید خرابکاری کنیم +### ▶ بیایید خرابکاری کنیم 1\. ```py @@ -3298,7 +3298,7 @@ class Yo(object): self.bro = True ``` -‫ **خروجی:** +**خروجی:** ```py >>> Yo().bro True @@ -3317,7 +3317,7 @@ class Yo(object): self.bro = True ``` -‫ **خروجی:** +**خروجی:** ```py >>> Yo().bro True @@ -3340,7 +3340,7 @@ class A(object): return __variable # هنوز در هیچ جا مقداردهی اولیه نشده است ``` -‫ **خروجی:** +**خروجی:** ```py >>> A().__variable Traceback (most recent call last): @@ -3352,23 +3352,23 @@ AttributeError: 'A' object has no attribute '__variable' ``` -#### ‫ 💡 توضیح: +#### 💡 توضیح: -* ‫ [تغییر نام](https://en.wikipedia.org/wiki/Name_mangling) برای جلوگیری از برخورد نام‌ها بین فضاهای نام مختلف استفاده می‌شود. -* ‫ در پایتون، مفسر نام‌های اعضای کلاس که با `__` (دو آندرلاین که به عنوان "دندر" شناخته می‌شود) شروع می‌شوند و بیش از یک آندرلاین انتهایی ندارند را با اضافه کردن `_NameOfTheClass` در ابتدای آنها تغییر می‌دهد. -* ‫ بنابراین، برای دسترسی به ویژگی `__honey` در اولین قطعه کد، مجبور بودیم `_Yo` را به ابتدای آن اضافه کنیم، که از بروز تعارض با ویژگی با همان نام تعریف‌شده در هر کلاس دیگری جلوگیری می‌کند. -* ‫ اما چرا در دومین قطعه کد کار نکرد؟ زیرا تغییر نام، نام‌هایی که با دو آندرلاین خاتمه می‌یابند را شامل نمی‌شود. -* ‫ قطعه سوم نیز نتیجه تغییر نام بود. نام `__variable` در عبارت `return __variable` به `_A__variable` تغییر یافت، که همچنین همان نام متغیری است که در محدوده بیرونی تعریف کرده بودیم. -* ‫ همچنین، اگر نام تغییر یافته بیش از ۲۵۵ کاراکتر باشد، برش داده می‌شود. +* [تغییر نام](https://en.wikipedia.org/wiki/Name_mangling) برای جلوگیری از برخورد نام‌ها بین فضاهای نام مختلف استفاده می‌شود. +* در پایتون، مفسر نام‌های اعضای کلاس که با `__` (دو آندرلاین که به عنوان "دندر" شناخته می‌شود) شروع می‌شوند و بیش از یک آندرلاین انتهایی ندارند را با اضافه کردن `_NameOfTheClass` در ابتدای آنها تغییر می‌دهد. +* بنابراین، برای دسترسی به ویژگی `__honey` در اولین قطعه کد، مجبور بودیم `_Yo` را به ابتدای آن اضافه کنیم، که از بروز تعارض با ویژگی با همان نام تعریف‌شده در هر کلاس دیگری جلوگیری می‌کند. +* اما چرا در دومین قطعه کد کار نکرد؟ زیرا تغییر نام، نام‌هایی که با دو آندرلاین خاتمه می‌یابند را شامل نمی‌شود. +* قطعه سوم نیز نتیجه تغییر نام بود. نام `__variable` در عبارت `return __variable` به `_A__variable` تغییر یافت، که همچنین همان نام متغیری است که در محدوده بیرونی تعریف کرده بودیم. +* همچنین، اگر نام تغییر یافته بیش از ۲۵۵ کاراکتر باشد، برش داده می‌شود. --- --- -## ‫ بخش: ظاهرها فریبنده‌اند! +## بخش: ظاهرها فریبنده‌اند! -### ▶ ‫ خطوط را رد می‌کند؟ +### ▶ خطوط را رد می‌کند؟ -‫ **خروجی:** +**خروجی:** ```py >>> value = 11 >>> valuе = 32 @@ -3376,13 +3376,13 @@ AttributeError: 'A' object has no attribute '__variable' 11 ``` -‫ چی? +چی? -‫ **نکته:** ساده‌ترین روش برای بازتولید این رفتار، کپی کردن دستورات از کد بالا و جایگذاری (paste) آن‌ها در فایل یا محیط تعاملی (shell) خودتان است. +**نکته:** ساده‌ترین روش برای بازتولید این رفتار، کپی کردن دستورات از کد بالا و جایگذاری (paste) آن‌ها در فایل یا محیط تعاملی (shell) خودتان است. -#### ‫ 💡 توضیح +#### 💡 توضیح -‫ برخی از حروف غیرغربی کاملاً مشابه حروف الفبای انگلیسی به نظر می‌رسند، اما مفسر پایتون آن‌ها را متفاوت در نظر می‌گیرد. +برخی از حروف غیرغربی کاملاً مشابه حروف الفبای انگلیسی به نظر می‌رسند، اما مفسر پایتون آن‌ها را متفاوت در نظر می‌گیرد. ```py >>> ord('е') # حرف سیریلیک «е» (Ye) @@ -3398,11 +3398,11 @@ False 42 ``` -‫ تابع داخلی `ord()`، [کدپوینت](https://fa.wikipedia.org/wiki/کدپوینت) یونیکد مربوط به یک نویسه را برمی‌گرداند. موقعیت‌های کدی متفاوت برای حرف سیریلیک «е» و حرف لاتین «e»، علت رفتار مثال بالا را توجیه می‌کنند. +تابع داخلی `ord()`، [کدپوینت](https://fa.wikipedia.org/wiki/کدپوینت) یونیکد مربوط به یک نویسه را برمی‌گرداند. موقعیت‌های کدی متفاوت برای حرف سیریلیک «е» و حرف لاتین «e»، علت رفتار مثال بالا را توجیه می‌کنند. --- -### ▶ ‫ تله‌پورت کردن +### ▶ تله‌پورت کردن @@ -3419,23 +3419,23 @@ def energy_receive(): return np.empty((), dtype=np.float).tolist() ``` -‫ **خروجی:** +**خروجی:** ```py >>> energy_send(123.456) >>> energy_receive() 123.456 ``` -‫ جایزه نوبل کجاست؟ +جایزه نوبل کجاست؟ -#### ‫ 💡 توضیح: +#### 💡 توضیح: -* ‫ توجه کنید که آرایه‌ی numpy ایجادشده در تابع `energy_send` برگردانده نشده است، بنابراین فضای حافظه‌ی آن آزاد شده و مجدداً قابل استفاده است. -* ‫ تابع `numpy.empty()` نزدیک‌ترین فضای حافظه‌ی آزاد را بدون مقداردهی مجدد برمی‌گرداند. این فضای حافظه معمولاً همان فضایی است که به‌تازگی آزاد شده است (البته معمولاً این اتفاق می‌افتد و نه همیشه). +* توجه کنید که آرایه‌ی numpy ایجادشده در تابع `energy_send` برگردانده نشده است، بنابراین فضای حافظه‌ی آن آزاد شده و مجدداً قابل استفاده است. +* تابع `numpy.empty()` نزدیک‌ترین فضای حافظه‌ی آزاد را بدون مقداردهی مجدد برمی‌گرداند. این فضای حافظه معمولاً همان فضایی است که به‌تازگی آزاد شده است (البته معمولاً این اتفاق می‌افتد و نه همیشه). --- -### ▶ ‫ خب، یک جای کار مشکوک است... +### ▶ خب، یک جای کار مشکوک است... ```py def square(x): @@ -3448,27 +3448,27 @@ def square(x): return sum_so_far ``` -‫ **خروجی (پایتون 2.X):** +**خروجی (پایتون 2.X):** ```py >>> square(10) 10 ``` -‫ آیا این نباید ۱۰۰ باشد؟ +آیا این نباید ۱۰۰ باشد؟ -‫ **نکته:** اگر نمی‌توانید این مشکل را بازتولید کنید، سعی کنید فایل [mixed_tabs_and_spaces.py](/mixed_tabs_and_spaces.py) را از طریق شِل اجرا کنید. +**نکته:** اگر نمی‌توانید این مشکل را بازتولید کنید، سعی کنید فایل [mixed_tabs_and_spaces.py](/mixed_tabs_and_spaces.py) را از طریق شِل اجرا کنید. -#### ‫ 💡 توضیح +#### 💡 توضیح -* ‫ **تب‌ها و فاصله‌ها (space) را با هم ترکیب نکنید!** کاراکتری که دقیقاً قبل از دستور return آمده یک «تب» است، در حالی که در بقیۀ مثال، کد با مضربی از «۴ فاصله» تورفتگی دارد. -* ‫ نحوۀ برخورد پایتون با تب‌ها به این صورت است: +* **تب‌ها و فاصله‌ها (space) را با هم ترکیب نکنید!** کاراکتری که دقیقاً قبل از دستور return آمده یک «تب» است، در حالی که در بقیۀ مثال، کد با مضربی از «۴ فاصله» تورفتگی دارد. +* نحوۀ برخورد پایتون با تب‌ها به این صورت است: - > ‫ ابتدا تب‌ها (از چپ به راست) با یک تا هشت فاصله جایگزین می‌شوند به‌طوری که تعداد کل کاراکترها تا انتهای آن جایگزینی، مضربی از هشت باشد <...> -* ‫ بنابراین «تب» در آخرین خط تابع `square` با هشت فاصله جایگزین شده و به همین دلیل داخل حلقه قرار می‌گیرد. -* ‫ پایتون ۳ آنقدر هوشمند هست که چنین مواردی را به‌صورت خودکار با خطا اعلام کند. + > ابتدا تب‌ها (از چپ به راست) با یک تا هشت فاصله جایگزین می‌شوند به‌طوری که تعداد کل کاراکترها تا انتهای آن جایگزینی، مضربی از هشت باشد <...> +* بنابراین «تب» در آخرین خط تابع `square` با هشت فاصله جایگزین شده و به همین دلیل داخل حلقه قرار می‌گیرد. +* پایتون ۳ آنقدر هوشمند هست که چنین مواردی را به‌صورت خودکار با خطا اعلام کند. - ‫ **خروجی (Python 3.x):** + **خروجی (Python 3.x):** ```py TabError: inconsistent use of tabs and spaces in indentation @@ -3480,7 +3480,7 @@ def square(x): ## بخش: متفرقه -### ‫ ▶ `+=` سریع‌تر است +### ▶ `+=` سریع‌تر است ```py @@ -3492,12 +3492,12 @@ def square(x): 0.012188911437988281 ``` -#### ‫ 💡 توضیح: -+ ‫ استفاده از `+=` برای اتصال بیش از دو رشته سریع‌تر از `+` است، زیرا هنگام محاسبه رشته‌ی نهایی، رشته‌ی اول (به‌عنوان مثال `s1` در عبارت `s1 += s2 + s3`) از بین نمی‌رود. +#### 💡 توضیح: ++ استفاده از `+=` برای اتصال بیش از دو رشته سریع‌تر از `+` است، زیرا هنگام محاسبه رشته‌ی نهایی، رشته‌ی اول (به‌عنوان مثال `s1` در عبارت `s1 += s2 + s3`) از بین نمی‌رود. --- -### ‫ ▶ بیایید یک رشته‌ی بزرگ بسازیم! +### ▶ بیایید یک رشته‌ی بزرگ بسازیم! ```py def add_string_with_plus(iters): @@ -3529,10 +3529,10 @@ def convert_list_to_string(l, iters): assert len(s) == 3*iters ``` -‫ **خروجی:** +**خروجی:** -‫ اجرا شده در پوسته‌ی ipython با استفاده از `%timeit` برای خوانایی بهتر نتایج. -‫ همچنین می‌توانید از ماژول `timeit` در پوسته یا اسکریپت عادی پایتون استفاده کنید؛ نمونه‌ی استفاده در زیر آمده است: +اجرا شده در پوسته‌ی ipython با استفاده از `%timeit` برای خوانایی بهتر نتایج. +همچنین می‌توانید از ماژول `timeit` در پوسته یا اسکریپت عادی پایتون استفاده کنید؛ نمونه‌ی استفاده در زیر آمده است: timeit.timeit('add_string_with_plus(10000)', number=1000, globals=globals()) ```py @@ -3551,7 +3551,7 @@ timeit.timeit('add_string_with_plus(10000)', number=1000, globals=globals()) 10.1 µs ± 1.06 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) ``` -‫ بیایید تعداد تکرارها را ۱۰ برابر افزایش دهیم. +بیایید تعداد تکرارها را ۱۰ برابر افزایش دهیم. ```py >>> NUM_ITERS = 10000 @@ -3570,11 +3570,11 @@ timeit.timeit('add_string_with_plus(10000)', number=1000, globals=globals()) #### 💡 توضیحات توضیحات -- ‫ برای اطلاعات بیشتر درباره‌ی [timeit](https://docs.python.org/3/library/timeit.html) یا [%timeit](https://ipython.org/ipython-doc/dev/interactive/magics.html#magic-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"`)، افزایش زمان اجرا درجه دو می‌شد. +- برای اطلاعات بیشتر درباره‌ی [timeit](https://docs.python.org/3/library/timeit.html) یا [%timeit](https://ipython.org/ipython-doc/dev/interactive/magics.html#magic-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"`)، افزایش زمان اجرا درجه دو می‌شد. ```py def add_string_with_plus(iters): s = "" @@ -3587,21 +3587,21 @@ timeit.timeit('add_string_with_plus(10000)', number=1000, globals=globals()) >>> %timeit -n100 add_string_with_plus(10000) # افزایش درجه دو در زمان اجرا 9 ms ± 298 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) ``` -- ‫ وجود راه‌های متعدد برای قالب‌بندی و ایجاد رشته‌های بزرگ تا حدودی در تضاد با [ذِن پایتون](https://www.python.org/dev/peps/pep-0020/) است که می‌گوید: +- وجود راه‌های متعدد برای قالب‌بندی و ایجاد رشته‌های بزرگ تا حدودی در تضاد با [ذِن پایتون](https://www.python.org/dev/peps/pep-0020/) است که می‌گوید: - > ‫ «باید یک راه — و ترجیحاً فقط یک راه — واضح برای انجام آن وجود داشته باشد.» + > «باید یک راه — و ترجیحاً فقط یک راه — واضح برای انجام آن وجود داشته باشد.» --- -### ▶ ‫ کُند کردن جستجوها در `dict` * +### ▶ کُند کردن جستجوها در `dict` * ```py some_dict = {str(i): 1 for i in range(1_000_000)} another_dict = {str(i): 1 for i in range(1_000_000)} ``` -‫ **خروجی:** +**خروجی:** ```py >>> %timeit some_dict['5'] 28.6 ns ± 0.115 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each) @@ -3620,14 +3620,14 @@ KeyError: 1 ``` چرا جستجوهای یکسان کندتر می‌شوند؟ -#### ‫ 💡 توضیح: -+ ‫ در CPython یک تابع عمومی برای جستجوی کلید در دیکشنری‌ها وجود دارد که از تمام انواع کلیدها (`str`، `int` و هر شیء دیگر) پشتیبانی می‌کند؛ اما برای حالت متداولی که تمام کلیدها از نوع `str` هستند، یک تابع بهینه‌شده‌ی اختصاصی نیز وجود دارد. -+ ‫ تابع اختصاصی (که در کد منبع CPython با نام [`lookdict_unicode`](https://github.com/python/cpython/blob/522691c46e2ae51faaad5bbbce7d959dd61770df/Objects/dictobject.c#L841) شناخته می‌شود) فرض می‌کند که تمام کلیدهای موجود در دیکشنری (از جمله کلیدی که در حال جستجوی آن هستید) رشته (`str`) هستند و برای مقایسه‌ی کلیدها، به‌جای فراخوانی متد `__eq__`، از مقایسه‌ی سریع‌تر و ساده‌تر رشته‌ای استفاده می‌کند. -+ ‫ اولین باری که یک دیکشنری (`dict`) با کلیدی غیر از `str` فراخوانی شود، این حالت تغییر می‌کند و جستجوهای بعدی از تابع عمومی استفاده خواهند کرد. -+ ‫ این فرایند برای آن نمونه‌ی خاص از دیکشنری غیرقابل بازگشت است و حتی لازم نیست کلید موردنظر در دیکشنری موجود باشد. به همین دلیل است که حتی تلاش ناموفق برای دسترسی به کلیدی ناموجود نیز باعث ایجاد همین تأثیر (کند شدن جستجو) می‌شود. +#### 💡 توضیح: ++ در CPython یک تابع عمومی برای جستجوی کلید در دیکشنری‌ها وجود دارد که از تمام انواع کلیدها (`str`، `int` و هر شیء دیگر) پشتیبانی می‌کند؛ اما برای حالت متداولی که تمام کلیدها از نوع `str` هستند، یک تابع بهینه‌شده‌ی اختصاصی نیز وجود دارد. ++ تابع اختصاصی (که در کد منبع CPython با نام [`lookdict_unicode`](https://github.com/python/cpython/blob/522691c46e2ae51faaad5bbbce7d959dd61770df/Objects/dictobject.c#L841) شناخته می‌شود) فرض می‌کند که تمام کلیدهای موجود در دیکشنری (از جمله کلیدی که در حال جستجوی آن هستید) رشته (`str`) هستند و برای مقایسه‌ی کلیدها، به‌جای فراخوانی متد `__eq__`، از مقایسه‌ی سریع‌تر و ساده‌تر رشته‌ای استفاده می‌کند. ++ اولین باری که یک دیکشنری (`dict`) با کلیدی غیر از `str` فراخوانی شود، این حالت تغییر می‌کند و جستجوهای بعدی از تابع عمومی استفاده خواهند کرد. ++ این فرایند برای آن نمونه‌ی خاص از دیکشنری غیرقابل بازگشت است و حتی لازم نیست کلید موردنظر در دیکشنری موجود باشد. به همین دلیل است که حتی تلاش ناموفق برای دسترسی به کلیدی ناموجود نیز باعث ایجاد همین تأثیر (کند شدن جستجو) می‌شود. -### ‫ ▶ حجیم کردن دیکشنری نمونه‌ها (`instance dicts`) * +### ▶ حجیم کردن دیکشنری نمونه‌ها (`instance dicts`) * ```py import sys @@ -3645,7 +3645,7 @@ def dict_size(o): ``` -‫ **خروجی:** (پایتون ۳.۸؛ سایر نسخه‌های پایتون ۳ ممکن است کمی متفاوت باشند) +**خروجی:** (پایتون ۳.۸؛ سایر نسخه‌های پایتون ۳ ممکن است کمی متفاوت باشند) ```py >>> o1 = SomeClass() >>> o2 = SomeClass() @@ -3661,7 +3661,7 @@ def dict_size(o): 232 ``` -‫ بیایید دوباره امتحان کنیم... در یک مفسر (interpreter) جدید: +بیایید دوباره امتحان کنیم... در یک مفسر (interpreter) جدید: ```py >>> o1 = SomeClass() @@ -3679,28 +3679,28 @@ def dict_size(o): 232 ``` -‫ چه چیزی باعث حجیم‌شدن این دیکشنری‌ها می‌شود؟ و چرا اشیاء تازه ساخته‌شده نیز حجیم هستند؟ +چه چیزی باعث حجیم‌شدن این دیکشنری‌ها می‌شود؟ و چرا اشیاء تازه ساخته‌شده نیز حجیم هستند؟ #### 💡 توضیح: -+ ‫ در CPython، امکان استفاده‌ی مجدد از یک شیء «کلیدها» (`keys`) در چندین دیکشنری وجود دارد. این ویژگی در [PEP 412](https://www.python.org/dev/peps/pep-0412/) معرفی شد تا مصرف حافظه کاهش یابد، به‌ویژه برای دیکشنری‌هایی که به نمونه‌ها (instances) تعلق دارند و معمولاً کلیدها (نام صفات نمونه‌ها) بین آن‌ها مشترک است. -+ ‫ این بهینه‌سازی برای دیکشنری‌های نمونه‌ها کاملاً شفاف و خودکار است؛ اما اگر بعضی فرضیات نقض شوند، غیرفعال می‌شود. -+ ‫ دیکشنری‌هایی که کلیدهایشان به اشتراک گذاشته شده باشد، از حذف کلید پشتیبانی نمی‌کنند؛ بنابراین اگر صفتی از یک نمونه حذف شود، دیکشنریِ آن نمونه «غیر مشترک» (`unshared`) شده و این قابلیت اشتراک‌گذاری کلیدها برای تمام نمونه‌هایی که در آینده از آن کلاس ساخته می‌شوند، غیرفعال می‌گردد. -+ ‫ همچنین اگر اندازه‌ی دیکشنری به‌علت اضافه‌شدن کلیدهای جدید تغییر کند (`resize` شود)، اشتراک‌گذاری کلیدها تنها زمانی ادامه می‌یابد که فقط یک دیکشنری در حال استفاده از آن‌ها باشد (این اجازه می‌دهد در متد `__init__` برای اولین نمونه‌ی ساخته‌شده، صفات متعددی تعریف کنید بدون آن‌که اشتراک‌گذاری کلیدها از بین برود). اما اگر چند نمونه همزمان وجود داشته باشند و تغییر اندازه‌ی دیکشنری رخ دهد، قابلیت اشتراک‌گذاری کلیدها برای نمونه‌های بعدی همان کلاس غیرفعال خواهد شد. زیرا CPython دیگر نمی‌تواند مطمئن باشد که آیا نمونه‌های بعدی دقیقاً از مجموعه‌ی یکسانی از صفات استفاده خواهند کرد یا خیر. -+ ‫ نکته‌ای کوچک برای کاهش مصرف حافظه‌ی برنامه: هرگز صفات نمونه‌ها را حذف نکنید و حتماً تمام صفات را در متد `__init__` تعریف و مقداردهی اولیه کنید! ++ در CPython، امکان استفاده‌ی مجدد از یک شیء «کلیدها» (`keys`) در چندین دیکشنری وجود دارد. این ویژگی در [PEP 412](https://www.python.org/dev/peps/pep-0412/) معرفی شد تا مصرف حافظه کاهش یابد، به‌ویژه برای دیکشنری‌هایی که به نمونه‌ها (instances) تعلق دارند و معمولاً کلیدها (نام صفات نمونه‌ها) بین آن‌ها مشترک است. ++ این بهینه‌سازی برای دیکشنری‌های نمونه‌ها کاملاً شفاف و خودکار است؛ اما اگر بعضی فرضیات نقض شوند، غیرفعال می‌شود. ++ دیکشنری‌هایی که کلیدهایشان به اشتراک گذاشته شده باشد، از حذف کلید پشتیبانی نمی‌کنند؛ بنابراین اگر صفتی از یک نمونه حذف شود، دیکشنریِ آن نمونه «غیر مشترک» (`unshared`) شده و این قابلیت اشتراک‌گذاری کلیدها برای تمام نمونه‌هایی که در آینده از آن کلاس ساخته می‌شوند، غیرفعال می‌گردد. ++ همچنین اگر اندازه‌ی دیکشنری به‌علت اضافه‌شدن کلیدهای جدید تغییر کند (`resize` شود)، اشتراک‌گذاری کلیدها تنها زمانی ادامه می‌یابد که فقط یک دیکشنری در حال استفاده از آن‌ها باشد (این اجازه می‌دهد در متد `__init__` برای اولین نمونه‌ی ساخته‌شده، صفات متعددی تعریف کنید بدون آن‌که اشتراک‌گذاری کلیدها از بین برود). اما اگر چند نمونه همزمان وجود داشته باشند و تغییر اندازه‌ی دیکشنری رخ دهد، قابلیت اشتراک‌گذاری کلیدها برای نمونه‌های بعدی همان کلاس غیرفعال خواهد شد. زیرا CPython دیگر نمی‌تواند مطمئن باشد که آیا نمونه‌های بعدی دقیقاً از مجموعه‌ی یکسانی از صفات استفاده خواهند کرد یا خیر. ++ نکته‌ای کوچک برای کاهش مصرف حافظه‌ی برنامه: هرگز صفات نمونه‌ها را حذف نکنید و حتماً تمام صفات را در متد `__init__` تعریف و مقداردهی اولیه کنید! -### ‫ ▶ موارد جزئی * +### ▶ موارد جزئی * -* ‫ متد `join()` عملیاتی مربوط به رشته (`str`) است، نه لیست (`list`). (در نگاه اول کمی برخلاف انتظار است.) +* متد `join()` عملیاتی مربوط به رشته (`str`) است، نه لیست (`list`). (در نگاه اول کمی برخلاف انتظار است.) ** ‫💡 توضیح:** اگر `join()` به‌عنوان متدی روی رشته پیاده‌سازی شود، می‌تواند روی هر شیء قابل پیمایش (`iterable`) از جمله لیست، تاپل و هر نوع تکرارشونده‌ی دیگر کار کند. اگر به‌جای آن روی لیست تعریف می‌شد، باید به‌طور جداگانه برای هر نوع دیگری نیز پیاده‌سازی می‌شد. همچنین منطقی نیست که یک متد مختص رشته روی یک شیء عمومی مانند `list` پیاده شود. -* ‫ تعدادی عبارت با ظاهری عجیب اما از نظر معنا صحیح: - + ‫ عبارت `[] = ()` از نظر معنایی صحیح است (باز کردن یا `unpack` کردن یک تاپل خالی درون یک لیست خالی). - + ‫ عبارت `'a'[0][0][0][0][0]` نیز از نظر معنایی صحیح است، زیرا پایتون برخلاف زبان‌هایی که از C منشعب شده‌اند، نوع داده‌ای جداگانه‌ای برای کاراکتر ندارد. بنابراین انتخاب یک کاراکتر از یک رشته، منجر به بازگشت یک رشته‌ی تک‌کاراکتری می‌شود. - + ‫ عبارات `3 --0-- 5 == 8` و `--5 == 5` هر دو از لحاظ معنایی درست بوده و مقدارشان برابر `True` است. +* تعدادی عبارت با ظاهری عجیب اما از نظر معنا صحیح: + + عبارت `[] = ()` از نظر معنایی صحیح است (باز کردن یا `unpack` کردن یک تاپل خالی درون یک لیست خالی). + + عبارت `'a'[0][0][0][0][0]` نیز از نظر معنایی صحیح است، زیرا پایتون برخلاف زبان‌هایی که از C منشعب شده‌اند، نوع داده‌ای جداگانه‌ای برای کاراکتر ندارد. بنابراین انتخاب یک کاراکتر از یک رشته، منجر به بازگشت یک رشته‌ی تک‌کاراکتری می‌شود. + + عبارات `3 --0-- 5 == 8` و `--5 == 5` هر دو از لحاظ معنایی درست بوده و مقدارشان برابر `True` است. -* ‫ با فرض اینکه `a` یک عدد باشد، عبارات `++a` و `--a` هر دو در پایتون معتبر هستند؛ اما رفتاری مشابه با عبارات مشابه در زبان‌هایی مانند C، ++C یا جاوا ندارند. +* با فرض اینکه `a` یک عدد باشد، عبارات `++a` و `--a` هر دو در پایتون معتبر هستند؛ اما رفتاری مشابه با عبارات مشابه در زبان‌هایی مانند C، ++C یا جاوا ندارند. ```py >>> a = 5 @@ -3712,12 +3712,12 @@ def dict_size(o): 5 ``` - ** ‫ 💡 توضیح:** - + ‫ در گرامر پایتون عملگری به‌نام `++` وجود ندارد. در واقع `++` دو عملگر `+` جداگانه است. - + ‫ عبارت `++a` به‌شکل `+(+a)` تفسیر می‌شود که معادل `a` است. به‌همین ترتیب، خروجی عبارت `--a` نیز قابل توجیه است. - + ‫ این [تاپیک در StackOverflow](https://stackoverflow.com/questions/3654830/why-are-there-no-and-operators-in-python) دلایل نبودن عملگرهای افزایش (`++`) و کاهش (`--`) در پایتون را بررسی می‌کند. + ** 💡 توضیح:** + + در گرامر پایتون عملگری به‌نام `++` وجود ندارد. در واقع `++` دو عملگر `+` جداگانه است. + + عبارت `++a` به‌شکل `+(+a)` تفسیر می‌شود که معادل `a` است. به‌همین ترتیب، خروجی عبارت `--a` نیز قابل توجیه است. + + این [تاپیک در StackOverflow](https://stackoverflow.com/questions/3654830/why-are-there-no-and-operators-in-python) دلایل نبودن عملگرهای افزایش (`++`) و کاهش (`--`) در پایتون را بررسی می‌کند. -* ‫ احتمالاً با عملگر Walrus (گراز دریایی) در پایتون آشنا هستید؛ اما تا به حال در مورد *عملگر Space-invader (مهاجم فضایی)* شنیده‌اید؟ +* احتمالاً با عملگر Walrus (گراز دریایی) در پایتون آشنا هستید؛ اما تا به حال در مورد *عملگر Space-invader (مهاجم فضایی)* شنیده‌اید؟ ```py >>> a = 42 @@ -3725,15 +3725,15 @@ def dict_size(o): >>> a 43 ``` -‫ از آن به‌عنوان جایگزینی برای عملگر افزایش (increment)، در ترکیب با یک عملگر دیگر استفاده می‌شود. +از آن به‌عنوان جایگزینی برای عملگر افزایش (increment)، در ترکیب با یک عملگر دیگر استفاده می‌شود. ```py >>> a +=+ 1 >>> a >>> 44 ``` - **‫ 💡 توضیح:** این شوخی از [توییت Raymond Hettinger](https://twitter.com/raymondh/status/1131103570856632321?lang=en) برگرفته شده است. عملگر «مهاجم فضایی» در واقع همان عبارت بدفرمت‌شده‌ی `a -= (-1)` است که معادل با `a = a - (- 1)` می‌باشد. حالت مشابهی برای عبارت `a += (+ 1)` نیز وجود دارد. + **💡 توضیح:** این شوخی از [توییت Raymond Hettinger](https://twitter.com/raymondh/status/1131103570856632321?lang=en) برگرفته شده است. عملگر «مهاجم فضایی» در واقع همان عبارت بدفرمت‌شده‌ی `a -= (-1)` است که معادل با `a = a - (- 1)` می‌باشد. حالت مشابهی برای عبارت `a += (+ 1)` نیز وجود دارد. -* ‫ پایتون یک عملگر مستندنشده برای [استلزام معکوس (converse implication)](https://en.wikipedia.org/wiki/Converse_implication) دارد. +* پایتون یک عملگر مستندنشده برای [استلزام معکوس (converse implication)](https://en.wikipedia.org/wiki/Converse_implication) دارد. ```py >>> False ** False == True @@ -3746,9 +3746,9 @@ def dict_size(o): True ``` - ‫ **💡 توضیح:** اگر مقادیر `False` و `True` را به‌ترتیب با اعداد ۰ و ۱ جایگزین کرده و محاسبات را انجام دهید، جدول درستی حاصل، معادل یک عملگر استلزام معکوس خواهد بود. ([منبع](https://github.com/cosmologicon/pywat/blob/master/explanation.md#the-undocumented-converse-implication-operator)) + **💡 توضیح:** اگر مقادیر `False` و `True` را به‌ترتیب با اعداد ۰ و ۱ جایگزین کرده و محاسبات را انجام دهید، جدول درستی حاصل، معادل یک عملگر استلزام معکوس خواهد بود. ([منبع](https://github.com/cosmologicon/pywat/blob/master/explanation.md#the-undocumented-converse-implication-operator)) -* ‫ حالا که صحبت از عملگرها شد، عملگر `@` نیز برای ضرب ماتریسی در پایتون وجود دارد (نگران نباشید، این بار واقعی است). +* حالا که صحبت از عملگرها شد، عملگر `@` نیز برای ضرب ماتریسی در پایتون وجود دارد (نگران نباشید، این بار واقعی است). ```py >>> import numpy as np @@ -3756,16 +3756,16 @@ def dict_size(o): 46 ``` - ‫ **💡 توضیح:** عملگر `@` در پایتون ۳٫۵ با در نظر گرفتن نیازهای جامعه علمی اضافه شد. هر شی‌ای می‌تواند متد جادویی `__matmul__` را بازنویسی کند تا رفتار این عملگر را مشخص نماید. + **💡 توضیح:** عملگر `@` در پایتون ۳٫۵ با در نظر گرفتن نیازهای جامعه علمی اضافه شد. هر شی‌ای می‌تواند متد جادویی `__matmul__` را بازنویسی کند تا رفتار این عملگر را مشخص نماید. -* ‫ از پایتون ۳٫۸ به بعد می‌توانید از نحو متداول f-string مانند `f'{some_var=}'` برای اشکال‌زدایی سریع استفاده کنید. مثال, +* از پایتون ۳٫۸ به بعد می‌توانید از نحو متداول f-string مانند `f'{some_var=}'` برای اشکال‌زدایی سریع استفاده کنید. مثال, ```py >>> some_string = "wtfpython" >>> f'{some_string=}' "some_string='wtfpython'" ``` -* ‫ پایتون برای ذخیره‌سازی متغیرهای محلی در توابع از ۲ بایت استفاده می‌کند. از نظر تئوری، این به معنای امکان تعریف حداکثر ۶۵۵۳۶ متغیر در یک تابع است. با این حال، پایتون راهکار مفیدی ارائه می‌کند که می‌توان با استفاده از آن بیش از ۲^۱۶ نام متغیر را ذخیره کرد. کد زیر نشان می‌دهد وقتی بیش از ۶۵۵۳۶ متغیر محلی تعریف شود، در پشته (stack) چه اتفاقی رخ می‌دهد (هشدار: این کد تقریباً ۲^۱۸ خط متن چاپ می‌کند، بنابراین آماده باشید!): +* پایتون برای ذخیره‌سازی متغیرهای محلی در توابع از ۲ بایت استفاده می‌کند. از نظر تئوری، این به معنای امکان تعریف حداکثر ۶۵۵۳۶ متغیر در یک تابع است. با این حال، پایتون راهکار مفیدی ارائه می‌کند که می‌توان با استفاده از آن بیش از ۲^۱۶ نام متغیر را ذخیره کرد. کد زیر نشان می‌دهد وقتی بیش از ۶۵۵۳۶ متغیر محلی تعریف شود، در پشته (stack) چه اتفاقی رخ می‌دهد (هشدار: این کد تقریباً ۲^۱۸ خط متن چاپ می‌کند، بنابراین آماده باشید!): ```py import dis @@ -3779,9 +3779,9 @@ def dict_size(o): print(dis.dis(f)) ``` -* ‫ چندین رشته (Thread) در پایتون، کدِ *پایتونی* شما را به‌صورت همزمان اجرا نمی‌کنند (بله، درست شنیدید!). شاید به نظر برسد که ایجاد چندین رشته و اجرای همزمان آن‌ها منطقی است، اما به دلیل وجود [قفل مفسر سراسری (GIL)](https://wiki.python.org/moin/GlobalInterpreterLock) در پایتون، تمام کاری که انجام می‌دهید این است که رشته‌هایتان به‌نوبت روی یک هسته اجرا می‌شوند. رشته‌ها در پایتون برای وظایفی مناسب هستند که عملیات I/O دارند، اما برای رسیدن به موازی‌سازی واقعی در وظایف پردازشی سنگین (CPU-bound)، بهتر است از ماژول [multiprocessing](https://docs.python.org/3/library/multiprocessing.html) در پایتون استفاده کنید. +* چندین رشته (Thread) در پایتون، کدِ *پایتونی* شما را به‌صورت همزمان اجرا نمی‌کنند (بله، درست شنیدید!). شاید به نظر برسد که ایجاد چندین رشته و اجرای همزمان آن‌ها منطقی است، اما به دلیل وجود [قفل مفسر سراسری (GIL)](https://wiki.python.org/moin/GlobalInterpreterLock) در پایتون، تمام کاری که انجام می‌دهید این است که رشته‌هایتان به‌نوبت روی یک هسته اجرا می‌شوند. رشته‌ها در پایتون برای وظایفی مناسب هستند که عملیات I/O دارند، اما برای رسیدن به موازی‌سازی واقعی در وظایف پردازشی سنگین (CPU-bound)، بهتر است از ماژول [multiprocessing](https://docs.python.org/3/library/multiprocessing.html) در پایتون استفاده کنید. -* ‫ گاهی اوقات، متد `print` ممکن است مقادیر را فوراً چاپ نکند. برای مثال، +* گاهی اوقات، متد `print` ممکن است مقادیر را فوراً چاپ نکند. برای مثال، ```py # File some_file.py @@ -3791,16 +3791,16 @@ def dict_size(o): time.sleep(3) ``` - ‫ این کد عبارت `wtfpython` را به دلیل آرگومان `end` پس از ۳ ثانیه چاپ می‌کند؛ چرا که بافر خروجی تنها پس از رسیدن به کاراکتر `\n` یا در زمان اتمام اجرای برنامه تخلیه می‌شود. برای تخلیه‌ی اجباری بافر می‌توانید از آرگومان `flush=True` استفاده کنید. + این کد عبارت `wtfpython` را به دلیل آرگومان `end` پس از ۳ ثانیه چاپ می‌کند؛ چرا که بافر خروجی تنها پس از رسیدن به کاراکتر `\n` یا در زمان اتمام اجرای برنامه تخلیه می‌شود. برای تخلیه‌ی اجباری بافر می‌توانید از آرگومان `flush=True` استفاده کنید. -* ‫ برش لیست‌ها (List slicing) با اندیس‌های خارج از محدوده، خطایی ایجاد نمی‌کند. +* برش لیست‌ها (List slicing) با اندیس‌های خارج از محدوده، خطایی ایجاد نمی‌کند. ```py >>> some_list = [1, 2, 3, 4, 5] >>> some_list[111:] [] ``` -* ‫ برش زدن (slicing) یک شئ قابل پیمایش (iterable) همیشه یک شئ جدید ایجاد نمی‌کند. به‌عنوان مثال، +* برش زدن (slicing) یک شئ قابل پیمایش (iterable) همیشه یک شئ جدید ایجاد نمی‌کند. به‌عنوان مثال، ```py >>> some_str = "wtfpython" >>> some_list = ['w', 't', 'f', 'p', 'y', 't', 'h', 'o', 'n'] @@ -3810,9 +3810,9 @@ def dict_size(o): True ``` -* ‫ در پایتون ۳، فراخوانی `int('١٢٣٤٥٦٧٨٩')` مقدار `123456789` را برمی‌گرداند. در پایتون، نویسه‌های ده‌دهی (Decimal characters) شامل تمام ارقامی هستند که می‌توانند برای تشکیل اعداد در مبنای ده استفاده شوند؛ به‌عنوان مثال نویسه‌ی U+0660 که همان رقم صفر عربی-هندی است. [اینجا](https://chris.improbable.org/2014/8/25/adventures-in-unicode-digits/) داستان جالبی درباره این رفتار پایتون آمده است. +* در پایتون ۳، فراخوانی `int('١٢٣٤٥٦٧٨٩')` مقدار `123456789` را برمی‌گرداند. در پایتون، نویسه‌های ده‌دهی (Decimal characters) شامل تمام ارقامی هستند که می‌توانند برای تشکیل اعداد در مبنای ده استفاده شوند؛ به‌عنوان مثال نویسه‌ی U+0660 که همان رقم صفر عربی-هندی است. [اینجا](https://chris.improbable.org/2014/8/25/adventures-in-unicode-digits/) داستان جالبی درباره این رفتار پایتون آمده است. -* ‫ از پایتون ۳ به بعد، می‌توانید برای افزایش خوانایی، اعداد را با استفاده از زیرخط (`_`) جدا کنید. +* از پایتون ۳ به بعد، می‌توانید برای افزایش خوانایی، اعداد را با استفاده از زیرخط (`_`) جدا کنید. ```py >>> six_million = 6_000_000 @@ -3823,7 +3823,7 @@ def dict_size(o): 4027435774 ``` -* ‫ عبارت `'abc'.count('') == 4` مقدار `True` برمی‌گرداند. در اینجا یک پیاده‌سازی تقریبی از متد `count` آورده شده که این موضوع را شفاف‌تر می‌کند: +* عبارت `'abc'.count('') == 4` مقدار `True` برمی‌گرداند. در اینجا یک پیاده‌سازی تقریبی از متد `count` آورده شده که این موضوع را شفاف‌تر می‌کند: ```py def count(s, sub): result = 0 @@ -3831,31 +3831,31 @@ def dict_size(o): result += (s[i:i + len(sub)] == sub) return result ``` -‫ این رفتار به این دلیل است که زیررشته‌ی خالی (`''`) با برش‌هایی (slices) به طول صفر در رشته‌ی اصلی مطابقت پیدا می‌کند. + این رفتار به این دلیل است که زیررشته‌ی خالی (`''`) با برش‌هایی (slices) به طول صفر در رشته‌ی اصلی مطابقت پیدا می‌کند. --- --- -# ‫ مشارکت +# مشارکت ‫چند روشی که می‌توانید در wtfpython مشارکت داشته باشید: -- ‫ پیشنهاد مثال‌های جدید -- ‫ کمک به ترجمه (به [مشکلات برچسب ترجمه](https://github.com/satwikkansal/wtfpython/issues?q=is%3Aissue+is%3Aopen+label%3Atranslation) مراجعه کنید) -- ‫ اصلاحات جزئی مثل اشاره به تکه‌کدهای قدیمی، اشتباهات تایپی، خطاهای قالب‌بندی و غیره. -- ‫ شناسایی نواقص (مانند توضیحات ناکافی، مثال‌های تکراری و ...) -- ‫ هر پیشنهاد خلاقانه‌ای برای مفیدتر و جذاب‌تر شدن این پروژه +- پیشنهاد مثال‌های جدید +- کمک به ترجمه (به [مشکلات برچسب ترجمه](https://github.com/satwikkansal/wtfpython/issues?q=is%3Aissue+is%3Aopen+label%3Atranslation) مراجعه کنید) +- اصلاحات جزئی مثل اشاره به تکه‌کدهای قدیمی، اشتباهات تایپی، خطاهای قالب‌بندی و غیره. +- شناسایی نواقص (مانند توضیحات ناکافی، مثال‌های تکراری و ...) +- هر پیشنهاد خلاقانه‌ای برای مفیدتر و جذاب‌تر شدن این پروژه -‫ برای اطلاعات بیشتر [CONTRIBUTING.md](/CONTRIBUTING.md) را مشاهده کنید. برای بحث درباره موارد مختلف می‌توانید یک [مشکل جدید](https://github.com/satwikkansal/wtfpython/issues/new) ایجاد کنید. +برای اطلاعات بیشتر [CONTRIBUTING.md](/CONTRIBUTING.md) را مشاهده کنید. برای بحث درباره موارد مختلف می‌توانید یک [مشکل جدید](https://github.com/satwikkansal/wtfpython/issues/new) ایجاد کنید. -‫ نکته: لطفاً برای درخواست بک‌لینک (backlink) تماس نگیرید. هیچ لینکی اضافه نمی‌شود مگر اینکه ارتباط بسیار زیادی با پروژه داشته باشد. +نکته: لطفاً برای درخواست بک‌لینک (backlink) تماس نگیرید. هیچ لینکی اضافه نمی‌شود مگر اینکه ارتباط بسیار زیادی با پروژه داشته باشد. -# ‫ تقدیر و تشکر +# تقدیر و تشکر -‫ ایده و طراحی این مجموعه ابتدا از پروژه عالی [wtfjs](https://github.com/denysdovhan/wtfjs) توسط Denys Dovhan الهام گرفته شد. حمایت فوق‌العاده‌ جامعه پایتون باعث شد پروژه به شکل امروزی خود درآید. +ایده و طراحی این مجموعه ابتدا از پروژه عالی [wtfjs](https://github.com/denysdovhan/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 @@ -3866,7 +3866,7 @@ def dict_size(o): * https://github.com/wemake-services/wemake-python-styleguide/search?q=wtfpython&type=Issues * WFTPython discussion threads on [Hacker News](https://news.ycombinator.com/item?id=21862073) and [Reddit](https://www.reddit.com/r/programming/comments/edsh3q/what_the_fck_python_30_exploring_and/). -# ‫ 🎓 مجوز +# 🎓 مجوز [![WTFPL 2.0][license-image]][license-url] @@ -3875,16 +3875,16 @@ def dict_size(o): [license-url]: http://www.wtfpl.net [license-image]: https://img.shields.io/badge/License-WTFPL%202.0-lightgrey.svg?style=flat-square -## ‫ دوستانتان را هم شگفت‌زده کنید! +## دوستانتان را هم شگفت‌زده کنید! -‫ اگر از wtfpython خوشتان آمد، می‌توانید با این لینک‌های سریع آن را با دوستانتان به اشتراک بگذارید: +اگر از wtfpython خوشتان آمد، می‌توانید با این لینک‌های سریع آن را با دوستانتان به اشتراک بگذارید: -‫ [توییتر](https://twitter.com/intent/tweet?url=https://github.com/satwikkansal/wtfpython&text=If%20you%20really%20think%20you%20know%20Python,%20think%20once%20more!%20Check%20out%20wtfpython&hashtags=python,wtfpython) | [لینکدین](https://www.linkedin.com/shareArticle?url=https://github.com/satwikkansal&title=What%20the%20f*ck%20Python!&summary=If%20you%20really%20thing%20you%20know%20Python,%20think%20once%20more!) | [فیسبوک](https://www.facebook.com/dialog/share?app_id=536779657179021&display=page&href=https%3A%2F%2Fgithub.com%2Fsatwikkansal%2Fwtfpython"e=If%20you%20really%20think%20you%20know%20Python%2C%20think%20once%20more!) +[توییتر](https://twitter.com/intent/tweet?url=https://github.com/satwikkansal/wtfpython&text=If%20you%20really%20think%20you%20know%20Python,%20think%20once%20more!%20Check%20out%20wtfpython&hashtags=python,wtfpython) | [لینکدین](https://www.linkedin.com/shareArticle?url=https://github.com/satwikkansal&title=What%20the%20f*ck%20Python!&summary=If%20you%20really%20thing%20you%20know%20Python,%20think%20once%20more!) | [فیسبوک](https://www.facebook.com/dialog/share?app_id=536779657179021&display=page&href=https%3A%2F%2Fgithub.com%2Fsatwikkansal%2Fwtfpython"e=If%20you%20really%20think%20you%20know%20Python%2C%20think%20once%20more!) -## ‫ آیا به یک نسخه pdf نیاز دارید؟ +## آیا به یک نسخه pdf نیاز دارید؟ -‫ من چند درخواست برای نسخه PDF (و epub) کتاب wtfpython دریافت کرده‌ام. برای دریافت این نسخه‌ها به محض آماده شدن، می‌توانید اطلاعات خود را [اینجا](https://form.jotform.com/221593245656057) وارد کنید. +من چند درخواست برای نسخه PDF (و epub) کتاب wtfpython دریافت کرده‌ام. برای دریافت این نسخه‌ها به محض آماده شدن، می‌توانید اطلاعات خود را [اینجا](https://form.jotform.com/221593245656057) وارد کنید. -‫ **همین بود دوستان!** برای دریافت مطالب آینده مشابه این، می‌توانید ایمیل خود را [اینجا](https://form.jotform.com/221593598380062) اضافه کنید. +**همین بود دوستان!** برای دریافت مطالب آینده مشابه این، می‌توانید ایمیل خود را [اینجا](https://form.jotform.com/221593598380062) اضافه کنید. From 2bd726ba98a2e9f8807a1a76314998f62491744f Mon Sep 17 00:00:00 2001 From: Leo Alavi Date: Sat, 5 Apr 2025 21:41:36 +0200 Subject: [PATCH 18/33] Remove RTL indicator --- translations/fa-farsi/README.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/translations/fa-farsi/README.md b/translations/fa-farsi/README.md index 376bd74..79818e2 100644 --- a/translations/fa-farsi/README.md +++ b/translations/fa-farsi/README.md @@ -2231,7 +2231,7 @@ for idx, item in enumerate(list_4): list_4.pop(idx) ``` -‫**خروجی:** +**خروجی:** ```py >>> list_1 [1, 2, 3, 4] @@ -2790,7 +2790,7 @@ def similar_recursive_func(a): `x, y = (0, 1) if True else (None, None)` * برای مورد ۲، عبارت صحیح برای رفتار مورد انتظار این است: -‫`t = ('one',)` یا `t = 'one',` (ویرگول از قلم افتاده است). در غیر این صورت مفسر `t` را به عنوان یک `str` در نظر گرفته و به صورت کاراکتر به کاراکتر روی آن پیمایش می‌کند. +`t = ('one',)` یا `t = 'one',` (ویرگول از قلم افتاده است). در غیر این صورت مفسر `t` را به عنوان یک `str` در نظر گرفته و به صورت کاراکتر به کاراکتر روی آن پیمایش می‌کند. * علامت `()` یک توکن خاص است و نشان‌دهنده‌ی یک `tuple` خالی است. @@ -3693,7 +3693,7 @@ def dict_size(o): * متد `join()` عملیاتی مربوط به رشته (`str`) است، نه لیست (`list`). (در نگاه اول کمی برخلاف انتظار است.) - ** ‫💡 توضیح:** اگر `join()` به‌عنوان متدی روی رشته پیاده‌سازی شود، می‌تواند روی هر شیء قابل پیمایش (`iterable`) از جمله لیست، تاپل و هر نوع تکرارشونده‌ی دیگر کار کند. اگر به‌جای آن روی لیست تعریف می‌شد، باید به‌طور جداگانه برای هر نوع دیگری نیز پیاده‌سازی می‌شد. همچنین منطقی نیست که یک متد مختص رشته روی یک شیء عمومی مانند `list` پیاده شود. + ** 💡 توضیح:** اگر `join()` به‌عنوان متدی روی رشته پیاده‌سازی شود، می‌تواند روی هر شیء قابل پیمایش (`iterable`) از جمله لیست، تاپل و هر نوع تکرارشونده‌ی دیگر کار کند. اگر به‌جای آن روی لیست تعریف می‌شد، باید به‌طور جداگانه برای هر نوع دیگری نیز پیاده‌سازی می‌شد. همچنین منطقی نیست که یک متد مختص رشته روی یک شیء عمومی مانند `list` پیاده شود. * تعدادی عبارت با ظاهری عجیب اما از نظر معنا صحیح: + عبارت `[] = ()` از نظر معنایی صحیح است (باز کردن یا `unpack` کردن یک تاپل خالی درون یک لیست خالی). @@ -3838,7 +3838,7 @@ def dict_size(o): # مشارکت -‫چند روشی که می‌توانید در wtfpython مشارکت داشته باشید: +چند روشی که می‌توانید در wtfpython مشارکت داشته باشید: - پیشنهاد مثال‌های جدید - کمک به ترجمه (به [مشکلات برچسب ترجمه](https://github.com/satwikkansal/wtfpython/issues?q=is%3Aissue+is%3Aopen+label%3Atranslation) مراجعه کنید) From ebe443e0afd5cdf908d1ffe3269a691a82663456 Mon Sep 17 00:00:00 2001 From: Leo Alavi Date: Sat, 5 Apr 2025 21:48:15 +0200 Subject: [PATCH 19/33] Update Farsi translations by replacing bullet indicators with arrow indicators in the README.md file. --- translations/fa-farsi/README.md | 256 ++++++++++++++++---------------- 1 file changed, 128 insertions(+), 128 deletions(-) diff --git a/translations/fa-farsi/README.md b/translations/fa-farsi/README.md index 79818e2..460c3a5 100644 --- a/translations/fa-farsi/README.md +++ b/translations/fa-farsi/README.md @@ -44,73 +44,73 @@ - [استفاده](#استفاده) - [👀 مثال‌ها](#-مثالها) - [بخش: ذهن خود را به چالش بکشید!](#بخش-ذهن-خود-را-به-چالش-بکشید) - - [▶ اول از همه! \*](#-اول-از-همه-) - - [▶ بعضی وقت‌ها رشته‌ها می‌توانند دردسرساز شوند](#-بعضی-وقتها-رشتهها-میتوانند-دردسرساز-شوند) - - [▶ مراقب عملیات‌های زنجیره‌ای باشید](#-مراقب-عملیاتهای-زنجیرهای-باشید) - - [▶ چطور از عملگر `is` استفاده نکنیم](#-چطور-از-عملگر-is-استفاده-نکنیم) - - [▶ کلیدهای هش](#-کلیدهای-هش) - - [▶ در عمق وجود همه ما یکسان هستیم](#-در-عمق-وجود-همه-ما-یکسان-هستیم) - - [▶ بی‌نظمی در خود نظم \*](#-بینظمی-در-خود-نظم-) - - [▶ تلاش کن... \*](#-تلاش-کن-) - - [▶ برای چی؟](#-برای-چی) - - [▶ اختلاف زمانی در محاسبه](#-اختلاف-زمانی-در-محاسبه) - - [▶ هر گردی، گردو نیست](#-هر-گردی-گردو-نیست) - - [▶ یک بازی دوز که توش X همون اول برنده میشه!](#-یک-بازی-دوز-که-توش-X-همون-اول-برنده-میشه) - - [▶ متغیر شرودینگر \*](#-متغیر-شرودینگر-) - - [▶ اول مرغ بوده یا تخم مرغ؟ \*](#-اول-مرغ-بوده-یا-تخم-مرغ-) - - [▶ روابط بین زیرمجموعه کلاس‌ها](#-روابط-بین-زیرمجموعه-کلاسها) - - [▶ ‫ برابری و هویت متدها](#--برابری-و-هویت-متدها) - - [▶ ‫ آل-ترو-یشن \*](#--آل-ترو-یشن-) - - [▶ ‫ رشته‌ها و بک‌اسلش‌ها](#--رشتهها-و-بکاسلشها) - - [▶ ‫ گره نیست، نَه!](#--گره-نیست-نَه) - - [▶ رشته‌های نیمه سه‌نقل‌قولی](#-رشتههای-نیمه-سهنقلقولی) - - [▶ ‫ مشکل بولین ها چیست؟](#--مشکل-بولین-ها-چیست) - - [▶ ‫ ویژگی‌های کلاس و ویژگی‌های نمونه](#--ویژگیهای-کلاس-و-ویژگیهای-نمونه) - - [▶ yielding None](#-yielding-none) - - [▶ Yielding from... return! \*](#-yielding-from-return-) - - [▶ ‫ بازتاب‌ناپذیری \*](#--بازتابناپذیری-) - - [▶ ‫ تغییر دادن اشیای تغییرناپذیر!](#--تغییر-دادن-اشیای-تغییرناپذیر) - - [▶ ‫ متغیری که از اسکوپ بیرونی ناپدید می‌شود](#--متغیری-که-از-اسکوپ-بیرونی-ناپدید-میشود) - - [▶ ‫ تبدیل اسرارآمیز نوع کلید](#--تبدیل-اسرارآمیز-نوع-کلید) - - [▶ ‫ ببینیم می‌توانید این را حدس بزنید؟](#--ببینیم-میتوانید-این-را-حدس-بزنید) - - [▶ ‫ از حد مجاز برای تبدیل رشته به عدد صحیح فراتر می‌رود](#--از-حد-مجاز-برای-تبدیل-رشته-به-عدد-صحیح-فراتر-میرود) + - [◀ اول از همه! \*](#-اول-از-همه-) + - [◀ بعضی وقت‌ها رشته‌ها می‌توانند دردسرساز شوند](#-بعضی-وقتها-رشتهها-میتوانند-دردسرساز-شوند) + - [◀ مراقب عملیات‌های زنجیره‌ای باشید](#-مراقب-عملیاتهای-زنجیرهای-باشید) + - [◀ چطور از عملگر `is` استفاده نکنیم](#-چطور-از-عملگر-is-استفاده-نکنیم) + - [◀ کلیدهای هش](#-کلیدهای-هش) + - [◀ در عمق وجود همه ما یکسان هستیم](#-در-عمق-وجود-همه-ما-یکسان-هستیم) + - [◀ بی‌نظمی در خود نظم \*](#-بینظمی-در-خود-نظم-) + - [◀ تلاش کن... \*](#-تلاش-کن-) + - [◀ برای چی؟](#-برای-چی) + - [◀ اختلاف زمانی در محاسبه](#-اختلاف-زمانی-در-محاسبه) + - [◀ هر گردی، گردو نیست](#-هر-گردی-گردو-نیست) + - [◀ یک بازی دوز که توش X همون اول برنده میشه!](#-یک-بازی-دوز-که-توش-X-همون-اول-برنده-میشه) + - [◀ متغیر شرودینگر \*](#-متغیر-شرودینگر-) + - [◀ اول مرغ بوده یا تخم مرغ؟ \*](#-اول-مرغ-بوده-یا-تخم-مرغ-) + - [◀ روابط بین زیرمجموعه کلاس‌ها](#-روابط-بین-زیرمجموعه-کلاسها) + - [◀ ‫ برابری و هویت متدها](#--برابری-و-هویت-متدها) + - [◀ ‫ آل-ترو-یشن \*](#--آل-ترو-یشن-) + - [◀ ‫ رشته‌ها و بک‌اسلش‌ها](#--رشتهها-و-بکاسلشها) + - [◀ ‫ گره نیست، نَه!](#--گره-نیست-نَه) + - [◀ رشته‌های نیمه سه‌نقل‌قولی](#-رشتههای-نیمه-سهنقلقولی) + - [◀ ‫ مشکل بولین ها چیست؟](#--مشکل-بولین-ها-چیست) + - [◀ ‫ ویژگی‌های کلاس و ویژگی‌های نمونه](#--ویژگیهای-کلاس-و-ویژگیهای-نمونه) + - [◀ yielding None](#-yielding-none) + - [◀ Yielding from... return! \*](#-yielding-from-return-) + - [◀ ‫ بازتاب‌ناپذیری \*](#--بازتابناپذیری-) + - [◀ ‫ تغییر دادن اشیای تغییرناپذیر!](#--تغییر-دادن-اشیای-تغییرناپذیر) + - [◀ ‫ متغیری که از اسکوپ بیرونی ناپدید می‌شود](#--متغیری-که-از-اسکوپ-بیرونی-ناپدید-میشود) + - [◀ ‫ تبدیل اسرارآمیز نوع کلید](#--تبدیل-اسرارآمیز-نوع-کلید) + - [◀ ‫ ببینیم می‌توانید این را حدس بزنید؟](#--ببینیم-میتوانید-این-را-حدس-بزنید) + - [◀ ‫ از حد مجاز برای تبدیل رشته به عدد صحیح فراتر می‌رود](#--از-حد-مجاز-برای-تبدیل-رشته-به-عدد-صحیح-فراتر-میرود) - [‫ بخش: شیب‌های لغزنده](#-بخش-شیبهای-لغزنده) - - [▶ ‫ تغییر یک دیکشنری هنگام پیمایش روی آن](#--تغییر-یک-دیکشنری-هنگام-پیمایش-روی-آن) - - [▶ عملیات سرسختانه‌ی `del`](#-عملیات-سرسختانهی-del) - - [▶ ‫ متغیری که از حوزه خارج است](#--متغیری-که-از-حوزه-خارج-است) - - [▶ ‫ حذف المان‌های لیست در حین پیمایش](#--حذف-المانهای-لیست-در-حین-پیمایش) - - [▶ ‫ زیپِ دارای اتلاف برای پیمایشگرها \*](#--زیپِ-دارای-اتلاف-برای-پیمایشگرها-) - - [▶ ‫ نشت کردن متغیرهای حلقه!](#--نشت-کردن-متغیرهای-حلقه) - - [▶ ‫ مراقب آرگومان‌های تغییرپذیر پیش‌فرض باشید!](#--مراقب-آرگومانهای-تغییرپذیر-پیشفرض-باشید) - - [▶ ‫ گرفتن استثناها (Exceptions)](#--گرفتن-استثناها-exceptions) - - [▶ ‫ عملوندهای یکسان، داستانی متفاوت!](#--عملوندهای-یکسان-داستانی-متفاوت) - - [▶ ‫ تفکیک نام‌ها با نادیده گرفتن حوزه‌ی کلاس](#--تفکیک-نامها-با-نادیده-گرفتن-حوزهی-کلاس) - - [▶ ‫ گرد کردن به روش بانکدار \*](#--گرد-کردن-به-روش-بانکدار-) - - [▶ ‫ سوزن‌هایی در انبار کاه \*](#--سوزنهایی-در-انبار-کاه-) - - [▶ ‫ تقسیم‌ها \*](#--تقسیمها-) - - [▶ واردسازی‌های عمومی \*](#-واردسازیهای-عمومی-) - - [▶ ‫ همه چیز مرتب شده؟ \*](#--همه-چیز-مرتب-شده-) - - [▶ ‫ زمان نیمه‌شب وجود ندارد؟](#--زمان-نیمهشب-وجود-ندارد) + - [◀ ‫ تغییر یک دیکشنری هنگام پیمایش روی آن](#--تغییر-یک-دیکشنری-هنگام-پیمایش-روی-آن) + - [◀ عملیات سرسختانه‌ی `del`](#-عملیات-سرسختانهی-del) + - [◀ ‫ متغیری که از حوزه خارج است](#--متغیری-که-از-حوزه-خارج-است) + - [◀ ‫ حذف المان‌های لیست در حین پیمایش](#--حذف-المانهای-لیست-در-حین-پیمایش) + - [◀ ‫ زیپِ دارای اتلاف برای پیمایشگرها \*](#--زیپِ-دارای-اتلاف-برای-پیمایشگرها-) + - [◀ ‫ نشت کردن متغیرهای حلقه!](#--نشت-کردن-متغیرهای-حلقه) + - [◀ ‫ مراقب آرگومان‌های تغییرپذیر پیش‌فرض باشید!](#--مراقب-آرگومانهای-تغییرپذیر-پیشفرض-باشید) + - [◀ ‫ گرفتن استثناها (Exceptions)](#--گرفتن-استثناها-exceptions) + - [◀ ‫ عملوندهای یکسان، داستانی متفاوت!](#--عملوندهای-یکسان-داستانی-متفاوت) + - [◀ ‫ تفکیک نام‌ها با نادیده گرفتن حوزه‌ی کلاس](#--تفکیک-نامها-با-نادیده-گرفتن-حوزهی-کلاس) + - [◀ ‫ گرد کردن به روش بانکدار \*](#--گرد-کردن-به-روش-بانکدار-) + - [◀ ‫ سوزن‌هایی در انبار کاه \*](#--سوزنهایی-در-انبار-کاه-) + - [◀ ‫ تقسیم‌ها \*](#--تقسیمها-) + - [◀ واردسازی‌های عمومی \*](#-واردسازیهای-عمومی-) + - [◀ ‫ همه چیز مرتب شده؟ \*](#--همه-چیز-مرتب-شده-) + - [◀ ‫ زمان نیمه‌شب وجود ندارد؟](#--زمان-نیمهشب-وجود-ندارد) - [‫ بخش: گنجینه‌های پنهان!](#-بخش-گنجینههای-پنهان) - - [▶ ‫ خب پایتون، می‌توانی کاری کنی پرواز کنم؟](#--خب-پایتون-میتوانی-کاری-کنی-پرواز-کنم) - - [▶ ‫ `goto`، ولی چرا؟](#--goto-ولی-چرا) - - [▶ ‫ خودتان را آماده کنید!](#--خودتان-را-آماده-کنید) - - [▶ ‫ بیایید با «عمو زبان مهربان برای همیشه» آشنا شویم](#--بیایید-با-عمو-زبان-مهربان-برای-همیشه-آشنا-شویم) - - [▶ ‫ حتی پایتون هم می‌داند که عشق پیچیده است](#--حتی-پایتون-هم-میداند-که-عشق-پیچیده-است) - - [▶ ‫ بله، این واقعاً وجود دارد!](#--بله-این-واقعاً-وجود-دارد) - - [▶ Ellipsis \*](#-ellipsis-) - - [▶ ‫ بی‌نهایت (`Inpinity`)](#--بینهایت-inpinity) - - [▶ ‫ بیایید خرابکاری کنیم](#--بیایید-خرابکاری-کنیم) + - [◀ ‫ خب پایتون، می‌توانی کاری کنی پرواز کنم؟](#--خب-پایتون-میتوانی-کاری-کنی-پرواز-کنم) + - [◀ ‫ `goto`، ولی چرا؟](#--goto-ولی-چرا) + - [◀ ‫ خودتان را آماده کنید!](#--خودتان-را-آماده-کنید) + - [◀ ‫ بیایید با «عمو زبان مهربان برای همیشه» آشنا شویم](#--بیایید-با-عمو-زبان-مهربان-برای-همیشه-آشنا-شویم) + - [◀ ‫ حتی پایتون هم می‌داند که عشق پیچیده است](#--حتی-پایتون-هم-میداند-که-عشق-پیچیده-است) + - [◀ ‫ بله، این واقعاً وجود دارد!](#--بله-این-واقعاً-وجود-دارد) + - [◀ Ellipsis \*](#-ellipsis-) + - [◀ ‫ بی‌نهایت (`Inpinity`)](#--بینهایت-inpinity) + - [◀ ‫ بیایید خرابکاری کنیم](#--بیایید-خرابکاری-کنیم) - [‫ بخش: ظاهرها فریبنده‌اند!](#-بخش-ظاهرها-فریبندهاند) - - [▶ ‫ خطوط را رد می‌کند؟](#--خطوط-را-رد-میکند) - - [▶ ‫ تله‌پورت کردن](#--تلهپورت-کردن) - - [▶ ‫ خب، یک جای کار مشکوک است...](#--خب-یک-جای-کار-مشکوک-است) + - [◀ ‫ خطوط را رد می‌کند؟](#--خطوط-را-رد-میکند) + - [◀ ‫ تله‌پورت کردن](#--تلهپورت-کردن) + - [◀ ‫ خب، یک جای کار مشکوک است...](#--خب-یک-جای-کار-مشکوک-است) - [بخش: متفرقه](#بخش-متفرقه) - - [‫ ▶ `+=` سریع‌تر است](#---سریعتر-است) - - [‫ ▶ بیایید یک رشته‌ی بزرگ بسازیم!](#--بیایید-یک-رشتهی-بزرگ-بسازیم) - - [▶ ‫ کُند کردن جستجوها در `dict` \*](#---کُند-کردن-جستجوها-در-dict-) - - [‫ ▶ حجیم کردن دیکشنری نمونه‌ها (`instance dicts`) \*](#--حجیم-کردن-دیکشنری-نمونهها-instance-dicts-) - - [‫ ▶ موارد جزئی \*](#---موارد-جزئی-) + - [‫ ◀ `+=` سریع‌تر است](#---سریعتر-است) + - [‫ ◀ بیایید یک رشته‌ی بزرگ بسازیم!](#--بیایید-یک-رشتهی-بزرگ-بسازیم) + - [◀ ‫ کُند کردن جستجوها در `dict` \*](#---کُند-کردن-جستجوها-در-dict-) + - [‫ ◀ حجیم کردن دیکشنری نمونه‌ها (`instance dicts`) \*](#--حجیم-کردن-دیکشنری-نمونهها-instance-dicts-) + - [‫ ◀ موارد جزئی \*](#---موارد-جزئی-) - [‫ مشارکت](#-مشارکت) - [‫ تقدیر و تشکر](#-تقدیر-و-تشکر) - [‫ چند لینک جالب!](#-چند-لینک-جالب) @@ -124,7 +124,7 @@ همه مثال‌ها به صورت زیر ساخته می‌شوند: -> ### ▶ یه اسم خوشگل +> ### ◀ یه اسم خوشگل > > ```py > # راه اندازی کد @@ -175,7 +175,7 @@ ## بخش: ذهن خود را به چالش بکشید! -### ▶ اول از همه! * +### ◀ اول از همه! * @@ -298,7 +298,7 @@ if a := some_func(): --- -### ▶ بعضی وقت‌ها رشته‌ها می‌توانند دردسرساز شوند +### ◀ بعضی وقت‌ها رشته‌ها می‌توانند دردسرساز شوند 1\. @@ -383,7 +383,7 @@ False --- -### ▶ مراقب عملیات‌های زنجیره‌ای باشید +### ◀ مراقب عملیات‌های زنجیره‌ای باشید ```py >>> (False == False) in [False] # منطقیه @@ -427,7 +427,7 @@ False --- -### ▶ چطور از عملگر `is` استفاده نکنیم +### ◀ چطور از عملگر `is` استفاده نکنیم عبارت پایین خیلی معروفه و تو کل اینترنت موجوده. @@ -552,7 +552,7 @@ False --- -### ▶ کلیدهای هش +### ◀ کلیدهای هش 1\. ```py @@ -617,7 +617,7 @@ complex --- -### ▶ در عمق وجود همه ما یکسان هستیم +### ◀ در عمق وجود همه ما یکسان هستیم ```py class WTF: @@ -667,7 +667,7 @@ True --- -### ▶ بی‌نظمی در خود نظم * +### ◀ بی‌نظمی در خود نظم * ```py from collections import OrderedDict @@ -766,7 +766,7 @@ TypeError: unhashable type: 'dict' --- -### ▶ تلاش کن... * +### ◀ تلاش کن... * ```py def some_func(): @@ -828,7 +828,7 @@ Iteration 0 --- -### ▶ برای چی؟ +### ◀ برای چی؟ ```py some_string = "wtf" @@ -880,7 +880,7 @@ for i, some_dict[i] in enumerate(some_string): --- -### ▶ اختلاف زمانی در محاسبه +### ◀ اختلاف زمانی در محاسبه 1\. ```py @@ -949,7 +949,7 @@ array_4 = [400, 500, 600] --- -### ▶ هر گردی، گردو نیست +### ◀ هر گردی، گردو نیست ```py >>> 'something' is not None @@ -966,7 +966,7 @@ False --- -### ▶ یک بازی دوز که توش X همون اول برنده میشه! +### ◀ یک بازی دوز که توش X همون اول برنده میشه! ```py @@ -1026,7 +1026,7 @@ board = [row] * 3 --- -### ▶ متغیر شرودینگر * +### ◀ متغیر شرودینگر * @@ -1105,7 +1105,7 @@ ClosureVars(nonlocals={}, globals={}, builtins={}, unbound=set()) --- -### ▶ اول مرغ بوده یا تخم مرغ؟ * +### ◀ اول مرغ بوده یا تخم مرغ؟ * 1\. ```py @@ -1157,7 +1157,7 @@ False --- -### ▶ روابط بین زیرمجموعه کلاس‌ها +### ◀ روابط بین زیرمجموعه کلاس‌ها **خروجی:** ```py @@ -1181,7 +1181,7 @@ False --- -### ▶ برابری و هویت متدها +### ◀ برابری و هویت متدها 1. @@ -1270,7 +1270,7 @@ True * ایجاد شیءهای "متد" جدید در هر بار فراخوانی متدهای نمونه و نیاز به اصلاح آرگومان‌ها برای درج `self`، عملکرد را به شدت تحت تأثیر قرار می‌داد. CPython 3.7 [این مشکل را حل کرد](https://bugs.python.org/issue26110) با معرفی opcodeهای جدیدی که فراخوانی متدها را بدون ایجاد شیء متد موقتی مدیریت می‌کنند. این به شرطی است که تابع دسترسی‌یافته واقعاً فراخوانی شود، بنابراین قطعه‌کدهای اینجا تحت تأثیر قرار نمی‌گیرند و همچنان متد ایجاد می‌کنند :) -### ▶ آل-ترو-یشن * +### ◀ آل-ترو-یشن * @@ -1308,7 +1308,7 @@ True --- -### ▶ کاما‌ی شگفت‌انگیز +### ◀ کاما‌ی شگفت‌انگیز **خروجی (< 3.6):** @@ -1340,7 +1340,7 @@ SyntaxError: invalid syntax --- -### ▶ رشته‌ها و بک‌اسلش‌ها +### ◀ رشته‌ها و بک‌اسلش‌ها **خروجی:** ```py @@ -1383,7 +1383,7 @@ True --- -### ▶ گره نیست، نَه! +### ◀ گره نیست، نَه! ```py x = True @@ -1410,7 +1410,7 @@ SyntaxError: invalid syntax --- -### ▶ رشته‌های نیمه سه‌نقل‌قولی +### ◀ رشته‌های نیمه سه‌نقل‌قولی **خروجی:** ```py @@ -1439,7 +1439,7 @@ SyntaxError: EOF while scanning triple-quoted string literal --- -### ▶ مشکل بولین ها چیست؟ +### ◀ مشکل بولین ها چیست؟ 1\. @@ -1529,7 +1529,7 @@ I have lost faith in truth! --- -### ▶ ویژگی‌های کلاس و ویژگی‌های نمونه +### ◀ ویژگی‌های کلاس و ویژگی‌های نمونه 1\. ```py @@ -1600,7 +1600,7 @@ True --- -### ▶ yielding None +### ◀ yielding None ```py some_iterable = ('a', 'b') @@ -1633,7 +1633,7 @@ def some_func(val): --- -### ▶ Yielding from... return! * +### ◀ Yielding from... return! * 1\. @@ -1698,7 +1698,7 @@ def some_func(x): --- -### ▶ بازتاب‌ناپذیری * +### ◀ بازتاب‌ناپذیری * @@ -1774,7 +1774,7 @@ True --- -### ▶ تغییر دادن اشیای تغییرناپذیر! +### ◀ تغییر دادن اشیای تغییرناپذیر! @@ -1813,7 +1813,7 @@ TypeError: 'tuple' object does not support item assignment --- -### ▶ متغیری که از اسکوپ بیرونی ناپدید می‌شود +### ◀ متغیری که از اسکوپ بیرونی ناپدید می‌شود ```py @@ -1895,7 +1895,7 @@ NameError: name 'e' is not defined --- -### ▶ تبدیل اسرارآمیز نوع کلید +### ◀ تبدیل اسرارآمیز نوع کلید ```py class SomeClass(str): @@ -1951,7 +1951,7 @@ str --- -### ▶ ببینیم می‌توانید این را حدس بزنید؟ +### ◀ ببینیم می‌توانید این را حدس بزنید؟ ```py a, b = a[b] = {}, 5 @@ -2010,7 +2010,7 @@ a, b = a[b] = {}, 5 --- -### ▶ از حد مجاز برای تبدیل رشته به عدد صحیح فراتر می‌رود +### ◀ از حد مجاز برای تبدیل رشته به عدد صحیح فراتر می‌رود ```py >>> # Python 3.10.6 >>> int("2" * 5432) @@ -2049,7 +2049,7 @@ ValueError: Exceeds the limit (4300) for integer string conversion: ## بخش: شیب‌های لغزنده -### ▶ تغییر یک دیکشنری هنگام پیمایش روی آن +### ◀ تغییر یک دیکشنری هنگام پیمایش روی آن ```py x = {0: None} @@ -2085,7 +2085,7 @@ for i in x: --- -### ▶ عملیات سرسختانه‌ی `del` +### ◀ عملیات سرسختانه‌ی `del` @@ -2130,7 +2130,7 @@ Deleted! --- -### ▶ متغیری که از حوزه خارج است +### ◀ متغیری که از حوزه خارج است 1\. @@ -2210,7 +2210,7 @@ UnboundLocalError: local variable 'a' referenced before assignment --- -### ▶ حذف المان‌های لیست در حین پیمایش +### ◀ حذف المان‌های لیست در حین پیمایش ```py list_1 = [1, 2, 3, 4] @@ -2271,7 +2271,7 @@ for idx, item in enumerate(list_4): --- -### ▶ زیپِ دارای اتلاف برای پیمایشگرها * +### ◀ زیپِ دارای اتلاف برای پیمایشگرها * ```py @@ -2320,7 +2320,7 @@ for idx, item in enumerate(list_4): --- -### ▶ نشت کردن متغیرهای حلقه! +### ◀ نشت کردن متغیرهای حلقه! 1\. ```py @@ -2384,7 +2384,7 @@ print(x, ': x in global') --- -### ▶ مراقب آرگومان‌های تغییرپذیر پیش‌فرض باشید! +### ◀ مراقب آرگومان‌های تغییرپذیر پیش‌فرض باشید! ```py @@ -2442,7 +2442,7 @@ def some_func(default_arg=[]): --- -### ▶ گرفتن استثناها (Exceptions) +### ◀ گرفتن استثناها (Exceptions) ```py some_list = [1, 2, 3] @@ -2517,7 +2517,7 @@ SyntaxError: invalid syntax --- -### ▶ عملوندهای یکسان، داستانی متفاوت! +### ◀ عملوندهای یکسان، داستانی متفاوت! 1\. ```py @@ -2558,7 +2558,7 @@ a += [5, 6, 7, 8] --- -### ▶ تفکیک نام‌ها با نادیده گرفتن حوزه‌ی کلاس +### ◀ تفکیک نام‌ها با نادیده گرفتن حوزه‌ی کلاس 1\. ```py @@ -2601,7 +2601,7 @@ class SomeClass: --- -### ▶ گرد کردن به روش بانکدار * +### ◀ گرد کردن به روش بانکدار * بیایید یک تابع ساده برای به‌دست‌آوردن عنصر میانی یک لیست پیاده‌سازی کنیم: ```py @@ -2651,7 +2651,7 @@ def get_middle(some_list): --- -### ▶ سوزن‌هایی در انبار کاه * +### ◀ سوزن‌هایی در انبار کاه * @@ -2828,7 +2828,7 @@ def similar_recursive_func(a): --- -### ▶ تقسیم‌ها * +### ◀ تقسیم‌ها * ```py >>> 'a'.split() @@ -2864,7 +2864,7 @@ def similar_recursive_func(a): --- -### ▶ واردسازی‌های عمومی * +### ◀ واردسازی‌های عمومی * @@ -2923,7 +2923,7 @@ NameError: name '_another_weird_name_func' is not defined --- -### ▶ همه چیز مرتب شده؟ * +### ◀ همه چیز مرتب شده؟ * @@ -2963,7 +2963,7 @@ False --- -### ▶ زمان نیمه‌شب وجود ندارد؟ +### ◀ زمان نیمه‌شب وجود ندارد؟ ```py from datetime import datetime @@ -3001,7 +3001,7 @@ Before Python 3.5, the boolean value for `datetime.time` object was considered t این بخش شامل چند مورد جالب و کمتر شناخته‌شده درباره‌ی پایتون است که بیشتر مبتدی‌هایی مثل من از آن بی‌خبرند (البته دیگر اینطور نیست). -### ▶ خب پایتون، می‌توانی کاری کنی پرواز کنم؟ +### ◀ خب پایتون، می‌توانی کاری کنی پرواز کنم؟ خب، بفرمایید @@ -3019,7 +3019,7 @@ Sshh... It's a super-secret. --- -### ▶ `goto`، ولی چرا؟ +### ◀ `goto`، ولی چرا؟ ```py @@ -3048,7 +3048,7 @@ Freedom! --- -### ▶ خودتان را آماده کنید! +### ◀ خودتان را آماده کنید! اگر جزو افرادی هستید که دوست ندارند در پایتون برای مشخص کردن محدوده‌ها از فضای خالی (whitespace) استفاده کنند، می‌توانید با ایمپورت کردن ماژول زیر از آکولاد `{}` به سبک زبان C استفاده کنید: @@ -3073,7 +3073,7 @@ SyntaxError: not a chance --- -### ▶ بیایید با «عمو زبان مهربان برای همیشه» آشنا شویم +### ◀ بیایید با «عمو زبان مهربان برای همیشه» آشنا شویم **خروجی (Python 3.x)** ```py @@ -3106,7 +3106,7 @@ True --- -### ▶ حتی پایتون هم می‌داند که عشق پیچیده است +### ◀ حتی پایتون هم می‌داند که عشق پیچیده است ```py import this @@ -3163,7 +3163,7 @@ True --- -### ▶ بله، این واقعاً وجود دارد! +### ◀ بله، این واقعاً وجود دارد! **عبارت `else` برای حلقه‌ها.** یک مثال معمول آن می‌تواند چنین باشد: @@ -3207,7 +3207,7 @@ Try block executed successfully... - عبارت `else` پس از بلاک `try` به عنوان «عبارت تکمیل» (`completion clause`) نیز شناخته می‌شود؛ چراکه رسیدن به عبارت `else` در ساختار `try` به این معنی است که بلاک `try` بدون رخ دادن استثنا با موفقیت تکمیل شده است. --- -### ▶ Ellipsis * +### ◀ Ellipsis * ```py def some_func(): @@ -3269,7 +3269,7 @@ Ellipsis --- -### ▶ بی‌نهایت (`Inpinity`) +### ◀ بی‌نهایت (`Inpinity`) این املای کلمه تعمداً به همین شکل نوشته شده است. لطفاً برای اصلاح آن درخواست (`patch`) ارسال نکنید. @@ -3288,7 +3288,7 @@ Ellipsis --- -### ▶ بیایید خرابکاری کنیم +### ◀ بیایید خرابکاری کنیم 1\. ```py @@ -3366,7 +3366,7 @@ AttributeError: 'A' object has no attribute '__variable' ## بخش: ظاهرها فریبنده‌اند! -### ▶ خطوط را رد می‌کند؟ +### ◀ خطوط را رد می‌کند؟ **خروجی:** ```py @@ -3402,7 +3402,7 @@ False --- -### ▶ تله‌پورت کردن +### ◀ تله‌پورت کردن @@ -3435,7 +3435,7 @@ def energy_receive(): --- -### ▶ خب، یک جای کار مشکوک است... +### ◀ خب، یک جای کار مشکوک است... ```py def square(x): @@ -3480,7 +3480,7 @@ def square(x): ## بخش: متفرقه -### ▶ `+=` سریع‌تر است +### ◀ `+=` سریع‌تر است ```py @@ -3497,7 +3497,7 @@ def square(x): --- -### ▶ بیایید یک رشته‌ی بزرگ بسازیم! +### ◀ بیایید یک رشته‌ی بزرگ بسازیم! ```py def add_string_with_plus(iters): @@ -3594,7 +3594,7 @@ timeit.timeit('add_string_with_plus(10000)', number=1000, globals=globals()) --- -### ▶ کُند کردن جستجوها در `dict` * +### ◀ کُند کردن جستجوها در `dict` * ```py some_dict = {str(i): 1 for i in range(1_000_000)} @@ -3627,7 +3627,7 @@ KeyError: 1 + این فرایند برای آن نمونه‌ی خاص از دیکشنری غیرقابل بازگشت است و حتی لازم نیست کلید موردنظر در دیکشنری موجود باشد. به همین دلیل است که حتی تلاش ناموفق برای دسترسی به کلیدی ناموجود نیز باعث ایجاد همین تأثیر (کند شدن جستجو) می‌شود. -### ▶ حجیم کردن دیکشنری نمونه‌ها (`instance dicts`) * +### ◀ حجیم کردن دیکشنری نمونه‌ها (`instance dicts`) * ```py import sys @@ -3689,7 +3689,7 @@ def dict_size(o): + نکته‌ای کوچک برای کاهش مصرف حافظه‌ی برنامه: هرگز صفات نمونه‌ها را حذف نکنید و حتماً تمام صفات را در متد `__init__` تعریف و مقداردهی اولیه کنید! -### ▶ موارد جزئی * +### ◀ موارد جزئی * * متد `join()` عملیاتی مربوط به رشته (`str`) است، نه لیست (`list`). (در نگاه اول کمی برخلاف انتظار است.) From 78aab13e40505ba63e3d5ac0c2230f45fd8ce4ea Mon Sep 17 00:00:00 2001 From: Leo Alavi Date: Sat, 5 Apr 2025 21:51:35 +0200 Subject: [PATCH 20/33] Unify the translation of explanations --- translations/fa-farsi/README.md | 74 ++++++++++++++++----------------- 1 file changed, 37 insertions(+), 37 deletions(-) diff --git a/translations/fa-farsi/README.md b/translations/fa-farsi/README.md index 460c3a5..ba54104 100644 --- a/translations/fa-farsi/README.md +++ b/translations/fa-farsi/README.md @@ -238,7 +238,7 @@ SyntaxError: invalid syntax -#### 💡 توضیحات +#### 💡 توضیح **مرور سریع بر عملگر Walrus** @@ -359,7 +359,7 @@ False منطقیه، نه؟ -#### 💡 توضیحات: +#### 💡 توضیح: + در قطعه‌کد اول و دوم، رفتار کد به دلیل یک بهینه سازی در CPython است (به نام داوطلب سازی رشته‌ها) که باعث می‌شود از برخی مقادیر غیرقابل تغییر، به جای مقداردهی مجدد، دوباره استفاده شود. + بیشتر متغیرهایی که به‌این صورت جایگزین می‌شوند، در حافظه دستگاه به مقدار داوطلب خود اشاره می‌کنند (تا از حافظه کمتری استفاده شود) + در قطعه‌کدهای بالا، رشته‌ها به‌صورت غیرمستقیم داوطلب می‌شوند. تصمیم اینکه رشته‌ها چه زمانی به صورت غیرمستقیم داوطلب شوند به نحوه پیاده‌سازی و مقداردهی آن‌ها بستگی دارد. برخی قوانین وجود دارند تا بتوانیم داوطلب شدن یا نشدن یک رشته را حدس بزنیم: @@ -406,7 +406,7 @@ False 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 است. فقط دقت کنید که هر عبارت یک بار ارزیابی می‌شود. @@ -476,7 +476,7 @@ True False ``` -#### 💡 توضیحات: +#### 💡 توضیح: **فرض بین عملگرهای `is` و `==`** @@ -582,7 +582,7 @@ complex خب، چرا Python همه جارو گرفت؟ -#### 💡 توضیحات +#### 💡 توضیح * تو دیکشنری‌های پایتون چیزی که کلیدها رو یگانه میکنه مقدار کلیدهاست، نه شناسه اون‌ها. پس با اینکه `5`، `5.0` و `5 + 0j` شیءهای متمایزی از نوع‌های متفاوتی هستند ولی از اون جایی که مقدارشون با هم برابره، نمیتونن داخل یه `dict` به عنوان کلید جدا از هم باشن (حتی به عنوان مقادیر داخل یه `set` نمیتونن باشن). وقتی بخواید داخل یه دیکشنری جست‌وجو کنید، به محض اینکه یکی از این داده‌ها رو وارد کنید، مقدار نگاشته‌شده به کلیدی که مقدار برابر با اون داده داره ولی نوعش متفاوته، با موفقیت برگردونده میشه (به جای اینکه به ارور `KeyError` بردخورد کنید.). ```py >>> 5 == 5.0 == 5 + 0j @@ -636,7 +636,7 @@ True True ``` -#### 💡 توضیحات: +#### 💡 توضیح: * وقتی `id` صدا زده شد، پایتون یک شیء با کلاس `WTF` ساخت و اون رو به تابع `id` داد. تابع `id` شناسه این شیء رو میگیره (درواقع آدرس اون شیء در حافظه دستگاه) و شیء رو حذف میکنه. * وقتی این کار رو دو بار متوالی انجام بدیم، پایتون آدرس یکسانی رو به شیء دوم اختصاص میده. از اونجایی که (در CPython) تابع `id` از آدرس شیءها توی حافظه به عنوان شناسه برای اون‌ها استفاده میکنه، پس شناسه این دو شیء یکسانه. * پس، شناسه یک شیء تا زمانی که اون شیء وجود داره، منحصربه‌فرده. بعد از اینکه اون شیء حذف میشه یا قبل از اینکه اون شیء به وجود بیاد، چیز دیگه‌ای میتونه اون شناسه رو داشته باشه. @@ -727,7 +727,7 @@ TypeError: unhashable type: 'dict' چی شد؟ -#### 💡 توضیحات: +#### 💡 توضیح: - دلیل اینکه این مقایسه بین متغیرهای `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` و شیءهای قابل نگاشت دیگر به ترتیب اعضای آن‌ها بستگی ندارد و مقایسه همانند دیکشنری‌های عادی انجام می‌شود. @@ -819,7 +819,7 @@ Iteration 0 ``` -#### 💡 توضیحات: +#### 💡 توضیح: - وقتی یک عبارت `return`، `break` یا `continue` داخل بخش `try` از یک عبارت "try...finally" اجرا میشه، بخش `fianlly` هم هنگام خارج شدن اجرا میشه. - مقدار بازگشتی یک تابع از طریق آخرین عبارت `return` که داخل تابع اجرا میشه، مشخص میشه. از اونجایی که بخش `finally` همیشه اجرا میشه، عبارت `return` که داخل بخش `finally` هست آخرین عبارتیه که اجرا میشه. @@ -843,7 +843,7 @@ for i, some_dict[i] in enumerate(some_string): {0: 'w', 1: 't', 2: 'f'} ``` -#### 💡 توضیحات: +#### 💡 توضیح: * یک حلقه `for` در [گرامر پایتون](https://docs.python.org/3/reference/grammar.html) این طور تعریف میشه: ``` for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite] @@ -866,7 +866,7 @@ for i, some_dict[i] in enumerate(some_string): آیا انتظار داشتید که حلقه فقط یک بار اجرا بشه؟ - **💡 توضیحات:** + **💡 توضیح:** - عبارت مقداردهی `i = 10` به خاطر نحوه کار کردن حلقه‌ها، هیچوقت باعث تغییر در تکرار حلقه نمیشه. قبل از شروع هر تکرار، مقدار بعدی که توسط شیء قابل تکرار (که در اینجا `range(4)` است) ارائه میشه، از بسته خارج میشه و به متغیرهای لیست هدف (که در اینجا `i` است) مقداردهی میشه. @@ -935,7 +935,7 @@ array_4 = [400, 500, 600] [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` رو برمیگردونه @@ -958,7 +958,7 @@ True False ``` -#### 💡 توضیحات +#### 💡 توضیح - عملگر `is not` یک عملگر باینری واحده و رفتارش متفاوت تر از استفاده `is` و `not` به صورت جداگانه‌ست. - عملگر `is not` مقدار `False` رو برمیگردونه اگر متغیرها در هردو سمت این عملگر به شیء یکسانی اشاره کنند و درغیر این صورت، مقدار `True` برمیگردونه - در مثال بالا، عبارت `(not None)` برابره با مقدار `True` از اونجایی که مقدار `None` در زمینه boolean به `False` تبدیل میشه. پس کل عبارت معادل عبارت `'something' is True` میشه. @@ -992,7 +992,7 @@ board = [row] * 3 ما که سه‌تا `"X"` نذاشتیم. گذاشتیم مگه؟ -#### 💡 توضیحات: +#### 💡 توضیح: وقتی متغیر `row` رو تشکیل میدیم، تصویر زیر نشون میده که چه اتفاقی در حافظه دستگاه میافته. @@ -1060,7 +1060,7 @@ funcs_results = [func() for func in funcs] [512, 512, 512, 512, 512, 512, 512, 512, 512, 512] ``` -#### 💡 توضیحات: +#### 💡 توضیح: * وقتی یک تابع رو در داخل یک حلقه تعریف می‌کنیم که در بدنه‌اش از متغیر اون حلقه استفاده شده، بست این تابع به *متغیر* وصله، نه *مقدار* اون. تابع به جای اینکه از مقدار `x` در زمان تعریف تابع استفاده کنه، در زمینه اطرافش دنبال `x` می‌گرده. پس همه این توابع از آخرین مقداری که به متغیر `x` مقداردهی شده برای محاسباتشون استفاده می‌کنند. ما می‌تونیم ببینیم که این توابع از متغیر `x` که در زمینه اطرافشون (*نه* از متغیر محلی) هست، استفاده می‌کنند، به این صورت: ```py @@ -1143,7 +1143,7 @@ False ``` -#### 💡 توضیحات +#### 💡 توضیح - در پایتون، `type` یک [متاکلاس](https://realpython.com/python-metaclasses/) است. - در پایتون **همه چیز** یک `object` است، که کلاس‌ها و همچنین نمونه‌هاشون (یا همان instance های کلاس‌ها) هم شامل این موضوع میشن. @@ -1172,7 +1172,7 @@ False ما انتظار داشتیم که روابط بین زیرکلاس‌ها، انتقالی باشند، درسته؟ (یعنی اگه `A` زیرکلاس `B` باشه و `B` هم زیرکلاس `C` باشه، کلس `A` __باید__ زیرکلاس `C` باشه) -#### 💡 توضیحات: +#### 💡 توضیح: * روابط بین زیرکلاس‌ها در پایتون لزوما انتقالی نیستند. همه مجازند که تابع `__subclasscheck__` دلخواه خودشون رو در یک متاکلاس تعریف کنند. * وقتی عبارت `issubclass(cls, Hashable)` اجرا میشه، برنامه دنبال یک تابع "غیر نادرست" (یا non-Falsy) در `cls` یا هرچیزی که ازش ارث‌بری می‌کنه، می‌گرده. @@ -1238,7 +1238,7 @@ True دسترسی به `classm` یا `method` دو بار، اشیایی برابر اما نه *یکسان* را برای همان نمونه از `SomeClass` ایجاد می‌کند. -#### 💡 توضیحات +#### 💡 توضیح * تابع‌ها [وصاف](https://docs.python.org/3/howto/descriptor.html) هستند. هر زمان که تابعی به عنوان یک ویژگی فراخوانی شود، وصف فعال می‌شود و یک شیء متد ایجاد می‌کند که تابع را به شیء صاحب آن ویژگی "متصل" می‌کند. اگر این متد فراخوانی شود، تابع را با ارسال ضمنی شیء متصل‌شده به عنوان اولین آرگومان صدا می‌زند (به این ترتیب است که `self` را به عنوان اولین آرگومان دریافت می‌کنیم، با وجود اینکه آن را به‌طور صریح ارسال نکرده‌ایم). ```py >>> o1.method @@ -1494,7 +1494,7 @@ I have lost faith in truth! -#### 💡 توضیحات: +#### 💡 توضیح: * در پایتون، `bool` زیرکلاسی از `int` است @@ -1751,7 +1751,7 @@ True -#### 💡 توضیحات: +#### 💡 توضیح: - `'inf'` و `'nan'` رشته‌هایی خاص هستند (نسبت به حروف بزرگ و کوچک حساس نیستند) که وقتی به‌طور صریح به نوع `float` تبدیل شوند، به ترتیب برای نمایش "بی‌نهایت" ریاضی و "عدد نیست" استفاده می‌شوند. @@ -1800,7 +1800,7 @@ TypeError: 'tuple' object does not support item assignment اما من فکر می‌کردم تاپل‌ها تغییرناپذیر هستند... -#### 💡 توضیحات: +#### 💡 توضیح: * نقل‌قول از https://docs.python.org/3/reference/datamodel.html @@ -1836,7 +1836,7 @@ except Exception as e: NameError: name 'e' is not defined ``` -#### 💡 توضیحات: +#### 💡 توضیح: * منبع: [مستندات رسمی پایتون](https://docs.python.org/3/reference/compound_stmts.html#except) هنگامی که یک استثنا (Exception) با استفاده از کلمه‌ی کلیدی `as` به متغیری تخصیص داده شود، این متغیر در انتهای بلاکِ `except` پاک می‌شود. این رفتار مشابه کد زیر است: @@ -1916,7 +1916,7 @@ str str ``` -#### 💡 توضیحات: +#### 💡 توضیح: * هر دو شیء `s` و رشته‌ی `"s"` به دلیل ارث‌بری `SomeClass` از متد `__hash__` کلاس `str`، هش یکسانی دارند. * عبارت `SomeClass("s") == "s"` به دلیل ارث‌بری `SomeClass` از متد `__eq__` کلاس `str` برابر با `True` ارزیابی می‌شود. @@ -2290,7 +2290,7 @@ for idx, item in enumerate(list_4): ``` عنصر `3` از لیست `numbers` چه شد؟ -#### 💡 توضیحات: +#### 💡 توضیح: - بر اساس [مستندات](https://docs.python.org/3.3/library/functions.html#zip) پایتون، پیاده‌سازی تقریبی تابع `zip` به شکل زیر است: ```py @@ -2374,7 +2374,7 @@ print(x, ': x in global') 1 ``` -#### 💡 توضیحات: +#### 💡 توضیح: - در پایتون، حلقه‌های `for` از حوزه (*scope*) فعلی که در آن قرار دارند استفاده می‌کنند و متغیرهای تعریف‌شده در حلقه حتی بعد از اتمام حلقه نیز باقی می‌مانند. این قاعده حتی در مواردی که متغیر حلقه پیش‌تر در فضای نام سراسری (*global namespace*) تعریف شده باشد نیز صدق می‌کند؛ در چنین حالتی، متغیر موجود مجدداً به مقدار جدید متصل می‌شود. @@ -2405,7 +2405,7 @@ def some_func(default_arg=[]): ['some_string', 'some_string', 'some_string'] ``` -#### 💡 توضیحات: +#### 💡 توضیح: - آرگومان‌های تغییرپذیر پیش‌فرض در توابع پایتون، هر بار که تابع فراخوانی می‌شود مقداردهی نمی‌شوند؛ بلکه مقداردهی آنها تنها یک بار در زمان تعریف تابع انجام می‌شود و مقدار اختصاص‌یافته به آن‌ها به عنوان مقدار پیش‌فرض برای فراخوانی‌های بعدی استفاده خواهد شد. هنگامی که به صراحت مقدار `[]` را به عنوان آرگومان به `some_func` ارسال کردیم، مقدار پیش‌فرض برای متغیر `default_arg` مورد استفاده قرار نگرفت، بنابراین تابع همان‌طور که انتظار داشتیم عمل کرد. @@ -2474,7 +2474,7 @@ ValueError: list.remove(x): x not in list 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, ```py @@ -2549,7 +2549,7 @@ a += [5, 6, 7, 8] [1, 2, 3, 4, 5, 6, 7, 8] ``` -#### 💡 توضیحات: +#### 💡 توضیح: * عملگر `a += b` همیشه همانند `a = a + b` رفتار نمی‌کند. کلاس‌ها *ممکن است* عملگرهای *`op=`* را به گونه‌ای متفاوت پیاده‌سازی کنند، و لیست‌ها نیز چنین می‌کنند. * عبارت `a = a + [5,6,7,8]` یک لیست جدید ایجاد می‌کند و مرجع `a` را به این لیست جدید اختصاص می‌دهد، بدون آنکه `b` را تغییر دهد. @@ -2594,7 +2594,7 @@ class SomeClass: 5 ``` -#### 💡 توضیحات +#### 💡 توضیح - حوزه‌هایی که درون تعریف کلاس تو در تو هستند، نام‌های تعریف‌شده در سطح کلاس را نادیده می‌گیرند. - عبارت‌های جنراتور (generator expressions) حوزه‌ی مختص به خود دارند. - از پایتون نسخه‌ی ۳ به بعد، لیست‌های فشرده (list comprehensions) نیز حوزه‌ی مختص به خود دارند. @@ -2625,7 +2625,7 @@ def get_middle(some_list): ``` به نظر می‌رسد که پایتون عدد ۲٫۵ را به ۲ گرد کرده است. -#### 💡 توضیحات: +#### 💡 توضیح: - این یک خطای مربوط به دقت اعداد اعشاری نیست؛ بلکه این رفتار عمدی است. از پایتون نسخه 3.0 به بعد، تابع `round()` از [گرد کردن بانکی](https://en.wikipedia.org/wiki/Rounding#Rounding_half_to_even) استفاده می‌کند که در آن کسرهای `.5` به نزدیک‌ترین عدد **زوج** گرد می‌شوند: @@ -2785,7 +2785,7 @@ def similar_recursive_func(a): 4 ``` -#### 💡 توضیحات: +#### 💡 توضیح: * برای مورد ۱، عبارت صحیح برای رفتار مورد انتظار این است: `x, y = (0, 1) if True else (None, None)` @@ -2847,7 +2847,7 @@ def similar_recursive_func(a): 1 ``` -#### 💡 توضیحات: +#### 💡 توضیح: - در نگاه اول ممکن است به نظر برسد جداکننده‌ی پیش‌فرض متد `split` یک فاصله‌ی تکی (`' '`) است؛ اما مطابق با [مستندات رسمی](https://docs.python.org/3/library/stdtypes.html#str.split): > اگر `sep` مشخص نشده یا برابر با `None` باشد، یک الگوریتم متفاوت برای جدا کردن اعمال می‌شود: رشته‌هایی از فاصله‌های متوالی به عنوان یک جداکننده‌ی واحد در نظر گرفته شده و در نتیجه، هیچ رشته‌ی خالی‌ای در ابتدا یا انتهای لیست خروجی قرار نمی‌گیرد، حتی اگر رشته‌ی اولیه دارای فاصله‌های اضافی در ابتدا یا انتها باشد. به همین دلیل، تقسیم یک رشته‌ی خالی یا رشته‌ای که فقط شامل فضای خالی است با جداکننده‌ی `None` باعث بازگشت یک لیست خالی `[]` می‌شود. @@ -2891,7 +2891,7 @@ Traceback (most recent call last): NameError: name '_another_weird_name_func' is not defined ``` -#### 💡 توضیحات: +#### 💡 توضیح: - اغلب توصیه می‌شود از واردسازی عمومی (wildcard imports) استفاده نکنید. اولین دلیل واضح آن این است که در این نوع واردسازی‌ها، اسامی که با زیرخط (`_`) شروع شوند، وارد نمی‌شوند. این مسئله ممکن است در زمان اجرا به خطا منجر شود. - اگر از ساختار `from ... import a, b, c` استفاده کنیم، خطای `NameError` فوق اتفاق نمی‌افتاد. @@ -2939,7 +2939,7 @@ True False ``` -#### 💡 توضیحات: +#### 💡 توضیح: - متد `sorted` همیشه یک لیست (`list`) برمی‌گرداند، و در پایتون مقایسه‌ی لیست‌ها و تاپل‌ها (`tuple`) همیشه مقدار `False` را برمی‌گرداند. @@ -2988,7 +2988,7 @@ if noon_time: ``` 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." @@ -3568,7 +3568,7 @@ timeit.timeit('add_string_with_plus(10000)', number=1000, globals=globals()) 86.3 µs ± 2 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) ``` -#### 💡 توضیحات +#### 💡 توضیح توضیحات - برای اطلاعات بیشتر درباره‌ی [timeit](https://docs.python.org/3/library/timeit.html) یا [%timeit](https://ipython.org/ipython-doc/dev/interactive/magics.html#magic-timeit)، می‌توانید به این لینک‌ها مراجعه کنید. این توابع برای اندازه‌گیری زمان اجرای قطعه‌کدها استفاده می‌شوند. - برای تولید رشته‌های طولانی از `+` استفاده نکنید — در پایتون، نوع داده‌ی `str` تغییرناپذیر (immutable) است؛ بنابراین برای هر الحاق (concatenation)، رشته‌ی چپ و راست باید در رشته‌ی جدید کپی شوند. اگر چهار رشته‌ی ۱۰ حرفی را متصل کنید، به‌جای کپی ۴۰ کاراکتر، باید `(10+10) + ((10+10)+10) + (((10+10)+10)+10) = 90` کاراکتر کپی کنید. این وضعیت با افزایش تعداد و طول رشته‌ها به‌صورت درجه دو (مربعی) بدتر می‌شود (که توسط زمان اجرای تابع `add_bytes_with_plus` تأیید شده است). @@ -3693,7 +3693,7 @@ def dict_size(o): * متد `join()` عملیاتی مربوط به رشته (`str`) است، نه لیست (`list`). (در نگاه اول کمی برخلاف انتظار است.) - ** 💡 توضیح:** اگر `join()` به‌عنوان متدی روی رشته پیاده‌سازی شود، می‌تواند روی هر شیء قابل پیمایش (`iterable`) از جمله لیست، تاپل و هر نوع تکرارشونده‌ی دیگر کار کند. اگر به‌جای آن روی لیست تعریف می‌شد، باید به‌طور جداگانه برای هر نوع دیگری نیز پیاده‌سازی می‌شد. همچنین منطقی نیست که یک متد مختص رشته روی یک شیء عمومی مانند `list` پیاده شود. + **توضیح:** اگر `join()` به‌عنوان متدی روی رشته پیاده‌سازی شود، می‌تواند روی هر شیء قابل پیمایش (`iterable`) از جمله لیست، تاپل و هر نوع تکرارشونده‌ی دیگر کار کند. اگر به‌جای آن روی لیست تعریف می‌شد، باید به‌طور جداگانه برای هر نوع دیگری نیز پیاده‌سازی می‌شد. همچنین منطقی نیست که یک متد مختص رشته روی یک شیء عمومی مانند `list` پیاده شود. * تعدادی عبارت با ظاهری عجیب اما از نظر معنا صحیح: + عبارت `[] = ()` از نظر معنایی صحیح است (باز کردن یا `unpack` کردن یک تاپل خالی درون یک لیست خالی). @@ -3712,7 +3712,7 @@ def dict_size(o): 5 ``` - ** 💡 توضیح:** + 💡 **توضیح:** + در گرامر پایتون عملگری به‌نام `++` وجود ندارد. در واقع `++` دو عملگر `+` جداگانه است. + عبارت `++a` به‌شکل `+(+a)` تفسیر می‌شود که معادل `a` است. به‌همین ترتیب، خروجی عبارت `--a` نیز قابل توجیه است. + این [تاپیک در StackOverflow](https://stackoverflow.com/questions/3654830/why-are-there-no-and-operators-in-python) دلایل نبودن عملگرهای افزایش (`++`) و کاهش (`--`) در پایتون را بررسی می‌کند. From 4ffaa0ff77f2a6ad303580619d1d64395c14f46e Mon Sep 17 00:00:00 2001 From: Leo Alavi Date: Sat, 5 Apr 2025 21:58:43 +0200 Subject: [PATCH 21/33] Update ToC --- translations/fa-farsi/README.md | 105 ++++++++++++++++---------------- 1 file changed, 52 insertions(+), 53 deletions(-) diff --git a/translations/fa-farsi/README.md b/translations/fa-farsi/README.md index ba54104..c2b8299 100644 --- a/translations/fa-farsi/README.md +++ b/translations/fa-farsi/README.md @@ -51,72 +51,71 @@ - [◀ کلیدهای هش](#-کلیدهای-هش) - [◀ در عمق وجود همه ما یکسان هستیم](#-در-عمق-وجود-همه-ما-یکسان-هستیم) - [◀ بی‌نظمی در خود نظم \*](#-بینظمی-در-خود-نظم-) - - [◀ تلاش کن... \*](#-تلاش-کن-) - [◀ برای چی؟](#-برای-چی) - [◀ اختلاف زمانی در محاسبه](#-اختلاف-زمانی-در-محاسبه) - [◀ هر گردی، گردو نیست](#-هر-گردی-گردو-نیست) - - [◀ یک بازی دوز که توش X همون اول برنده میشه!](#-یک-بازی-دوز-که-توش-X-همون-اول-برنده-میشه) + - [◀ یک بازی دوز که توش X همون اول برنده میشه!](#-یک-بازی-دوز-که-توش-x-همون-اول-برنده-میشه) - [◀ متغیر شرودینگر \*](#-متغیر-شرودینگر-) - [◀ اول مرغ بوده یا تخم مرغ؟ \*](#-اول-مرغ-بوده-یا-تخم-مرغ-) - [◀ روابط بین زیرمجموعه کلاس‌ها](#-روابط-بین-زیرمجموعه-کلاسها) - - [◀ ‫ برابری و هویت متدها](#--برابری-و-هویت-متدها) - - [◀ ‫ آل-ترو-یشن \*](#--آل-ترو-یشن-) - - [◀ ‫ رشته‌ها و بک‌اسلش‌ها](#--رشتهها-و-بکاسلشها) - - [◀ ‫ گره نیست، نَه!](#--گره-نیست-نَه) + - [◀ برابری و هویت متدها](#-برابری-و-هویت-متدها) + - [◀ آل-ترو-یشن \*](#-آل-ترو-یشن-) + - [◀ رشته‌ها و بک‌اسلش‌ها](#-رشتهها-و-بکاسلشها) + - [◀ گره نیست، نَه!](#-گره-نیست-نَه) - [◀ رشته‌های نیمه سه‌نقل‌قولی](#-رشتههای-نیمه-سهنقلقولی) - - [◀ ‫ مشکل بولین ها چیست؟](#--مشکل-بولین-ها-چیست) - - [◀ ‫ ویژگی‌های کلاس و ویژگی‌های نمونه](#--ویژگیهای-کلاس-و-ویژگیهای-نمونه) + - [◀ مشکل بولین ها چیست؟](#-مشکل-بولین-ها-چیست) + - [◀ ویژگی‌های کلاس و ویژگی‌های نمونه](#-ویژگیهای-کلاس-و-ویژگیهای-نمونه) - [◀ yielding None](#-yielding-none) - [◀ Yielding from... return! \*](#-yielding-from-return-) - - [◀ ‫ بازتاب‌ناپذیری \*](#--بازتابناپذیری-) - - [◀ ‫ تغییر دادن اشیای تغییرناپذیر!](#--تغییر-دادن-اشیای-تغییرناپذیر) - - [◀ ‫ متغیری که از اسکوپ بیرونی ناپدید می‌شود](#--متغیری-که-از-اسکوپ-بیرونی-ناپدید-میشود) - - [◀ ‫ تبدیل اسرارآمیز نوع کلید](#--تبدیل-اسرارآمیز-نوع-کلید) - - [◀ ‫ ببینیم می‌توانید این را حدس بزنید؟](#--ببینیم-میتوانید-این-را-حدس-بزنید) - - [◀ ‫ از حد مجاز برای تبدیل رشته به عدد صحیح فراتر می‌رود](#--از-حد-مجاز-برای-تبدیل-رشته-به-عدد-صحیح-فراتر-میرود) - - [‫ بخش: شیب‌های لغزنده](#-بخش-شیبهای-لغزنده) - - [◀ ‫ تغییر یک دیکشنری هنگام پیمایش روی آن](#--تغییر-یک-دیکشنری-هنگام-پیمایش-روی-آن) + - [◀ بازتاب‌ناپذیری \*](#-بازتابناپذیری-) + - [◀ تغییر دادن اشیای تغییرناپذیر!](#-تغییر-دادن-اشیای-تغییرناپذیر) + - [◀ متغیری که از اسکوپ بیرونی ناپدید می‌شود](#-متغیری-که-از-اسکوپ-بیرونی-ناپدید-میشود) + - [◀ تبدیل اسرارآمیز نوع کلید](#-تبدیل-اسرارآمیز-نوع-کلید) + - [◀ ببینیم می‌توانید این را حدس بزنید؟](#-ببینیم-میتوانید-این-را-حدس-بزنید) + - [◀ از حد مجاز برای تبدیل رشته به عدد صحیح فراتر می‌رود](#-از-حد-مجاز-برای-تبدیل-رشته-به-عدد-صحیح-فراتر-میرود) + - [بخش: شیب‌های لغزنده](#بخش-شیبهای-لغزنده) + - [◀ تغییر یک دیکشنری هنگام پیمایش روی آن](#-تغییر-یک-دیکشنری-هنگام-پیمایش-روی-آن) - [◀ عملیات سرسختانه‌ی `del`](#-عملیات-سرسختانهی-del) - - [◀ ‫ متغیری که از حوزه خارج است](#--متغیری-که-از-حوزه-خارج-است) - - [◀ ‫ حذف المان‌های لیست در حین پیمایش](#--حذف-المانهای-لیست-در-حین-پیمایش) - - [◀ ‫ زیپِ دارای اتلاف برای پیمایشگرها \*](#--زیپِ-دارای-اتلاف-برای-پیمایشگرها-) - - [◀ ‫ نشت کردن متغیرهای حلقه!](#--نشت-کردن-متغیرهای-حلقه) - - [◀ ‫ مراقب آرگومان‌های تغییرپذیر پیش‌فرض باشید!](#--مراقب-آرگومانهای-تغییرپذیر-پیشفرض-باشید) - - [◀ ‫ گرفتن استثناها (Exceptions)](#--گرفتن-استثناها-exceptions) - - [◀ ‫ عملوندهای یکسان، داستانی متفاوت!](#--عملوندهای-یکسان-داستانی-متفاوت) - - [◀ ‫ تفکیک نام‌ها با نادیده گرفتن حوزه‌ی کلاس](#--تفکیک-نامها-با-نادیده-گرفتن-حوزهی-کلاس) - - [◀ ‫ گرد کردن به روش بانکدار \*](#--گرد-کردن-به-روش-بانکدار-) - - [◀ ‫ سوزن‌هایی در انبار کاه \*](#--سوزنهایی-در-انبار-کاه-) - - [◀ ‫ تقسیم‌ها \*](#--تقسیمها-) + - [◀ متغیری که از حوزه خارج است](#-متغیری-که-از-حوزه-خارج-است) + - [◀ حذف المان‌های لیست در حین پیمایش](#-حذف-المانهای-لیست-در-حین-پیمایش) + - [◀ زیپِ دارای اتلاف برای پیمایشگرها \*](#-زیپِ-دارای-اتلاف-برای-پیمایشگرها-) + - [◀ نشت کردن متغیرهای حلقه!](#-نشت-کردن-متغیرهای-حلقه) + - [◀ مراقب آرگومان‌های تغییرپذیر پیش‌فرض باشید!](#-مراقب-آرگومانهای-تغییرپذیر-پیشفرض-باشید) + - [◀ گرفتن استثناها (Exceptions)](#-گرفتن-استثناها-exceptions) + - [◀ عملوندهای یکسان، داستانی متفاوت!](#-عملوندهای-یکسان-داستانی-متفاوت) + - [◀ تفکیک نام‌ها با نادیده گرفتن حوزه‌ی کلاس](#-تفکیک-نامها-با-نادیده-گرفتن-حوزهی-کلاس) + - [◀ گرد کردن به روش بانکدار \*](#-گرد-کردن-به-روش-بانکدار-) + - [◀ سوزن‌هایی در انبار کاه \*](#-سوزنهایی-در-انبار-کاه-) + - [◀ تقسیم‌ها \*](#-تقسیمها-) - [◀ واردسازی‌های عمومی \*](#-واردسازیهای-عمومی-) - - [◀ ‫ همه چیز مرتب شده؟ \*](#--همه-چیز-مرتب-شده-) - - [◀ ‫ زمان نیمه‌شب وجود ندارد؟](#--زمان-نیمهشب-وجود-ندارد) - - [‫ بخش: گنجینه‌های پنهان!](#-بخش-گنجینههای-پنهان) - - [◀ ‫ خب پایتون، می‌توانی کاری کنی پرواز کنم؟](#--خب-پایتون-میتوانی-کاری-کنی-پرواز-کنم) - - [◀ ‫ `goto`، ولی چرا؟](#--goto-ولی-چرا) - - [◀ ‫ خودتان را آماده کنید!](#--خودتان-را-آماده-کنید) - - [◀ ‫ بیایید با «عمو زبان مهربان برای همیشه» آشنا شویم](#--بیایید-با-عمو-زبان-مهربان-برای-همیشه-آشنا-شویم) - - [◀ ‫ حتی پایتون هم می‌داند که عشق پیچیده است](#--حتی-پایتون-هم-میداند-که-عشق-پیچیده-است) - - [◀ ‫ بله، این واقعاً وجود دارد!](#--بله-این-واقعاً-وجود-دارد) + - [◀ همه چیز مرتب شده؟ \*](#-همه-چیز-مرتب-شده-) + - [◀ زمان نیمه‌شب وجود ندارد؟](#-زمان-نیمهشب-وجود-ندارد) + - [بخش: گنجینه‌های پنهان!](#بخش-گنجینههای-پنهان) + - [◀ خب پایتون، می‌توانی کاری کنی پرواز کنم؟](#-خب-پایتون-میتوانی-کاری-کنی-پرواز-کنم) + - [◀ `goto`، ولی چرا؟](#-goto-ولی-چرا) + - [◀ خودتان را آماده کنید!](#-خودتان-را-آماده-کنید) + - [◀ بیایید با «عمو زبان مهربان برای همیشه» آشنا شویم](#-بیایید-با-عمو-زبان-مهربان-برای-همیشه-آشنا-شویم) + - [◀ حتی پایتون هم می‌داند که عشق پیچیده است](#-حتی-پایتون-هم-میداند-که-عشق-پیچیده-است) + - [◀ بله، این واقعاً وجود دارد!](#-بله-این-واقعاً-وجود-دارد) - [◀ Ellipsis \*](#-ellipsis-) - - [◀ ‫ بی‌نهایت (`Inpinity`)](#--بینهایت-inpinity) - - [◀ ‫ بیایید خرابکاری کنیم](#--بیایید-خرابکاری-کنیم) - - [‫ بخش: ظاهرها فریبنده‌اند!](#-بخش-ظاهرها-فریبندهاند) - - [◀ ‫ خطوط را رد می‌کند؟](#--خطوط-را-رد-میکند) - - [◀ ‫ تله‌پورت کردن](#--تلهپورت-کردن) - - [◀ ‫ خب، یک جای کار مشکوک است...](#--خب-یک-جای-کار-مشکوک-است) + - [◀ بی‌نهایت (`Inpinity`)](#-بینهایت-inpinity) + - [◀ بیایید خرابکاری کنیم](#-بیایید-خرابکاری-کنیم) + - [بخش: ظاهرها فریبنده‌اند!](#بخش-ظاهرها-فریبندهاند) + - [◀ خطوط را رد می‌کند؟](#-خطوط-را-رد-میکند) + - [◀ تله‌پورت کردن](#-تلهپورت-کردن) + - [◀ خب، یک جای کار مشکوک است...](#-خب-یک-جای-کار-مشکوک-است) - [بخش: متفرقه](#بخش-متفرقه) - - [‫ ◀ `+=` سریع‌تر است](#---سریعتر-است) - - [‫ ◀ بیایید یک رشته‌ی بزرگ بسازیم!](#--بیایید-یک-رشتهی-بزرگ-بسازیم) - - [◀ ‫ کُند کردن جستجوها در `dict` \*](#---کُند-کردن-جستجوها-در-dict-) - - [‫ ◀ حجیم کردن دیکشنری نمونه‌ها (`instance dicts`) \*](#--حجیم-کردن-دیکشنری-نمونهها-instance-dicts-) - - [‫ ◀ موارد جزئی \*](#---موارد-جزئی-) -- [‫ مشارکت](#-مشارکت) -- [‫ تقدیر و تشکر](#-تقدیر-و-تشکر) - - [‫ چند لینک جالب!](#-چند-لینک-جالب) -- [‫ 🎓 مجوز](#--مجوز) - - [‫ دوستانتان را هم شگفت‌زده کنید!](#-دوستانتان-را-هم-شگفتزده-کنید) - - [‫ آیا به یک نسخه pdf نیاز دارید؟](#-آیا-به-یک-نسخه-pdf-نیاز-دارید) + - [◀ `+=` سریع‌تر است](#--سریعتر-است) + - [◀ بیایید یک رشته‌ی بزرگ بسازیم!](#-بیایید-یک-رشتهی-بزرگ-بسازیم) + - [◀ کُند کردن جستجوها در `dict` \*](#--کُند-کردن-جستجوها-در-dict-) + - [◀ حجیم کردن دیکشنری نمونه‌ها (`instance dicts`) \*](#-حجیم-کردن-دیکشنری-نمونهها-instance-dicts-) + - [◀ موارد جزئی \*](#-موارد-جزئی-) +- [مشارکت](#مشارکت) +- [تقدیر و تشکر](#تقدیر-و-تشکر) + - [چند لینک جالب!](#چند-لینک-جالب) +- [🎓 مجوز](#-مجوز) + - [دوستانتان را هم شگفت‌زده کنید!](#دوستانتان-را-هم-شگفتزده-کنید) + - [آیا به یک نسخه pdf نیاز دارید؟](#آیا-به-یک-نسخه-pdf-نیاز-دارید) From 7a12c2ae4a871dd9dc205ecbe22f65d7a30cc620 Mon Sep 17 00:00:00 2001 From: Leo Alavi Date: Sun, 13 Apr 2025 15:28:26 +0200 Subject: [PATCH 22/33] Fix some typos --- translations/fa-farsi/README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/translations/fa-farsi/README.md b/translations/fa-farsi/README.md index c2b8299..1002516 100644 --- a/translations/fa-farsi/README.md +++ b/translations/fa-farsi/README.md @@ -17,7 +17,7 @@ پایتون، یه زبان زیبا طراحی شده، سطح بالا و مبتنی بر مفسره که قابلیت‌های بسیاری برای راحتی ما برنامه‌نویس‌ها فراهم می‌کنه. ولی گاهی اوقات قطعه‌کدهایی رو می‌بینیم که تو نگاه اول خروجی‌هاشون واضح نیست. -این یه پروژه باحاله که سعی داریم توش توضیح بدیم که پشت پرده یه سری قطعه‌کدهای غیرشهودی و فابلیت‌های کمتر شناخته شده پایتون +این یه پروژه باحاله که سعی داریم توش توضیح بدیم که پشت پرده یه سری قطعه‌کدهای غیرشهودی و قابلیت‌های کمتر شناخته شده پایتون چه خبره. درحالی که بعضی از مثال‌هایی که قراره تو این سند ببینید واقعا عجیب و غریب نیستند ولی بخش‌های جالبی از پایتون رو ظاهر می‌کنند که @@ -28,7 +28,7 @@ تو تلاش اول حدس بزنید. ممکنه شما بعضی از این مثال‌ها رو قبلا تجربه کرده باشید و من خاطراتشون رو در این سند براتون زنده کرده باشم! :sweat_smile: -پ.ن: اگه شما قبلا این سند رو خوندید، می‌تونید تغییرات جدید رو در بخش انتشار (فعلا در [اینجا](https://github.com/satwikkansal/wtfpython/)) مطالعه کنید +پ.ن: اگه شما قبلا این سند رو خوندید، می‌تونید تغییرات جدید رو در بخش انتشار (فعلا در [اینجا](https://github.com/satwikkansal/wtfpython/releases/)) مطالعه کنید (مثال‌هایی که کنارشون علامت ستاره دارند، در آخرین ویرایش اضافه شده‌اند). پس، بزن بریم... @@ -242,7 +242,7 @@ SyntaxError: invalid syntax **مرور سریع بر عملگر Walrus** عملگر Walrus همونطور که اشاره شد، در نسخه ۳.۸ پایتون معرفی -شد. این عملگر می‌تونه تو مقعیت‌هایی کاربردی باشه که شما می‌خواید داخل یه عبارت، مقادیری رو به متغیرها اختصاص بدید +شد. این عملگر می‌تونه تو موقعیت‌هایی کاربردی باشه که شما می‌خواید داخل یه عبارت، مقادیری رو به متغیرها اختصاص بدید. ```py def some_func(): From e690b4a349899af5a9ba0c329719808a2f896be9 Mon Sep 17 00:00:00 2001 From: Leo Alavi Date: Sun, 13 Apr 2025 15:34:58 +0200 Subject: [PATCH 23/33] Add some RTL fixings --- translations/fa-farsi/README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/translations/fa-farsi/README.md b/translations/fa-farsi/README.md index 1002516..c02f5e1 100644 --- a/translations/fa-farsi/README.md +++ b/translations/fa-farsi/README.md @@ -275,9 +275,9 @@ if a := some_func(): این باعث میشه که یک خط کمتر کد بزنیم و از دوبار فراخوندن `some_func` جلوگیری کرد. -- "عبارت اختصاص‌دادن مقدار" بدون پرانتز (نحوه استفاده عملگر Walrus)، در سطح بالا محدود است، `SyntaxError` در عبارت `a := "wtf_walrus"` در قطعه‌کد اول به همین دلیل است. قرار دادن آن داخل پرانتز، همانطور که می‌خواستیم کار کرد و مقدار را به `a` اختصاص داد. +- ‫ "عبارت اختصاص‌دادن مقدار" بدون پرانتز (نحوه استفاده عملگر Walrus)، در سطح بالا محدود است، `SyntaxError` در عبارت `a := "wtf_walrus"` در قطعه‌کد اول به همین دلیل است. قرار دادن آن داخل پرانتز، همانطور که می‌خواستیم کار کرد و مقدار را به `a` اختصاص داد. -- به طور معمول، قرار دادن عبارتی که دارای `=` است داخل پرانتز مجاز نیست. به همین دلیل ‍عبارت `(a, b = 6, 9)` به ما خطای سینتکس داد. +- ‫ به طور معمول، قرار دادن عبارتی که دارای `=` است داخل پرانتز مجاز نیست. به همین دلیل ‍عبارت `(a, b = 6, 9)` به ما خطای سینتکس داد. - قائده استفاده از عملگر Walrus به صورت `NAME:= expr` است، به طوری که `NAME` یک شناسه صحیح و `expr` یک عبارت صحیح است. به همین دلیل باز و بسته کردن با تکرار (iterable) پشتیبانی نمی‌شوند. پس، From 385d93c40e4797f803bf1e74fd392452d318b559 Mon Sep 17 00:00:00 2001 From: Leo Alavi Date: Sun, 13 Apr 2025 15:36:59 +0200 Subject: [PATCH 24/33] Revert RTL fixing --- translations/fa-farsi/README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/translations/fa-farsi/README.md b/translations/fa-farsi/README.md index c02f5e1..1002516 100644 --- a/translations/fa-farsi/README.md +++ b/translations/fa-farsi/README.md @@ -275,9 +275,9 @@ if a := some_func(): این باعث میشه که یک خط کمتر کد بزنیم و از دوبار فراخوندن `some_func` جلوگیری کرد. -- ‫ "عبارت اختصاص‌دادن مقدار" بدون پرانتز (نحوه استفاده عملگر Walrus)، در سطح بالا محدود است، `SyntaxError` در عبارت `a := "wtf_walrus"` در قطعه‌کد اول به همین دلیل است. قرار دادن آن داخل پرانتز، همانطور که می‌خواستیم کار کرد و مقدار را به `a` اختصاص داد. +- "عبارت اختصاص‌دادن مقدار" بدون پرانتز (نحوه استفاده عملگر Walrus)، در سطح بالا محدود است، `SyntaxError` در عبارت `a := "wtf_walrus"` در قطعه‌کد اول به همین دلیل است. قرار دادن آن داخل پرانتز، همانطور که می‌خواستیم کار کرد و مقدار را به `a` اختصاص داد. -- ‫ به طور معمول، قرار دادن عبارتی که دارای `=` است داخل پرانتز مجاز نیست. به همین دلیل ‍عبارت `(a, b = 6, 9)` به ما خطای سینتکس داد. +- به طور معمول، قرار دادن عبارتی که دارای `=` است داخل پرانتز مجاز نیست. به همین دلیل ‍عبارت `(a, b = 6, 9)` به ما خطای سینتکس داد. - قائده استفاده از عملگر Walrus به صورت `NAME:= expr` است، به طوری که `NAME` یک شناسه صحیح و `expr` یک عبارت صحیح است. به همین دلیل باز و بسته کردن با تکرار (iterable) پشتیبانی نمی‌شوند. پس، From 5bf9aabd25b42779b6dedf06b4d50f15699fc14e Mon Sep 17 00:00:00 2001 From: Leo Alavi Date: Sun, 13 Apr 2025 16:25:42 +0200 Subject: [PATCH 25/33] Add RTL fix for chaining --- translations/fa-farsi/README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/translations/fa-farsi/README.md b/translations/fa-farsi/README.md index 1002516..0113a53 100644 --- a/translations/fa-farsi/README.md +++ b/translations/fa-farsi/README.md @@ -412,8 +412,8 @@ False شاید چنین رفتاری برای شما احمقانه به نظر بیاد ولی برای عملیات‌هایی مثل `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` می‌شود. +* ‫ عبارت `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 From d1c19a0d72a940817cafac88db7518faf8ee1c34 Mon Sep 17 00:00:00 2001 From: Leo Alavi Date: Sun, 13 Apr 2025 16:28:41 +0200 Subject: [PATCH 26/33] remove extra rtl chars --- translations/fa-farsi/README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/translations/fa-farsi/README.md b/translations/fa-farsi/README.md index 0113a53..1002516 100644 --- a/translations/fa-farsi/README.md +++ b/translations/fa-farsi/README.md @@ -412,8 +412,8 @@ False شاید چنین رفتاری برای شما احمقانه به نظر بیاد ولی برای عملیات‌هایی مثل `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` می‌شود. +* عبارت `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 From 48b0b96193bd10aa0143b92fb4035480dd2e84d9 Mon Sep 17 00:00:00 2001 From: Leo Alavi Date: Sun, 13 Apr 2025 17:27:09 +0200 Subject: [PATCH 27/33] Add missing link --- translations/fa-farsi/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/translations/fa-farsi/README.md b/translations/fa-farsi/README.md index 1002516..f872be4 100644 --- a/translations/fa-farsi/README.md +++ b/translations/fa-farsi/README.md @@ -612,7 +612,7 @@ complex >>> hash(5) == hash(5.0) == hash(5 + 0j) True ``` - **توجه:** برعکس این قضیه لزوما درست نیست. شیءهای میتونن هش های یکسانی داشته باشند ولی مقادیر نابرابری داشته باشند. (این باعث به وجود اومدن پدیده‌ای معروف [تصادم هش]() میشه)، در این صورت توابع هش عملکرد خودشون رو کندتر از حالت عادی انجام می‌دهند. + **توجه:** برعکس این قضیه لزوما درست نیست. شیءهای میتونن هش های یکسانی داشته باشند ولی مقادیر نابرابری داشته باشند. (این باعث به وجود اومدن پدیده‌ای معروف [تصادف هش](https://en.wikipedia.org/wiki/Collision_(disambiguation)#Other_uses) میشه)، در این صورت توابع هش عملکرد خودشون رو کندتر از حالت عادی انجام می‌دهند. --- From 17046d418afd00e319ea5a8fea3346d85eef8972 Mon Sep 17 00:00:00 2001 From: Leo Alavi Date: Tue, 15 Apr 2025 14:57:56 +0200 Subject: [PATCH 28/33] Fix some rtl --- translations/fa-farsi/README.md | 47 +++++++++++++++++++-------------- 1 file changed, 27 insertions(+), 20 deletions(-) diff --git a/translations/fa-farsi/README.md b/translations/fa-farsi/README.md index f872be4..54df2c5 100644 --- a/translations/fa-farsi/README.md +++ b/translations/fa-farsi/README.md @@ -869,7 +869,7 @@ for i, some_dict[i] in enumerate(some_string): - عبارت مقداردهی `i = 10` به خاطر نحوه کار کردن حلقه‌ها، هیچوقت باعث تغییر در تکرار حلقه نمیشه. قبل از شروع هر تکرار، مقدار بعدی که توسط شیء قابل تکرار (که در اینجا `range(4)` است) ارائه میشه، از بسته خارج میشه و به متغیرهای لیست هدف (که در اینجا `i` است) مقداردهی میشه. -* تابع `enumerate(some_string)`، یک متغیر `i` (که یک شمارنده اقزایشی است) و یک حرف از حروف رشته `some_string` رو در هر تکرار برمیگردونه. و بعدش برای کلید `i` (تازه مقداردهی‌شده) در دیکشنری `some_dict`، مقدار اون حرف رو تنظیم می‌کنه. بازشده این حلقه می‌تونه مانند مثال زیر ساده بشه: +* تابع `enumerate(some_string)`، یک متغیر `i` (که یک شمارنده افزایشی است) و یک حرف از حروف رشته `some_string` رو در هر تکرار برمیگردونه. و بعدش برای کلید `i` (تازه مقداردهی‌شده) در دیکشنری `some_dict`، مقدار اون حرف رو تنظیم می‌کنه. بازشده این حلقه می‌تونه مانند مثال زیر ساده بشه: ```py >>> i, some_dict[i] = (0, 'w') >>> i, some_dict[i] = (1, 't') @@ -969,10 +969,15 @@ False ```py + # بیاید یک سطر تشکیل بدیم + row = [""] * 3 #row i['', '', ''] + # حالا بیاید تخته بازی رو ایجاد کنیم + board = [row] * 3 + ``` **خروجی:** @@ -1036,7 +1041,7 @@ for x in range(7): def some_func(): return x funcs.append(some_func) - results.append(some_func()) # note the function call here + results.append(some_func()) # به فراخوانی تابع دقت کنید. funcs_results = [func() for func in funcs] ``` @@ -1150,7 +1155,6 @@ False - هیچ کلاس پایه واقعی بین کلاس‌های `object` و `type` وجود نداره. سردرگمی که در قطعه‌کدهای بالا به وجود اومده، به خاطر اینه که ما به این روابط (یعنی `issubclass` و `isinstance`) از دیدگاه کلاس‌های پایتون فکر می‌کنیم. رابطه بین `object` و `type` رو در پایتون خالص نمیشه بازتولید کرد. برای اینکه دقیق‌تر باشیم، رابطه‌های زیر در پایتون خالص نمی‌تونند بازتولید بشن. + کلاس A یک نمونه از کلاس B، و کلاس B یک نمونه از کلاس A باشه. + کلاس A یک نمونه از خودش باشه. -- - این روابط بین `object` و `type` (که هردو نمونه یکدیگه و همچنین خودشون باشند) به خاطر "تقلب" در مرحله پیاده‌سازی، وجود دارند. --- @@ -1289,7 +1293,7 @@ True چرا این تغییر درست-نادرسته؟ -#### 💡 Explanation: +#### 💡 توضیحات: - پیاده‌سازی تابع `all` معادل است با @@ -1400,7 +1404,7 @@ True SyntaxError: invalid syntax ``` -#### 💡 Explanation: +#### 💡 توضیح: * تقدم عملگرها بر نحوه‌ی ارزیابی یک عبارت تأثیر می‌گذارد، و در پایتون، عملگر `==` تقدم بالاتری نسبت به عملگر `not` دارد. * بنابراین عبارت `not x == y` معادل `not (x == y)` است که خودش معادل `not (True == False)` بوده و در نهایت به `True` ارزیابی می‌شود. @@ -1417,7 +1421,7 @@ SyntaxError: invalid syntax wtfpython >>> print("wtfpython""") wtfpython ->>> # The following statements raise `SyntaxError` +>>> # کد های زیر خطای سینکس دارند. >>> # print('''wtfpython') >>> # print("""wtfpython") File "", line 3 @@ -1428,12 +1432,14 @@ SyntaxError: EOF while scanning triple-quoted string literal #### 💡 توضیح: + پایتون از الحاق ضمنی [رشته‌های متنی](https://docs.python.org/3/reference/lexical_analysis.html#string-literal-concatenation) پشتیبانی می‌کند. برای مثال، + ``` >>> print("wtf" "python") wtfpython >>> print("wtf" "") # or "wtf""" wtf ``` + + `'''` و `"""` نیز جداکننده‌های رشته‌ای در پایتون هستند که باعث ایجاد SyntaxError می‌شوند، چون مفسر پایتون هنگام اسکن رشته‌ای که با سه‌نقل‌قول آغاز شده، انتظار یک سه‌نقل‌قول پایانی به‌عنوان جداکننده را دارد. --- @@ -1442,9 +1448,10 @@ SyntaxError: EOF while scanning triple-quoted string literal 1\. +‫ یک مثال ساده برای شمردن تعداد مقادیر بولی # اعداد صحیح در یک iterable با انواع داده‌ی مخلوط. + ```py -# یک مثال ساده برای شمردن تعداد مقادیر بولی و -# اعداد صحیح در یک iterable با انواع داده‌ی مخلوط. + mixed_list = [False, 1.0, "some_string", 3, True, [], False] integers_found_so_far = 0 booleans_found_so_far = 0 @@ -1528,7 +1535,7 @@ I have lost faith in truth! --- -### ◀ ویژگی‌های کلاس و ویژگی‌های نمونه +### ◀ متغیرهای کلاس و متغیرهای نمونه 1\. ```py @@ -1599,7 +1606,7 @@ True --- -### ◀ yielding None +### ◀ واگذار کردن None ```py some_iterable = ('a', 'b') @@ -1608,7 +1615,7 @@ def some_func(val): return "something" ``` -**Output (<= 3.7.x):** +**خروجی (<= 3.7.x):** ```py >>> [x for x in some_iterable] @@ -1623,16 +1630,16 @@ def some_func(val): ['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`. +#### 💡 توضیح: +- این یک باگ در نحوه‌ی مدیریت `yield` توسط CPython در ژنراتورها و درک لیستی (comprehensions) است. +- منبع و توضیحات را می‌توانید اینجا ببینید: https://stackoverflow.com/questions/32139885/yield-in-list-comprehensions-and-generator-expressions +- گزارش باگ مرتبط: https://bugs.python.org/issue10544 +- از نسخه‌ی ۳.۸ به بعد، پایتون دیگر اجازه‌ی استفاده از `yield` در داخل درک لیستی را نمی‌دهد و خطای `SyntaxError` ایجاد خواهد کرد. --- -### ◀ Yielding from... return! * +### ◀ بازگرداندن با استفاده از `yield from`! 1\. @@ -1677,7 +1684,7 @@ def some_func(x): + از پایتون نسخه ۳.۳ به بعد، امکان استفاده از عبارت `return` همراه با مقدار در داخل ژنراتورها فراهم شد (نگاه کنید به [PEP380](https://www.python.org/dev/peps/pep-0380/)). [مستندات رسمی](https://www.python.org/dev/peps/pep-0380/#enhancements-to-stopiteration) می‌گویند: -> "... `return expr` در یک ژنراتور باعث می‌شود که هنگام خروج از ژنراتور، `StopIteration(expr)` ایجاد شود." +> دلیل: "... `return expr` در یک ژنراتور باعث می‌شود که هنگام خروج از ژنراتور، `StopIteration(expr)` ایجاد شود." + در حالت `some_func(3)`، استثنای `StopIteration` در ابتدای اجرا به دلیل وجود دستور `return` رخ می‌دهد. این استثنا به‌طور خودکار درون پوشش `list(...)` و حلقه `for` گرفته می‌شود. بنابراین، دو قطعه‌کد بالا منجر به یک لیست خالی می‌شوند. @@ -1752,7 +1759,7 @@ True #### 💡 توضیح: -- `'inf'` و `'nan'` رشته‌هایی خاص هستند (نسبت به حروف بزرگ و کوچک حساس نیستند) که وقتی به‌طور صریح به نوع `float` تبدیل شوند، به ترتیب برای نمایش "بی‌نهایت" ریاضی و "عدد نیست" استفاده می‌شوند. +- در اینجا، `'inf'` و `'nan'` رشته‌هایی خاص هستند (نسبت به حروف بزرگ و کوچک حساس نیستند) که وقتی به‌طور صریح به نوع `float` تبدیل شوند، به ترتیب برای نمایش "بی‌نهایت" ریاضی و "عدد نیست" استفاده می‌شوند. - از آنجا که طبق استاندارد IEEE، `NaN != NaN`، پایبندی به این قانون فرض بازتاب‌پذیری (reflexivity) یک عنصر در مجموعه‌ها را در پایتون نقض می‌کند؛ یعنی اگر `x` عضوی از مجموعه‌ای مثل `list` باشد، پیاده‌سازی‌هایی مانند مقایسه، بر اساس این فرض هستند که `x == x`. به دلیل همین فرض، ابتدا هویت (identity) دو عنصر مقایسه می‌شود (چون سریع‌تر است) و فقط زمانی مقادیر مقایسه می‌شوند که هویت‌ها متفاوت باشند. قطعه‌کد زیر موضوع را روشن‌تر می‌کند، @@ -2244,7 +2251,7 @@ for idx, item in enumerate(list_4): می‌توانید حدس بزنید چرا خروجی `[2, 4]` است؟ -#### 💡 Explanation: +#### 💡 توضیح: * هیچ‌وقت ایده‌ی خوبی نیست که شیئی را که روی آن پیمایش می‌کنید تغییر دهید. روش درست این است که روی یک کپی از آن شیء پیمایش کنید؛ در این‌جا `list_3[:]` دقیقاً همین کار را می‌کند. From b62ac1518013635b9173010b5e8e5d27d2677f2c Mon Sep 17 00:00:00 2001 From: Leo Alavi Date: Thu, 17 Apr 2025 17:19:29 +0200 Subject: [PATCH 29/33] Final fixes for the translations --- translations/fa-farsi/README.md | 47 ++++++++++++++++++++++----------- 1 file changed, 31 insertions(+), 16 deletions(-) diff --git a/translations/fa-farsi/README.md b/translations/fa-farsi/README.md index 54df2c5..6c924f4 100644 --- a/translations/fa-farsi/README.md +++ b/translations/fa-farsi/README.md @@ -1916,7 +1916,7 @@ some_dict = {'s': 42} str >>> s = SomeClass('s') >>> some_dict[s] = 40 ->>> some_dict # expected: Two different keys-value pairs +>>> some_dict # دو عدد کلید-مقدار توقع می رود. {'s': 40} >>> type(list(some_dict.keys())[0]) str @@ -1972,9 +1972,11 @@ a, b = a[b] = {}, 5 #### 💡 توضیح: * طبق [مرجع زبان پایتون](https://docs.python.org/3/reference/simple_stmts.html#assignment-statements)، دستورات انتساب فرم زیر را دارند: + ``` (target_list "=")+ (expression_list | yield_expression) ``` + و > یک دستور انتساب ابتدا فهرست عبارت‌ها (expression list) را ارزیابی می‌کند (توجه کنید این عبارت می‌تواند یک عبارت تکی یا فهرستی از عبارت‌ها جداشده با ویرگول باشد که دومی به یک تاپل منجر می‌شود)، سپس شیء حاصل را به هریک از اهداف انتساب از **چپ به راست** تخصیص می‌دهد. @@ -2264,7 +2266,7 @@ for idx, item in enumerate(list_4): ``` **تفاوت بین `del`، `remove` و `pop`:** -* `del var_name` فقط اتصال `var_name` را از فضای نام محلی یا سراسری حذف می‌کند (به همین دلیل است که `list_1` تحت تأثیر قرار نمی‌گیرد). +* اینجا، `del var_name` فقط اتصال `var_name` را از فضای نام محلی یا سراسری حذف می‌کند (به همین دلیل است که `list_1` تحت تأثیر قرار نمی‌گیرد). * متد `remove` اولین مقدار مطابق را حذف می‌کند، نه یک اندیس خاص را؛ اگر مقدار مورد نظر پیدا نشود، خطای `ValueError` ایجاد می‌شود. * متد `pop` عنصری را در یک اندیس مشخص حذف کرده و آن را برمی‌گرداند؛ اگر اندیس نامعتبری مشخص شود، خطای `IndexError` ایجاد می‌شود. @@ -2290,7 +2292,7 @@ for idx, item in enumerate(list_4): >>> 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)] ``` @@ -2299,6 +2301,7 @@ for idx, item in enumerate(list_4): #### 💡 توضیح: - بر اساس [مستندات](https://docs.python.org/3.3/library/functions.html#zip) پایتون، پیاده‌سازی تقریبی تابع `zip` به شکل زیر است: + ```py def zip(*iterables): sentinel = object() @@ -2311,9 +2314,11 @@ for idx, item in enumerate(list_4): result.append(elem) yield tuple(result) ``` + - بنابراین این تابع تعداد دلخواهی از اشیای قابل پیمایش (*iterable*) را دریافت می‌کند، و با فراخوانی تابع `next` روی آن‌ها، هر یک از عناصرشان را به لیست `result` اضافه می‌کند. این فرایند زمانی متوقف می‌شود که اولین پیمایشگر به انتها برسد. - نکته مهم اینجاست که هر زمان یکی از پیمایشگرها به پایان برسد، عناصر موجود در لیست `result` نیز دور ریخته می‌شوند. این دقیقاً همان اتفاقی است که برای عدد `3` در `numbers_iter` رخ داد. - روش صحیح برای انجام عملیات بالا با استفاده از تابع `zip` چنین است: + ```py >>> numbers = list(range(7)) >>> numbers_iter = iter(numbers) @@ -2322,6 +2327,7 @@ for idx, item in enumerate(list_4): >>> list(zip(remaining, numbers_iter)) [(3, 3), (4, 4), (5, 5), (6, 6)] ``` + اولین آرگومانِ تابع `zip` باید پیمایشگری باشد که کمترین تعداد عنصر را دارد. --- @@ -2482,7 +2488,8 @@ 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, +* برای افزودن چندین استثنا به عبارت `except`، باید آن‌ها را به صورت یک تاپل پرانتزدار به عنوان آرگومان اول وارد کنید. آرگومان دوم یک نام اختیاری است که در صورت ارائه، نمونهٔ Exception ایجادشده را به آن متصل می‌کند. برای مثال: + ```py some_list = [1, 2, 3] try: @@ -2492,12 +2499,16 @@ SyntaxError: invalid syntax print("Caught again!") print(e) ``` + **خروجی (Python 2.x):** + ``` Caught again! list.remove(x): x not in list ``` + **خروجی (Python 3.x):** + ```py File "", line 4 except (IndexError, ValueError), e: @@ -2505,7 +2516,8 @@ SyntaxError: invalid syntax 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, +* جدا کردن استثنا از متغیر با استفاده از ویرگول منسوخ شده و در پایتون 3 کار نمی‌کند؛ روش صحیح استفاده از `as` است. برای مثال: + ```py some_list = [1, 2, 3] try: @@ -2515,7 +2527,9 @@ SyntaxError: invalid syntax print("Caught again!") print(e) ``` + **خروجی:** + ``` Caught again! list.remove(x): x not in list @@ -2796,7 +2810,7 @@ def similar_recursive_func(a): `x, y = (0, 1) if True else (None, None)` * برای مورد ۲، عبارت صحیح برای رفتار مورد انتظار این است: -`t = ('one',)` یا `t = 'one',` (ویرگول از قلم افتاده است). در غیر این صورت مفسر `t` را به عنوان یک `str` در نظر گرفته و به صورت کاراکتر به کاراکتر روی آن پیمایش می‌کند. +اینجا، `t = ('one',)` یا `t = 'one',` (ویرگول از قلم افتاده است). در غیر این صورت مفسر `t` را به عنوان یک `str` در نظر گرفته و به صورت کاراکتر به کاراکتر روی آن پیمایش می‌کند. * علامت `()` یک توکن خاص است و نشان‌دهنده‌ی یک `tuple` خالی است. @@ -2840,15 +2854,15 @@ def similar_recursive_func(a): >>> 'a'.split() ['a'] -# is same as +# معادل است با >>> 'a'.split(' ') ['a'] -# but +# اما >>> len(''.split()) 0 -# isn't the same as +# معادل نیست با >>> len(''.split(' ')) 1 ``` @@ -2859,6 +2873,7 @@ def similar_recursive_func(a): > اگر `sep` مشخص نشده یا برابر با `None` باشد، یک الگوریتم متفاوت برای جدا کردن اعمال می‌شود: رشته‌هایی از فاصله‌های متوالی به عنوان یک جداکننده‌ی واحد در نظر گرفته شده و در نتیجه، هیچ رشته‌ی خالی‌ای در ابتدا یا انتهای لیست خروجی قرار نمی‌گیرد، حتی اگر رشته‌ی اولیه دارای فاصله‌های اضافی در ابتدا یا انتها باشد. به همین دلیل، تقسیم یک رشته‌ی خالی یا رشته‌ای که فقط شامل فضای خالی است با جداکننده‌ی `None` باعث بازگشت یک لیست خالی `[]` می‌شود. > اگر `sep` مشخص شود، جداکننده‌های متوالی در کنار هم قرار نمی‌گیرند و هر جداکننده، یک رشته‌ی خالی جدید ایجاد می‌کند. (مثلاً `'1,,2'.split(',')` مقدار `['1', '', '2']` را برمی‌گرداند.) تقسیم یک رشته‌ی خالی با یک جداکننده‌ی مشخص‌شده نیز باعث بازگشت `['']` می‌شود. - توجه به اینکه چگونه فضای خالی در ابتدا و انتهای رشته در قطعه‌ی کد زیر مدیریت شده است، این مفهوم را روشن‌تر می‌کند: + ```py >>> ' a '.split(' ') ['', 'a', ''] @@ -2992,11 +3007,11 @@ if noon_time: ```py ('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." +پیش از پایتون 3.5، مقدار بولی برای شیء `datetime.time` اگر نشان‌دهندهٔ نیمه‌شب به وقت UTC بود، برابر با `False` در نظر گرفته می‌شد. این رفتار در استفاده از دستور `if obj:` برای بررسی تهی بودن شیء یا برابر بودن آن با مقدار "خالی"، ممکن است باعث بروز خطا شود. --- --- @@ -3118,7 +3133,7 @@ True import this ``` -Wait, what's **this**? `this` is love :heart: +صبر کن، **این** چیه؟ `this` عشقه :heart: **خروجی:** ``` @@ -3213,7 +3228,7 @@ Try block executed successfully... - عبارت `else` پس از بلاک `try` به عنوان «عبارت تکمیل» (`completion clause`) نیز شناخته می‌شود؛ چراکه رسیدن به عبارت `else` در ساختار `try` به این معنی است که بلاک `try` بدون رخ دادن استثنا با موفقیت تکمیل شده است. --- -### ◀ Ellipsis * +### ◀ عملگر Ellipsis * ```py def some_func(): @@ -3240,7 +3255,7 @@ Ellipsis >>> ... Ellipsis ``` -- `Ellipsis` می‌تواند برای چندین منظور استفاده شود: +- عملگر `Ellipsis` می‌تواند برای چندین منظور استفاده شود: + به عنوان یک نگه‌دارنده برای کدی که هنوز نوشته نشده است (مانند دستور `pass`) + در سینتکس برش (`slicing`) برای نمایش برش کامل در ابعاد باقی‌مانده @@ -3810,9 +3825,9 @@ def dict_size(o): ```py >>> 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. + >>> some_list is some_list[:] # انتظار می‌رود False باشد چون یک شیء جدید ایجاد شده است. False - >>> some_str is some_str[:] # True because strings are immutable, so making a new object is of not much use. + >>> some_str is some_str[:] # True چون رشته‌ها تغییرناپذیر هستند، بنابراین ساختن یک شیء جدید فایده‌ای ندارد. True ``` From f01c716e60ea66a747787b25d63654d93e64cccd Mon Sep 17 00:00:00 2001 From: Leo Alavi Date: Thu, 17 Apr 2025 17:22:06 +0200 Subject: [PATCH 30/33] Add persian link --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 35a9cf5..667aaeb 100644 --- a/README.md +++ b/README.md @@ -9,7 +9,7 @@

Exploring and understanding Python through surprising snippets.

-Translations: [Chinese 中文](https://github.com/leisurelicht/wtfpython-cn) | [Vietnamese Tiếng Việt](https://github.com/vuduclyunitn/wtfptyhon-vi) | [Spanish Español](https://web.archive.org/web/20220511161045/https://github.com/JoseDeFreitas/wtfpython-es) | [Korean 한국어](https://github.com/buttercrab/wtfpython-ko) | [Russian Русский](https://github.com/satwikkansal/wtfpython/tree/master/translations/ru-russian) | [German Deutsch](https://github.com/BenSt099/wtfpython) | [Add translation](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].) +Translations: [Chinese 中文](https://github.com/leisurelicht/wtfpython-cn) | [Vietnamese Tiếng Việt](https://github.com/vuduclyunitn/wtfptyhon-vi) | [Spanish Español](https://web.archive.org/web/20220511161045/https://github.com/JoseDeFreitas/wtfpython-es) | [Korean 한국어](https://github.com/buttercrab/wtfpython-ko) | [Russian Русский](https://github.com/satwikkansal/wtfpython/tree/master/translations/ru-russian) | [German Deutsch](https://github.com/BenSt099/wtfpython) | [Persian فارسی](https://github.com/satwikkansal/wtfpython/tree/master/translations/fa-farsi) | [Add translation](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].) Other modes: [Interactive Website](https://wtfpython-interactive.vercel.app) | [Interactive Notebook](https://colab.research.google.com/github/satwikkansal/wtfpython/blob/master/irrelevant/wtf.ipynb) From 1e0a1ea7976668599142d1ef90a38a93aef9e294 Mon Sep 17 00:00:00 2001 From: Leo Alavi Date: Tue, 22 Apr 2025 14:48:09 +0200 Subject: [PATCH 31/33] Add persian translation link --- translations/fa-farsi/README.md | 73 ++++++++++++++++++++++++++++++--- 1 file changed, 68 insertions(+), 5 deletions(-) diff --git a/translations/fa-farsi/README.md b/translations/fa-farsi/README.md index 6c924f4..e100c45 100644 --- a/translations/fa-farsi/README.md +++ b/translations/fa-farsi/README.md @@ -9,7 +9,7 @@

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

-ترجمه‌ها: [انگلیسی 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) | [اضافه کردن ترجمه](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].) +ترجمه‌ها: [انگلیسی 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) @@ -45,70 +45,133 @@ - [👀 مثال‌ها](#-مثالها) - [بخش: ذهن خود را به چالش بکشید!](#بخش-ذهن-خود-را-به-چالش-بکشید) - [◀ اول از همه! \*](#-اول-از-همه-) + - [💡 توضیح](#-توضیح) - [◀ بعضی وقت‌ها رشته‌ها می‌توانند دردسرساز شوند](#-بعضی-وقتها-رشتهها-میتوانند-دردسرساز-شوند) + - [💡 توضیح:](#-توضیح-1) - [◀ مراقب عملیات‌های زنجیره‌ای باشید](#-مراقب-عملیاتهای-زنجیرهای-باشید) + - [💡 توضیح:](#-توضیح-2) - [◀ چطور از عملگر `is` استفاده نکنیم](#-چطور-از-عملگر-is-استفاده-نکنیم) + - [💡 توضیح:](#-توضیح-3) - [◀ کلیدهای هش](#-کلیدهای-هش) + - [💡 توضیح](#-توضیح-4) - [◀ در عمق وجود همه ما یکسان هستیم](#-در-عمق-وجود-همه-ما-یکسان-هستیم) + - [💡 توضیح:](#-توضیح-5) - [◀ بی‌نظمی در خود نظم \*](#-بینظمی-در-خود-نظم-) + - [💡 توضیح:](#-توضیح-6) + - [💡 توضیح:](#-توضیح-7) - [◀ برای چی؟](#-برای-چی) + - [💡 توضیح:](#-توضیح-8) - [◀ اختلاف زمانی در محاسبه](#-اختلاف-زمانی-در-محاسبه) + - [💡 توضیح](#-توضیح-9) - [◀ هر گردی، گردو نیست](#-هر-گردی-گردو-نیست) + - [💡 توضیح](#-توضیح-10) - [◀ یک بازی دوز که توش X همون اول برنده میشه!](#-یک-بازی-دوز-که-توش-x-همون-اول-برنده-میشه) + - [💡 توضیح:](#-توضیح-11) - [◀ متغیر شرودینگر \*](#-متغیر-شرودینگر-) + - [💡 توضیح:](#-توضیح-12) - [◀ اول مرغ بوده یا تخم مرغ؟ \*](#-اول-مرغ-بوده-یا-تخم-مرغ-) + - [💡 توضیح](#-توضیح-13) - [◀ روابط بین زیرمجموعه کلاس‌ها](#-روابط-بین-زیرمجموعه-کلاسها) + - [💡 توضیح:](#-توضیح-14) - [◀ برابری و هویت متدها](#-برابری-و-هویت-متدها) + - [💡 توضیح](#-توضیح-15) - [◀ آل-ترو-یشن \*](#-آل-ترو-یشن-) + - [💡 توضیحات:](#-توضیحات) + - [💡 توضیح:](#-توضیح-16) - [◀ رشته‌ها و بک‌اسلش‌ها](#-رشتهها-و-بکاسلشها) + - [💡 توضیح:](#-توضیح-17) - [◀ گره نیست، نَه!](#-گره-نیست-نَه) + - [💡 توضیح:](#-توضیح-18) - [◀ رشته‌های نیمه سه‌نقل‌قولی](#-رشتههای-نیمه-سهنقلقولی) + - [💡 توضیح:](#-توضیح-19) - [◀ مشکل بولین ها چیست؟](#-مشکل-بولین-ها-چیست) - - [◀ ویژگی‌های کلاس و ویژگی‌های نمونه](#-ویژگیهای-کلاس-و-ویژگیهای-نمونه) - - [◀ yielding None](#-yielding-none) - - [◀ Yielding from... return! \*](#-yielding-from-return-) + - [💡 توضیح:](#-توضیح-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) - [◀ بله، این واقعاً وجود دارد!](#-بله-این-واقعاً-وجود-دارد) - - [◀ Ellipsis \*](#-ellipsis-) + - [💡 توضیح:](#-توضیح-51) + - [◀ عملگر Ellipsis \*](#-عملگر-ellipsis--) + - [💡توضیح](#توضیح) - [◀ بی‌نهایت (`Inpinity`)](#-بینهایت-inpinity) + - [💡 توضیح:](#-توضیح-52) - [◀ بیایید خرابکاری کنیم](#-بیایید-خرابکاری-کنیم) + - [💡 توضیح:](#-توضیح-53) - [بخش: ظاهرها فریبنده‌اند!](#بخش-ظاهرها-فریبندهاند) - [◀ خطوط را رد می‌کند؟](#-خطوط-را-رد-میکند) + - [💡 توضیح](#-توضیح-54) - [◀ تله‌پورت کردن](#-تلهپورت-کردن) + - [💡 توضیح:](#-توضیح-55) - [◀ خب، یک جای کار مشکوک است...](#-خب-یک-جای-کار-مشکوک-است) + - [💡 توضیح](#-توضیح-56) - [بخش: متفرقه](#بخش-متفرقه) - [◀ `+=` سریع‌تر است](#--سریعتر-است) + - [💡 توضیح:](#-توضیح-57) - [◀ بیایید یک رشته‌ی بزرگ بسازیم!](#-بیایید-یک-رشتهی-بزرگ-بسازیم) + - [💡 توضیح](#-توضیح-58) - [◀ کُند کردن جستجوها در `dict` \*](#--کُند-کردن-جستجوها-در-dict-) + - [💡 توضیح:](#-توضیح-59) - [◀ حجیم کردن دیکشنری نمونه‌ها (`instance dicts`) \*](#-حجیم-کردن-دیکشنری-نمونهها-instance-dicts-) + - [💡 توضیح:](#-توضیح-60) - [◀ موارد جزئی \*](#-موارد-جزئی-) - [مشارکت](#مشارکت) - [تقدیر و تشکر](#تقدیر-و-تشکر) From c5e2b94ab06048784ad9b8ab1626a996228d9881 Mon Sep 17 00:00:00 2001 From: Leo Alavi Date: Tue, 29 Apr 2025 14:56:02 +0200 Subject: [PATCH 32/33] Add linting --- translations/fa-farsi/README.md | 607 ++++++++++++++++++++------------ 1 file changed, 374 insertions(+), 233 deletions(-) diff --git a/translations/fa-farsi/README.md b/translations/fa-farsi/README.md index e100c45..22e7eb2 100644 --- a/translations/fa-farsi/README.md +++ b/translations/fa-farsi/README.md @@ -8,12 +8,10 @@

What the f*ck Python! 😱

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

- ترجمه‌ها: [انگلیسی 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) - پایتون، یه زبان زیبا طراحی شده، سطح بالا و مبتنی بر مفسره که قابلیت‌های بسیاری برای راحتی ما برنامه‌نویس‌ها فراهم می‌کنه. ولی گاهی اوقات قطعه‌کدهایی رو می‌بینیم که تو نگاه اول خروجی‌هاشون واضح نیست. @@ -199,16 +197,19 @@ > >>> triggering_statement > یه خروجی غیرمنتظره > ``` +> > (دلخواه): توضیح یک‌خطی خروجی غیرمنتظره > > > #### 💡 توضیح: > -> * توضیح کوتاه درمورد این‌که چی داره اتفاق میافته و چرا. +> - توضیح کوتاه درمورد این‌که چی داره اتفاق میافته و چرا. +> > ```py > # راه اندازی کد > # مثال‌های بیشتر برای شفاف سازی (در صورت نیاز) > ``` +> > **خروجی (نسخه(های) پایتون):** > > ```py @@ -221,16 +222,17 @@ کنند مگراینکه به صورت جداگانه و به طور واضح نسخه مخصوص پایتون قبل از خروجی ذکر شده باشد. - # استفاده یه راه خوب برای بیشتر بهره بردن، به نظرم، اینه که مثال‌ها رو به ترتیب متوالی بخونید و برای هر مثال: + - کد ابتدایی برای راه اندازی مثال رو با دقت بخونید. اگه شما یه پایتون کار سابقه‌دار باشید، با موفقیت بیشتر اوقات اتفاق بعدی رو پیش‌بینی می‌کنید. - قطعه خروجی رو بخونید و - + بررسی کنید که آیا خروجی‌ها همونطور که انتظار دارید هستند. - + مطمئین بشید که دقیقا دلیل اینکه خروجی اون طوری هست رو می‌دونید. + - بررسی کنید که آیا خروجی‌ها همونطور که انتظار دارید هستند. + - مطمئین بشید که دقیقا دلیل اینکه خروجی اون طوری هست رو می‌دونید. - اگه نمی‌دونید (که کاملا عادیه و اصلا بد نیست)، یک نفس عمیق بکشید و توضیحات رو بخونید (و اگه نفهمیدید، داد بزنید! و [اینجا](https://github.com/emargi/wtfpython/issues/new) درموردش حرف بزنید). - اگه می‌دونید، به افتخار خودتون یه دست محکم بزنید و برید سراغ مثال بعدی. + --- # 👀 مثال‌ها @@ -298,8 +300,6 @@ SyntaxError: invalid syntax 16 ``` - - #### 💡 توضیح **مرور سریع بر عملگر Walrus** @@ -374,6 +374,7 @@ if a := some_func(): ``` 2\. + ```py >>> a = "wtf" >>> b = "wtf" @@ -422,12 +423,13 @@ False منطقیه، نه؟ #### 💡 توضیح: -+ در قطعه‌کد اول و دوم، رفتار کد به دلیل یک بهینه سازی در CPython است (به نام داوطلب سازی رشته‌ها) که باعث می‌شود از برخی مقادیر غیرقابل تغییر، به جای مقداردهی مجدد، دوباره استفاده شود. -+ بیشتر متغیرهایی که به‌این صورت جایگزین می‌شوند، در حافظه دستگاه به مقدار داوطلب خود اشاره می‌کنند (تا از حافظه کمتری استفاده شود) -+ در قطعه‌کدهای بالا، رشته‌ها به‌صورت غیرمستقیم داوطلب می‌شوند. تصمیم اینکه رشته‌ها چه زمانی به صورت غیرمستقیم داوطلب شوند به نحوه پیاده‌سازی و مقداردهی آن‌ها بستگی دارد. برخی قوانین وجود دارند تا بتوانیم داوطلب شدن یا نشدن یک رشته را حدس بزنیم: - * همه رشته‌ها با طول صفر یا یک داوطلب می‌شوند. - * رشته‌ها در زمان کامپایل داوطلب می‌شوند (`'wtf'` داوطلب می‌شود اما `''.join(['w', 't', 'f'])` داوطلب نمی‌شود) - * رشته‌هایی که از حروف ASCII ، اعداد صحیح و آندرلاین تشکیل نشده‌باشند داوطلب نمی‌شود. به همین دلیل `'wtf!'` به خاطر وجود `'!'` داوطلب نشد. پیاده‌سازی این قانون در CPython در [اینجا](https://github.com/python/cpython/blob/3.6/Objects/codeobject.c#L19) قرار دارد. + +- در قطعه‌کد اول و دوم، رفتار کد به دلیل یک بهینه سازی در CPython است (به نام داوطلب سازی رشته‌ها) که باعث می‌شود از برخی مقادیر غیرقابل تغییر، به جای مقداردهی مجدد، دوباره استفاده شود. +- بیشتر متغیرهایی که به‌این صورت جایگزین می‌شوند، در حافظه دستگاه به مقدار داوطلب خود اشاره می‌کنند (تا از حافظه کمتری استفاده شود) +- در قطعه‌کدهای بالا، رشته‌ها به‌صورت غیرمستقیم داوطلب می‌شوند. تصمیم اینکه رشته‌ها چه زمانی به صورت غیرمستقیم داوطلب شوند به نحوه پیاده‌سازی و مقداردهی آن‌ها بستگی دارد. برخی قوانین وجود دارند تا بتوانیم داوطلب شدن یا نشدن یک رشته را حدس بزنیم: + - همه رشته‌ها با طول صفر یا یک داوطلب می‌شوند. + - رشته‌ها در زمان کامپایل داوطلب می‌شوند (`'wtf'` داوطلب می‌شود اما `''.join(['w', 't', 'f'])` داوطلب نمی‌شود) + - رشته‌هایی که از حروف ASCII ، اعداد صحیح و آندرلاین تشکیل نشده‌باشند داوطلب نمی‌شود. به همین دلیل `'wtf!'` به خاطر وجود `'!'` داوطلب نشد. پیاده‌سازی این قانون در CPython در [اینجا](https://github.com/python/cpython/blob/3.6/Objects/codeobject.c#L19) قرار دارد.

@@ -437,14 +439,13 @@ False

-+ زمانی که `"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) بیشتر درمورد این تغییرات بخوانید. +- زمانی که `"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 @@ -475,16 +476,18 @@ False شاید چنین رفتاری برای شما احمقانه به نظر بیاد ولی برای عملیات‌هایی مثل `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` است و : +- عبارت `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` است. --- @@ -542,9 +545,10 @@ False **فرض بین عملگرهای `is` و `==`** -* عملگر `is` بررسی میکنه که دو متغیر در حافظه دستگاه به یک شیء اشاره میکنند یا نه (یعنی شناسه متغیرها رو با هم تطبیق میده). -* عملگر `==` مقدار متغیرها رو با هم مقایسه میکنه و یکسان بودنشون رو بررسی میکنه. -* پس `is` برای معادل بودن متغیرها در حافظه دستگاه و `==` برای معادل بودن مقادیر استفاده میشه. یه مثال برای شفاف سازی بیشتر: +- عملگر `is` بررسی میکنه که دو متغیر در حافظه دستگاه به یک شیء اشاره میکنند یا نه (یعنی شناسه متغیرها رو با هم تطبیق میده). +- عملگر `==` مقدار متغیرها رو با هم مقایسه میکنه و یکسان بودنشون رو بررسی میکنه. +- پس `is` برای معادل بودن متغیرها در حافظه دستگاه و `==` برای معادل بودن مقادیر استفاده میشه. یه مثال برای شفاف سازی بیشتر: + ```py >>> class A: pass >>> A() is A() # این‌ها دو شیء خالی هستند که در دو جای مختلف در حافظه قرار دارند. @@ -599,9 +603,9 @@ False 140640774013488 ``` -* وقتی a و b در یک خط با `257` مقداردهی میشن، مفسر پایتون یک شیء برای یکی از متغیرها در حافظه میسازه و متغیر دوم رو در حافظه به اون ارجاع میده. اگه این کار رو تو دو خط جدا از هم انجام بدید، درواقع مفسر پایتون از وجود مقدار `257` به عنوان یک شیء، "خبر نداره". +- وقتی a و b در یک خط با `257` مقداردهی میشن، مفسر پایتون یک شیء برای یکی از متغیرها در حافظه میسازه و متغیر دوم رو در حافظه به اون ارجاع میده. اگه این کار رو تو دو خط جدا از هم انجام بدید، درواقع مفسر پایتون از وجود مقدار `257` به عنوان یک شیء، "خبر نداره". -* این یک بهینه سازی توسط کامپایلر هست و مخصوصا در محیط تعاملی به کار برده میشه. وقتی شما دو خط رو در یک مفسر زنده وارد می‌کنید، اون‌ها به صورت جداگانه کامپایل میشن، به همین دلیل بهینه سازی به صورت جداگانه برای هرکدوم اعمال میشه. اگر بخواهید این مثال رو در یک فایل `.py` امتحان کنید، رفتار متفاوتی می‌بینید زیرا فایل به صورت کلی و یک‌جا کامپایل میشه. این بهینه سازی محدود به اعداد صحیح نیست و برای انواع داده‌های غیرقابل تغییر دیگه مانند رشته‌ها (مثال "رشته‌ها می‌توانند دردسرساز شوند" رو ببینید) و اعداد اعشاری هم اعمال میشه. +- این یک بهینه سازی توسط کامپایلر هست و مخصوصا در محیط تعاملی به کار برده میشه. وقتی شما دو خط رو در یک مفسر زنده وارد می‌کنید، اون‌ها به صورت جداگانه کامپایل میشن، به همین دلیل بهینه سازی به صورت جداگانه برای هرکدوم اعمال میشه. اگر بخواهید این مثال رو در یک فایل `.py` امتحان کنید، رفتار متفاوتی می‌بینید زیرا فایل به صورت کلی و یک‌جا کامپایل میشه. این بهینه سازی محدود به اعداد صحیح نیست و برای انواع داده‌های غیرقابل تغییر دیگه مانند رشته‌ها (مثال "رشته‌ها می‌توانند دردسرساز شوند" رو ببینید) و اعداد اعشاری هم اعمال میشه. ```py >>> a, b = 257.0, 257.0 @@ -609,14 +613,14 @@ False True ``` -* چرا این برای پایتون ۳.۷ کار نکرد؟ دلیل انتزاعیش اینه که چنین بهینه‌سازی‌های کامپایلری وابسته به پیاده‌سازی هستن (یعنی بسته به نسخه، و نوع سیستم‌عامل و چیزهای دیگه تغییر میکنن). من هنوز پیگیرم که بدونم که کدوم تغییر تو پیاده‌سازی باعث همچین مشکلاتی میشه، می‌تونید برای خبرهای بیشتر این [موضوع](https://github.com/satwikkansal/wtfpython/issues/100) رو نگاه کنید. +- چرا این برای پایتون ۳.۷ کار نکرد؟ دلیل انتزاعیش اینه که چنین بهینه‌سازی‌های کامپایلری وابسته به پیاده‌سازی هستن (یعنی بسته به نسخه، و نوع سیستم‌عامل و چیزهای دیگه تغییر میکنن). من هنوز پیگیرم که بدونم که کدوم تغییر تو پیاده‌سازی باعث همچین مشکلاتی میشه، می‌تونید برای خبرهای بیشتر این [موضوع](https://github.com/satwikkansal/wtfpython/issues/100) رو نگاه کنید. --- - ### ◀ کلیدهای هش 1\. + ```py some_dict = {} some_dict[5.5] = "JavaScript" @@ -643,9 +647,10 @@ complex خب، چرا Python همه جارو گرفت؟ - #### 💡 توضیح -* تو دیکشنری‌های پایتون چیزی که کلیدها رو یگانه میکنه مقدار کلیدهاست، نه شناسه اون‌ها. پس با اینکه `5`، `5.0` و `5 + 0j` شیءهای متمایزی از نوع‌های متفاوتی هستند ولی از اون جایی که مقدارشون با هم برابره، نمیتونن داخل یه `dict` به عنوان کلید جدا از هم باشن (حتی به عنوان مقادیر داخل یه `set` نمیتونن باشن). وقتی بخواید داخل یه دیکشنری جست‌وجو کنید، به محض اینکه یکی از این داده‌ها رو وارد کنید، مقدار نگاشته‌شده به کلیدی که مقدار برابر با اون داده داره ولی نوعش متفاوته، با موفقیت برگردونده میشه (به جای اینکه به ارور `KeyError` بردخورد کنید.). + +- تو دیکشنری‌های پایتون چیزی که کلیدها رو یگانه میکنه مقدار کلیدهاست، نه شناسه اون‌ها. پس با اینکه `5`، `5.0` و `5 + 0j` شیءهای متمایزی از نوع‌های متفاوتی هستند ولی از اون جایی که مقدارشون با هم برابره، نمیتونن داخل یه `dict` به عنوان کلید جدا از هم باشن (حتی به عنوان مقادیر داخل یه `set` نمیتونن باشن). وقتی بخواید داخل یه دیکشنری جست‌وجو کنید، به محض اینکه یکی از این داده‌ها رو وارد کنید، مقدار نگاشته‌شده به کلیدی که مقدار برابر با اون داده داره ولی نوعش متفاوته، با موفقیت برگردونده میشه (به جای اینکه به ارور `KeyError` بردخورد کنید.). + ```py >>> 5 == 5.0 == 5 + 0j True @@ -658,7 +663,9 @@ complex >>> (5 in some_dict) and (5 + 0j in some_dict) True ``` -* همچنین این قانون برای مقداردهی توی دیکشنری هم اعمال میشه. وقتی شما عبارت `some_dict[5] = "Python"` رو اجرا می‌کنید، پایتون دنبال کلیدی با مقدار یکسان می‌گرده که اینجا ما داریم `5.0 -> "Ruby"` و مقدار نگاشته‌شده به این کلید در دیکشنری رو با مقدار جدید جایگزین میکنه و کلید رو همونجوری که هست باقی میذاره. + +- همچنین این قانون برای مقداردهی توی دیکشنری هم اعمال میشه. وقتی شما عبارت `some_dict[5] = "Python"` رو اجرا می‌کنید، پایتون دنبال کلیدی با مقدار یکسان می‌گرده که اینجا ما داریم `5.0 -> "Ruby"` و مقدار نگاشته‌شده به این کلید در دیکشنری رو با مقدار جدید جایگزین میکنه و کلید رو همونجوری که هست باقی میذاره. + ```py >>> some_dict {5.0: 'Ruby'} @@ -666,15 +673,18 @@ complex >>> 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` مقدار هش یکسانی دارند. +- خب پس چطوری میتونیم مقدار خود کلید رو به `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 ``` + **توجه:** برعکس این قضیه لزوما درست نیست. شیءهای میتونن هش های یکسانی داشته باشند ولی مقادیر نابرابری داشته باشند. (این باعث به وجود اومدن پدیده‌ای معروف [تصادف هش](https://en.wikipedia.org/wiki/Collision_(disambiguation)#Other_uses) میشه)، در این صورت توابع هش عملکرد خودشون رو کندتر از حالت عادی انجام می‌دهند. --- @@ -687,6 +697,7 @@ class WTF: ``` **خروجی:** + ```py >>> WTF() == WTF() # دو نمونه متفاوت از یک کلاس نمیتونند برابر هم باشند False @@ -699,10 +710,12 @@ True ``` #### 💡 توضیح: -* وقتی `id` صدا زده شد، پایتون یک شیء با کلاس `WTF` ساخت و اون رو به تابع `id` داد. تابع `id` شناسه این شیء رو میگیره (درواقع آدرس اون شیء در حافظه دستگاه) و شیء رو حذف میکنه. -* وقتی این کار رو دو بار متوالی انجام بدیم، پایتون آدرس یکسانی رو به شیء دوم اختصاص میده. از اونجایی که (در CPython) تابع `id` از آدرس شیءها توی حافظه به عنوان شناسه برای اون‌ها استفاده میکنه، پس شناسه این دو شیء یکسانه. -* پس، شناسه یک شیء تا زمانی که اون شیء وجود داره، منحصربه‌فرده. بعد از اینکه اون شیء حذف میشه یا قبل از اینکه اون شیء به وجود بیاد، چیز دیگه‌ای میتونه اون شناسه رو داشته باشه. -* ولی چرا با عملگر `is` مقدار `False` رو دریافت کردیم؟ بیاید با یه قطعه‌کد ببینیم دلیلش رو. + +- وقتی `id` صدا زده شد، پایتون یک شیء با کلاس `WTF` ساخت و اون رو به تابع `id` داد. تابع `id` شناسه این شیء رو میگیره (درواقع آدرس اون شیء در حافظه دستگاه) و شیء رو حذف میکنه. +- وقتی این کار رو دو بار متوالی انجام بدیم، پایتون آدرس یکسانی رو به شیء دوم اختصاص میده. از اونجایی که (در CPython) تابع `id` از آدرس شیءها توی حافظه به عنوان شناسه برای اون‌ها استفاده میکنه، پس شناسه این دو شیء یکسانه. +- پس، شناسه یک شیء تا زمانی که اون شیء وجود داره، منحصربه‌فرده. بعد از اینکه اون شیء حذف میشه یا قبل از اینکه اون شیء به وجود بیاد، چیز دیگه‌ای میتونه اون شناسه رو داشته باشه. +- ولی چرا با عملگر `is` مقدار `False` رو دریافت کردیم؟ بیاید با یه قطعه‌کد ببینیم دلیلش رو. + ```py class WTF(object): def __init__(self): print("I") @@ -710,6 +723,7 @@ True ``` **خروجی:** + ```py >>> WTF() is WTF() I @@ -724,11 +738,11 @@ True D True ``` + همونطور که مشاهده می‌کنید، ترتیب حذف شدن شیءها باعث تفاوت میشه. --- - ### ◀ بی‌نظمی در خود نظم * ```py @@ -757,6 +771,7 @@ class OrderedDictWithHash(OrderedDict): ``` **خروجی** + ```py >>> dictionary == ordered_dict # اگر مقدار اولی با دومی برابره True @@ -795,6 +810,7 @@ TypeError: unhashable type: 'dict' > مقایسه برابری بین شیءهایی از نوع OrderedDict به ترتیب اعضای آن‌ها هم بستگی دارد و به صورت `list(od1.items())==list(od2.items())` پیاده سازی شده است. مقایسه برابری بین شیءهای `OrderedDict` و شیءهای قابل نگاشت دیگر به ترتیب اعضای آن‌ها بستگی ندارد و مقایسه همانند دیکشنری‌های عادی انجام می‌شود. - این رفتار باعث میشه که بتونیم `OrderedDict` ها رو هرجایی که یک دیکشنری عادی کاربرد داره، جایگزین کنیم و استفاده کنیم. - خب، حالا چرا تغییر ترتیب روی طول مجموعه‌ای که از دیکشنری‌ها ساختیم، تاثیر گذاشت؟ جوابش همین رفتار مقایسه‌ای غیرانتقالی بین این شیءهاست. از اونجایی که `set` ها مجموعه‌ای از عناصر غیرتکراری و بدون نظم هستند، ترتیبی که عناصر تو این مجموعه‌ها درج میشن نباید مهم باشه. ولی در این مورد، مهم هست. بیاید کمی تجزیه و تحلیلش کنیم. + ```py >>> some_set = set() >>> some_set.add(dictionary) # این شیء‌ها از قطعه‌کدهای بالا هستند. @@ -827,7 +843,6 @@ TypeError: unhashable type: 'dict' --- - ### ◀ تلاش کن... * ```py @@ -889,7 +904,6 @@ Iteration 0 --- - ### ◀ برای چی؟ ```py @@ -900,18 +914,23 @@ for i, some_dict[i] in enumerate(some_string): ``` **خروجی:** + ```py >>> some_dict # یک دیکشنری مرتب‌شده نمایان میشه. {0: 'w', 1: 't', 2: 'f'} ``` -#### 💡 توضیح: -* یک حلقه `for` در [گرامر پایتون](https://docs.python.org/3/reference/grammar.html) این طور تعریف میشه: +#### 💡 توضیح: + +- یک حلقه `for` در [گرامر پایتون](https://docs.python.org/3/reference/grammar.html) این طور تعریف میشه: + ``` for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite] ``` + به طوری که `exprlist` یک هدف برای مقداردهیه. این یعنی، معادل عبارت `{exprlist} = {next_value}` **برای هر شیء داخل `testlist` اجرا می‌شود**. یک مثال جالب برای نشون دادن این تعریف: + ```py for i in range(4): print(i) @@ -919,6 +938,7 @@ for i, some_dict[i] in enumerate(some_string): ``` **خروجی:** + ``` 0 1 @@ -932,7 +952,8 @@ for i, some_dict[i] in enumerate(some_string): - عبارت مقداردهی `i = 10` به خاطر نحوه کار کردن حلقه‌ها، هیچوقت باعث تغییر در تکرار حلقه نمیشه. قبل از شروع هر تکرار، مقدار بعدی که توسط شیء قابل تکرار (که در اینجا `range(4)` است) ارائه میشه، از بسته خارج میشه و به متغیرهای لیست هدف (که در اینجا `i` است) مقداردهی میشه. -* تابع `enumerate(some_string)`، یک متغیر `i` (که یک شمارنده افزایشی است) و یک حرف از حروف رشته `some_string` رو در هر تکرار برمیگردونه. و بعدش برای کلید `i` (تازه مقداردهی‌شده) در دیکشنری `some_dict`، مقدار اون حرف رو تنظیم می‌کنه. بازشده این حلقه می‌تونه مانند مثال زیر ساده بشه: +- تابع `enumerate(some_string)`، یک متغیر `i` (که یک شمارنده افزایشی است) و یک حرف از حروف رشته `some_string` رو در هر تکرار برمیگردونه. و بعدش برای کلید `i` (تازه مقداردهی‌شده) در دیکشنری `some_dict`، مقدار اون حرف رو تنظیم می‌کنه. بازشده این حلقه می‌تونه مانند مثال زیر ساده بشه: + ```py >>> i, some_dict[i] = (0, 'w') >>> i, some_dict[i] = (1, 't') @@ -945,6 +966,7 @@ for i, some_dict[i] in enumerate(some_string): ### ◀ اختلاف زمانی در محاسبه 1\. + ```py array = [1, 8, 15] # یک عبارت تولیدکننده عادی @@ -972,6 +994,7 @@ array_2[:] = [1,2,3,4,5] ``` **خروجی:** + ```py >>> print(list(gen_1)) [1, 2, 3, 4] @@ -992,6 +1015,7 @@ array_4 = [400, 500, 600] ``` **خروجی:** + ```py >>> print(list(gen)) [401, 501, 601, 402, 502, 602, 403, 503, 603] @@ -1010,7 +1034,6 @@ array_4 = [400, 500, 600] --- - ### ◀ هر گردی، گردو نیست ```py @@ -1021,13 +1044,13 @@ False ``` #### 💡 توضیح + - عملگر `is not` یک عملگر باینری واحده و رفتارش متفاوت تر از استفاده `is` و `not` به صورت جداگانه‌ست. - عملگر `is not` مقدار `False` رو برمیگردونه اگر متغیرها در هردو سمت این عملگر به شیء یکسانی اشاره کنند و درغیر این صورت، مقدار `True` برمیگردونه - در مثال بالا، عبارت `(not None)` برابره با مقدار `True` از اونجایی که مقدار `None` در زمینه boolean به `False` تبدیل میشه. پس کل عبارت معادل عبارت `'something' is True` میشه. --- - ### ◀ یک بازی دوز که توش X همون اول برنده میشه! @@ -1092,11 +1115,9 @@ board = [row] * 3 --- - ### ◀ متغیر شرودینگر * - ```py funcs = [] results = [] @@ -1110,6 +1131,7 @@ funcs_results = [func() for func in funcs] ``` **خروجی:** + ```py >>> results [0, 1, 2, 3, 4, 5, 6] @@ -1128,7 +1150,8 @@ funcs_results = [func() for func in funcs] ``` #### 💡 توضیح: -* وقتی یک تابع رو در داخل یک حلقه تعریف می‌کنیم که در بدنه‌اش از متغیر اون حلقه استفاده شده، بست این تابع به *متغیر* وصله، نه *مقدار* اون. تابع به جای اینکه از مقدار `x` در زمان تعریف تابع استفاده کنه، در زمینه اطرافش دنبال `x` می‌گرده. پس همه این توابع از آخرین مقداری که به متغیر `x` مقداردهی شده برای محاسباتشون استفاده می‌کنند. ما می‌تونیم ببینیم که این توابع از متغیر `x` که در زمینه اطرافشون (*نه* از متغیر محلی) هست، استفاده می‌کنند، به این صورت: + +- وقتی یک تابع رو در داخل یک حلقه تعریف می‌کنیم که در بدنه‌اش از متغیر اون حلقه استفاده شده، بست این تابع به *متغیر* وصله، نه *مقدار* اون. تابع به جای اینکه از مقدار `x` در زمان تعریف تابع استفاده کنه، در زمینه اطرافش دنبال `x` می‌گرده. پس همه این توابع از آخرین مقداری که به متغیر `x` مقداردهی شده برای محاسباتشون استفاده می‌کنند. ما می‌تونیم ببینیم که این توابع از متغیر `x` که در زمینه اطرافشون (*نه* از متغیر محلی) هست، استفاده می‌کنند، به این صورت: ```py >>> import inspect @@ -1144,7 +1167,7 @@ ClosureVars(nonlocals={}, globals={'x': 6}, builtins={}, unbound=set()) [42, 42, 42, 42, 42, 42, 42] ``` -* برای رسیدن به رفتار موردنظر شما می‌تونید متغیر حلقه رو به عنوان یک متغیر اسم‌دار به تابع بدید. **چرا در این صورت کار می‌کنه؟** چون اینجوری یک متغیر در دامنه خود تابع تعریف میشه. تابع دیگه دنبال مقدار `x` در دامنه اطراف (سراسری) نمی‌گرده ولی یک متغیر محلی برای ذخیره کردن مقدار `x` در اون لحظه می‌سازه. +- برای رسیدن به رفتار موردنظر شما می‌تونید متغیر حلقه رو به عنوان یک متغیر اسم‌دار به تابع بدید. **چرا در این صورت کار می‌کنه؟** چون اینجوری یک متغیر در دامنه خود تابع تعریف میشه. تابع دیگه دنبال مقدار `x` در دامنه اطراف (سراسری) نمی‌گرده ولی یک متغیر محلی برای ذخیره کردن مقدار `x` در اون لحظه می‌سازه. ```py funcs = [] @@ -1171,10 +1194,10 @@ ClosureVars(nonlocals={}, globals={}, builtins={}, unbound=set()) --- - ### ◀ اول مرغ بوده یا تخم مرغ؟ * 1\. + ```py >>> isinstance(3, int) True @@ -1186,7 +1209,7 @@ True پس کدوم کلاس پایه "نهایی" هست؟ راستی سردرگمی بیشتری هم تو راهه. -2\. +2\. ```py >>> class A: pass @@ -1209,23 +1232,22 @@ True False ``` - #### 💡 توضیح - در پایتون، `type` یک [متاکلاس](https://realpython.com/python-metaclasses/) است. - در پایتون **همه چیز** یک `object` است، که کلاس‌ها و همچنین نمونه‌هاشون (یا همان instance های کلاس‌ها) هم شامل این موضوع میشن. - کلاس `type` یک متاکلاسه برای کلاس `object` و همه کلاس‌ها (همچنین کلاس `type`) به صورت مستقیم یا غیرمستقیم از کلاس `object` ارث بری کرده است. - هیچ کلاس پایه واقعی بین کلاس‌های `object` و `type` وجود نداره. سردرگمی که در قطعه‌کدهای بالا به وجود اومده، به خاطر اینه که ما به این روابط (یعنی `issubclass` و `isinstance`) از دیدگاه کلاس‌های پایتون فکر می‌کنیم. رابطه بین `object` و `type` رو در پایتون خالص نمیشه بازتولید کرد. برای اینکه دقیق‌تر باشیم، رابطه‌های زیر در پایتون خالص نمی‌تونند بازتولید بشن. - + کلاس A یک نمونه از کلاس B، و کلاس B یک نمونه از کلاس A باشه. - + کلاس A یک نمونه از خودش باشه. + - کلاس A یک نمونه از کلاس B، و کلاس B یک نمونه از کلاس A باشه. + - کلاس A یک نمونه از خودش باشه. - این روابط بین `object` و `type` (که هردو نمونه یکدیگه و همچنین خودشون باشند) به خاطر "تقلب" در مرحله پیاده‌سازی، وجود دارند. --- - ### ◀ روابط بین زیرمجموعه کلاس‌ها **خروجی:** + ```py >>> from collections.abc import Hashable >>> issubclass(list, object) @@ -1236,14 +1258,14 @@ True False ``` -ما انتظار داشتیم که روابط بین زیرکلاس‌ها، انتقالی باشند، درسته؟ (یعنی اگه `A` زیرکلاس `B` باشه و `B` هم زیرکلاس `C` باشه، کلس `A` __باید__ زیرکلاس `C` باشه) +ما انتظار داشتیم که روابط بین زیرکلاس‌ها، انتقالی باشند، درسته؟ (یعنی اگه `A` زیرکلاس `B` باشه و `B` هم زیرکلاس `C` باشه، کلس `A` **باید** زیرکلاس `C` باشه) #### 💡 توضیح: -* روابط بین زیرکلاس‌ها در پایتون لزوما انتقالی نیستند. همه مجازند که تابع `__subclasscheck__` دلخواه خودشون رو در یک متاکلاس تعریف کنند. -* وقتی عبارت `issubclass(cls, Hashable)` اجرا میشه، برنامه دنبال یک تابع "غیر نادرست" (یا non-Falsy) در `cls` یا هرچیزی که ازش ارث‌بری می‌کنه، می‌گرده. -* از اونجایی که `object` قابل هش شدنه، ولی `list` این‌طور نیست، رابطه انتقالی شکسته میشه. -* توضیحات با جزئیات بیشتر [اینجا](https://www.naftaliharris.com/blog/python-subclass-intransitivity/) پیدا میشه. +- روابط بین زیرکلاس‌ها در پایتون لزوما انتقالی نیستند. همه مجازند که تابع `__subclasscheck__` دلخواه خودشون رو در یک متاکلاس تعریف کنند. +- وقتی عبارت `issubclass(cls, Hashable)` اجرا میشه، برنامه دنبال یک تابع "غیر نادرست" (یا non-Falsy) در `cls` یا هرچیزی که ازش ارث‌بری می‌کنه، می‌گرده. +- از اونجایی که `object` قابل هش شدنه، ولی `list` این‌طور نیست، رابطه انتقالی شکسته میشه. +- توضیحات با جزئیات بیشتر [اینجا](https://www.naftaliharris.com/blog/python-subclass-intransitivity/) پیدا میشه. --- @@ -1251,6 +1273,7 @@ False 1. + ```py class SomeClass: def method(self): @@ -1266,6 +1289,7 @@ class SomeClass: ``` **خروجی:** + ```py >>> print(SomeClass.method is SomeClass.method) True @@ -1281,12 +1305,14 @@ True چه اتفاقی برای نمونه‌های `SomeClass` می‌افتد: 2. + ```py o1 = SomeClass() o2 = SomeClass() ``` **خروجی:** + ```py >>> print(o1.method == o2.method) False @@ -1305,35 +1331,46 @@ True دسترسی به `classm` یا `method` دو بار، اشیایی برابر اما نه *یکسان* را برای همان نمونه از `SomeClass` ایجاد می‌کند. #### 💡 توضیح -* تابع‌ها [وصاف](https://docs.python.org/3/howto/descriptor.html) هستند. هر زمان که تابعی به عنوان یک ویژگی فراخوانی شود، وصف فعال می‌شود و یک شیء متد ایجاد می‌کند که تابع را به شیء صاحب آن ویژگی "متصل" می‌کند. اگر این متد فراخوانی شود، تابع را با ارسال ضمنی شیء متصل‌شده به عنوان اولین آرگومان صدا می‌زند (به این ترتیب است که `self` را به عنوان اولین آرگومان دریافت می‌کنیم، با وجود اینکه آن را به‌طور صریح ارسال نکرده‌ایم). + +- تابع‌ها [وصاف](https://docs.python.org/3/howto/descriptor.html) هستند. هر زمان که تابعی به عنوان یک ویژگی فراخوانی شود، وصف فعال می‌شود و یک شیء متد ایجاد می‌کند که تابع را به شیء صاحب آن ویژگی "متصل" می‌کند. اگر این متد فراخوانی شود، تابع را با ارسال ضمنی شیء متصل‌شده به عنوان اولین آرگومان صدا می‌زند (به این ترتیب است که `self` را به عنوان اولین آرگومان دریافت می‌کنیم، با وجود اینکه آن را به‌طور صریح ارسال نکرده‌ایم). + ```py >>> o1.method > ``` -* دسترسی به ویژگی چندین بار، هر بار یک شیء متد جدید ایجاد می‌کند! بنابراین عبارت `o1.method is o1.method` هرگز درست (truthy) نیست. با این حال، دسترسی به تابع‌ها به عنوان ویژگی‌های کلاس (و نه نمونه) متد ایجاد نمی‌کند؛ بنابراین عبارت `SomeClass.method is SomeClass.method` درست است. + +- دسترسی به ویژگی چندین بار، هر بار یک شیء متد جدید ایجاد می‌کند! بنابراین عبارت `o1.method is o1.method` هرگز درست (truthy) نیست. با این حال، دسترسی به تابع‌ها به عنوان ویژگی‌های کلاس (و نه نمونه) متد ایجاد نمی‌کند؛ بنابراین عبارت `SomeClass.method is SomeClass.method` درست است. + ```py >>> SomeClass.method ``` -* `classmethod` توابع را به متدهای کلاس تبدیل می‌کند. متدهای کلاس وصاف‌هایی هستند که هنگام دسترسی، یک شیء متد ایجاد می‌کنند که به *کلاس* (نوع) شیء متصل می‌شود، نه خود شیء. + +- `classmethod` توابع را به متدهای کلاس تبدیل می‌کند. متدهای کلاس وصاف‌هایی هستند که هنگام دسترسی، یک شیء متد ایجاد می‌کنند که به *کلاس* (نوع) شیء متصل می‌شود، نه خود شیء. + ```py >>> o1.classm > ``` -* برخلاف توابع، `classmethod`‌ها هنگام دسترسی به عنوان ویژگی‌های کلاس نیز یک شیء متد ایجاد می‌کنند (که در این حالت به خود کلاس متصل می‌شوند، نه نوع آن). بنابراین عبارت `SomeClass.classm is SomeClass.classm` نادرست (falsy) است. + +- برخلاف توابع، `classmethod`‌ها هنگام دسترسی به عنوان ویژگی‌های کلاس نیز یک شیء متد ایجاد می‌کنند (که در این حالت به خود کلاس متصل می‌شوند، نه نوع آن). بنابراین عبارت `SomeClass.classm is SomeClass.classm` نادرست (falsy) است. + ```py >>> SomeClass.classm > ``` -* یک شیء متد زمانی برابر در نظر گرفته می‌شود که هم تابع‌ها برابر باشند و هم شیءهای متصل‌شده یکسان باشند. بنابراین عبارت `o1.method == o1.method` درست (truthy) است، هرچند که آن‌ها در حافظه شیء یکسانی نیستند. -* `staticmethod` توابع را به یک وصف "بدون عملیات" (no-op) تبدیل می‌کند که تابع را به همان صورت بازمی‌گرداند. هیچ شیء متدی ایجاد نمی‌شود، بنابراین مقایسه با `is` نیز درست (truthy) است. + +- یک شیء متد زمانی برابر در نظر گرفته می‌شود که هم تابع‌ها برابر باشند و هم شیءهای متصل‌شده یکسان باشند. بنابراین عبارت `o1.method == o1.method` درست (truthy) است، هرچند که آن‌ها در حافظه شیء یکسانی نیستند. +- `staticmethod` توابع را به یک وصف "بدون عملیات" (no-op) تبدیل می‌کند که تابع را به همان صورت بازمی‌گرداند. هیچ شیء متدی ایجاد نمی‌شود، بنابراین مقایسه با `is` نیز درست (truthy) است. + ```py >>> o1.staticm >>> SomeClass.staticm ``` -* ایجاد شیءهای "متد" جدید در هر بار فراخوانی متدهای نمونه و نیاز به اصلاح آرگومان‌ها برای درج `self`، عملکرد را به شدت تحت تأثیر قرار می‌داد. + +- ایجاد شیءهای "متد" جدید در هر بار فراخوانی متدهای نمونه و نیاز به اصلاح آرگومان‌ها برای درج `self`، عملکرد را به شدت تحت تأثیر قرار می‌داد. CPython 3.7 [این مشکل را حل کرد](https://bugs.python.org/issue26110) با معرفی opcodeهای جدیدی که فراخوانی متدها را بدون ایجاد شیء متد موقتی مدیریت می‌کنند. این به شرطی است که تابع دسترسی‌یافته واقعاً فراخوانی شود، بنابراین قطعه‌کدهای اینجا تحت تأثیر قرار نمی‌گیرند و همچنان متد ایجاد می‌کنند :) ### ◀ آل-ترو-یشن * @@ -1409,6 +1446,7 @@ SyntaxError: invalid syntax ### ◀ رشته‌ها و بک‌اسلش‌ها **خروجی:** + ```py >>> print("\"") " @@ -1429,11 +1467,14 @@ True #### 💡 توضیح: - در یک رشته‌ی معمولی در پایتون، بک‌اسلش برای فرار دادن (escape) نویسه‌هایی استفاده می‌شود که ممکن است معنای خاصی داشته باشند (مانند تک‌نقل‌قول، دوتا‌نقل‌قول، و خودِ بک‌اسلش). + ```py >>> "wt\"f" 'wt"f' ``` + - در یک رشته‌ی خام (raw string literal) که با پیشوند `r` مشخص می‌شود، بک‌اسلش‌ها خودشان به همان شکل منتقل می‌شوند، به‌همراه رفتار فرار دادن نویسه‌ی بعدی. + ```py >>> r'wt\"f' == 'wt\\"f' True @@ -1445,6 +1486,7 @@ True >>> print(r"\\n") '\\n' ``` + - در یک رشته‌ی خام (raw string) که با پیشوند `r` مشخص می‌شود، بک‌اسلش‌ها خودشان به همان صورت منتقل می‌شوند، همراه با رفتاری که کاراکتر بعدی را فرار می‌دهد (escape می‌کند). --- @@ -1457,6 +1499,7 @@ y = False ``` **خروجی:** + ```py >>> not x == y True @@ -1469,16 +1512,17 @@ SyntaxError: invalid syntax #### 💡 توضیح: -* تقدم عملگرها بر نحوه‌ی ارزیابی یک عبارت تأثیر می‌گذارد، و در پایتون، عملگر `==` تقدم بالاتری نسبت به عملگر `not` دارد. -* بنابراین عبارت `not x == y` معادل `not (x == y)` است که خودش معادل `not (True == False)` بوده و در نهایت به `True` ارزیابی می‌شود. -* اما `x == not y` یک `SyntaxError` ایجاد می‌کند، چون می‌توان آن را به صورت `(x == not) y` تفسیر کرد، نه آن‌طور که در نگاه اول انتظار می‌رود یعنی `x == (not y)`. -* تجزیه‌گر (parser) انتظار دارد که توکن `not` بخشی از عملگر `not in` باشد (چون هر دو عملگر `==` و `not in` تقدم یکسانی دارند)، اما پس از اینکه توکن `in` بعد از `not` پیدا نمی‌شود، خطای `SyntaxError` صادر می‌شود. +- تقدم عملگرها بر نحوه‌ی ارزیابی یک عبارت تأثیر می‌گذارد، و در پایتون، عملگر `==` تقدم بالاتری نسبت به عملگر `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` صادر می‌شود. --- ### ◀ رشته‌های نیمه سه‌نقل‌قولی **خروجی:** + ```py >>> print('wtfpython''') wtfpython @@ -1494,7 +1538,8 @@ SyntaxError: EOF while scanning triple-quoted string literal ``` #### 💡 توضیح: -+ پایتون از الحاق ضمنی [رشته‌های متنی](https://docs.python.org/3/reference/lexical_analysis.html#string-literal-concatenation) پشتیبانی می‌کند. برای مثال، + +- پایتون از الحاق ضمنی [رشته‌های متنی](https://docs.python.org/3/reference/lexical_analysis.html#string-literal-concatenation) پشتیبانی می‌کند. برای مثال، ``` >>> print("wtf" "python") @@ -1503,7 +1548,7 @@ SyntaxError: EOF while scanning triple-quoted string literal wtf ``` -+ `'''` و `"""` نیز جداکننده‌های رشته‌ای در پایتون هستند که باعث ایجاد SyntaxError می‌شوند، چون مفسر پایتون هنگام اسکن رشته‌ای که با سه‌نقل‌قول آغاز شده، انتظار یک سه‌نقل‌قول پایانی به‌عنوان جداکننده را دارد. +- `'''` و `"""` نیز جداکننده‌های رشته‌ای در پایتون هستند که باعث ایجاد SyntaxError می‌شوند، چون مفسر پایتون هنگام اسکن رشته‌ای که با سه‌نقل‌قول آغاز شده، انتظار یک سه‌نقل‌قول پایانی به‌عنوان جداکننده را دارد. --- @@ -1527,6 +1572,7 @@ for item in mixed_list: ``` **خروجی:** + ```py >>> integers_found_so_far 4 @@ -1534,8 +1580,8 @@ for item in mixed_list: 0 ``` - 2\. + ```py >>> some_bool = True >>> "wtf" * some_bool @@ -1561,20 +1607,19 @@ def tell_truth(): I have lost faith in truth! ``` - - #### 💡 توضیح: -* در پایتون، `bool` زیرکلاسی از `int` است - +- در پایتون، `bool` زیرکلاسی از `int` است + ```py >>> issubclass(bool, int) True >>> issubclass(int, bool) False ``` - -* و بنابراین، `True` و `False` نمونه‌هایی از `int` هستند + +- و بنابراین، `True` و `False` نمونه‌هایی از `int` هستند + ```py >>> isinstance(True, int) True @@ -1582,7 +1627,8 @@ I have lost faith in truth! True ``` -* مقدار عددی `True` برابر با `1` و مقدار عددی `False` برابر با `0` است. +- مقدار عددی `True` برابر با `1` و مقدار عددی `False` برابر با `0` است. + ```py >>> int(True) 1 @@ -1590,17 +1636,18 @@ I have lost faith in truth! 0 ``` -* این پاسخ در StackOverflow را ببینید: [answer](https://stackoverflow.com/a/8169049/4354153) برای توضیح منطقی پشت این موضوع. +- این پاسخ در StackOverflow را ببینید: [answer](https://stackoverflow.com/a/8169049/4354153) برای توضیح منطقی پشت این موضوع. -* در ابتدا، پایتون نوع `bool` نداشت (کاربران از 0 برای false و مقادیر غیر صفر مثل 1 برای true استفاده می‌کردند). `True`، `False` و نوع `bool` در نسخه‌های 2.x اضافه شدند، اما برای سازگاری با نسخه‌های قبلی، `True` و `False` نمی‌توانستند به عنوان ثابت تعریف شوند. آن‌ها فقط متغیرهای توکار (built-in) بودند و امکان تغییر مقدارشان وجود داشت. +- در ابتدا، پایتون نوع `bool` نداشت (کاربران از 0 برای false و مقادیر غیر صفر مثل 1 برای true استفاده می‌کردند). `True`، `False` و نوع `bool` در نسخه‌های 2.x اضافه شدند، اما برای سازگاری با نسخه‌های قبلی، `True` و `False` نمی‌توانستند به عنوان ثابت تعریف شوند. آن‌ها فقط متغیرهای توکار (built-in) بودند و امکان تغییر مقدارشان وجود داشت. -* پایتون ۳ با نسخه‌های قبلی ناسازگار بود، این مشکل سرانجام رفع شد، و بنابراین قطعه‌کد آخر در نسخه‌های Python 3.x کار نخواهد کرد! +- پایتون ۳ با نسخه‌های قبلی ناسازگار بود، این مشکل سرانجام رفع شد، و بنابراین قطعه‌کد آخر در نسخه‌های Python 3.x کار نخواهد کرد! --- ### ◀ متغیرهای کلاس و متغیرهای نمونه 1\. + ```py class A: x = 1 @@ -1613,6 +1660,7 @@ class C(A): ``` **Output:** + ```py >>> A.x, B.x, C.x (1, 1, 1) @@ -1631,6 +1679,7 @@ class C(A): ``` 2\. + ```py class SomeClass: some_var = 15 @@ -1663,9 +1712,8 @@ True #### 💡 توضیح: -* متغیرهای کلاس و متغیرهای نمونه‌های کلاس درونی به‌صورت دیکشنری‌هایی از شیء کلاس مدیریت می‌شوند. اگر نام متغیری در دیکشنری کلاس جاری پیدا نشود، کلاس‌های والد برای آن جست‌وجو می‌شوند. -* عملگر `+=` شیء قابل‌تغییر (mutable) را به‌صورت درجا (in-place) تغییر می‌دهد بدون اینکه شیء جدیدی ایجاد کند. بنابراین، تغییر ویژگی یک نمونه بر نمونه‌های دیگر و همچنین ویژگی کلاس تأثیر می‌گذارد. - +- متغیرهای کلاس و متغیرهای نمونه‌های کلاس درونی به‌صورت دیکشنری‌هایی از شیء کلاس مدیریت می‌شوند. اگر نام متغیری در دیکشنری کلاس جاری پیدا نشود، کلاس‌های والد برای آن جست‌وجو می‌شوند. +- عملگر `+=` شیء قابل‌تغییر (mutable) را به‌صورت درجا (in-place) تغییر می‌دهد بدون اینکه شیء جدیدی ایجاد کند. بنابراین، تغییر ویژگی یک نمونه بر نمونه‌های دیگر و همچنین ویژگی کلاس تأثیر می‌گذارد. --- @@ -1694,6 +1742,7 @@ def some_func(val): ``` #### 💡 توضیح: + - این یک باگ در نحوه‌ی مدیریت `yield` توسط CPython در ژنراتورها و درک لیستی (comprehensions) است. - منبع و توضیحات را می‌توانید اینجا ببینید: https://stackoverflow.com/questions/32139885/yield-in-list-comprehensions-and-generator-expressions - گزارش باگ مرتبط: https://bugs.python.org/issue10544 @@ -1701,7 +1750,6 @@ def some_func(val): --- - ### ◀ بازگرداندن با استفاده از `yield from`! 1\. @@ -1745,13 +1793,13 @@ def some_func(x): #### 💡 توضیح: -+ از پایتون نسخه ۳.۳ به بعد، امکان استفاده از عبارت `return` همراه با مقدار در داخل ژنراتورها فراهم شد (نگاه کنید به [PEP380](https://www.python.org/dev/peps/pep-0380/)). [مستندات رسمی](https://www.python.org/dev/peps/pep-0380/#enhancements-to-stopiteration) می‌گویند: +- از پایتون نسخه ۳.۳ به بعد، امکان استفاده از عبارت `return` همراه با مقدار در داخل ژنراتورها فراهم شد (نگاه کنید به [PEP380](https://www.python.org/dev/peps/pep-0380/)). [مستندات رسمی](https://www.python.org/dev/peps/pep-0380/#enhancements-to-stopiteration) می‌گویند: > دلیل: "... `return expr` در یک ژنراتور باعث می‌شود که هنگام خروج از ژنراتور، `StopIteration(expr)` ایجاد شود." -+ در حالت `some_func(3)`، استثنای `StopIteration` در ابتدای اجرا به دلیل وجود دستور `return` رخ می‌دهد. این استثنا به‌طور خودکار درون پوشش `list(...)` و حلقه `for` گرفته می‌شود. بنابراین، دو قطعه‌کد بالا منجر به یک لیست خالی می‌شوند. +- در حالت `some_func(3)`، استثنای `StopIteration` در ابتدای اجرا به دلیل وجود دستور `return` رخ می‌دهد. این استثنا به‌طور خودکار درون پوشش `list(...)` و حلقه `for` گرفته می‌شود. بنابراین، دو قطعه‌کد بالا منجر به یک لیست خالی می‌شوند. -+ برای اینکه مقدار `["wtf"]` را از ژنراتور `some_func` بگیریم، باید استثنای `StopIteration` را خودمان مدیریت کنیم، +- برای اینکه مقدار `["wtf"]` را از ژنراتور `some_func` بگیریم، باید استثنای `StopIteration` را خودمان مدیریت کنیم، ```py try: @@ -1818,8 +1866,6 @@ False True ``` - - #### 💡 توضیح: - در اینجا، `'inf'` و `'nan'` رشته‌هایی خاص هستند (نسبت به حروف بزرگ و کوچک حساس نیستند) که وقتی به‌طور صریح به نوع `float` تبدیل شوند، به ترتیب برای نمایش "بی‌نهایت" ریاضی و "عدد نیست" استفاده می‌شوند. @@ -1855,6 +1901,7 @@ another_tuple = ([1, 2], [3, 4], [5, 6]) ``` **خروجی:** + ```py >>> some_tuple[2] = "change this" TypeError: 'tuple' object does not support item assignment @@ -1871,14 +1918,13 @@ TypeError: 'tuple' object does not support item assignment #### 💡 توضیح: -* نقل‌قول از https://docs.python.org/3/reference/datamodel.html +- نقل‌قول از https://docs.python.org/3/reference/datamodel.html > دنباله‌های تغییرناپذیر شیئی از نوع دنباله‌ی تغییرناپذیر، پس از ایجاد دیگر قابل تغییر نیست. (اگر شیء شامل ارجاع‌هایی به اشیای دیگر باشد، این اشیای دیگر ممکن است قابل تغییر باشند و تغییر کنند؛ اما مجموعه‌ی اشیایی که مستقیماً توسط یک شیء تغییرناپذیر ارجاع داده می‌شوند، نمی‌تواند تغییر کند.) -* عملگر `+=` لیست را به‌صورت درجا (in-place) تغییر می‌دهد. تخصیص به یک عضو کار نمی‌کند، اما زمانی که استثنا ایجاد می‌شود، عضو موردنظر پیش از آن به‌صورت درجا تغییر کرده است. -* همچنین توضیحی در [پرسش‌های متداول رسمی پایتون](https://docs.python.org/3/faq/programming.html#why-does-a-tuple-i-item-raise-an-exception-when-the-addition-works) وجود دارد. - +- عملگر `+=` لیست را به‌صورت درجا (in-place) تغییر می‌دهد. تخصیص به یک عضو کار نمی‌کند، اما زمانی که استثنا ایجاد می‌شود، عضو موردنظر پیش از آن به‌صورت درجا تغییر کرده است. +- همچنین توضیحی در [پرسش‌های متداول رسمی پایتون](https://docs.python.org/3/faq/programming.html#why-does-a-tuple-i-item-raise-an-exception-when-the-addition-works) وجود دارد. --- @@ -1894,19 +1940,22 @@ except Exception as e: ``` **Output (Python 2.x):** + ```py >>> print(e) # چیزی چاپ نمی شود. ``` **Output (Python 3.x):** + ```py >>> print(e) NameError: name 'e' is not defined ``` #### 💡 توضیح: -* منبع: [مستندات رسمی پایتون](https://docs.python.org/3/reference/compound_stmts.html#except) + +- منبع: [مستندات رسمی پایتون](https://docs.python.org/3/reference/compound_stmts.html#except) هنگامی که یک استثنا (Exception) با استفاده از کلمه‌ی کلیدی `as` به متغیری تخصیص داده شود، این متغیر در انتهای بلاکِ `except` پاک می‌شود. این رفتار مشابه کد زیر است: @@ -1927,8 +1976,7 @@ NameError: name 'e' is not defined این بدان معناست که استثنا باید به نام دیگری انتساب داده شود تا بتوان پس از پایان بند `except` به آن ارجاع داد. استثناها پاک می‌شوند چون با داشتن «ردیابی» (traceback) ضمیمه‌شده، یک چرخه‌ی مرجع (reference cycle) با قاب پشته (stack frame) تشکیل می‌دهند که باعث می‌شود تمام متغیرهای محلی (locals) در آن قاب تا زمان پاکسازی حافظه (garbage collection) باقی بمانند. -* در پایتون، بندها (`clauses`) حوزه‌ی مستقل ندارند. در مثال بالا، همه‌چیز در یک حوزه‌ی واحد قرار دارد، و متغیر `e` در اثر اجرای بند `except` حذف می‌شود. این موضوع در مورد توابع صادق نیست، زیرا توابع حوزه‌های داخلی جداگانه‌ای دارند. مثال زیر این نکته را نشان می‌دهد: - +- در پایتون، بندها (`clauses`) حوزه‌ی مستقل ندارند. در مثال بالا، همه‌چیز در یک حوزه‌ی واحد قرار دارد، و متغیر `e` در اثر اجرای بند `except` حذف می‌شود. این موضوع در مورد توابع صادق نیست، زیرا توابع حوزه‌های داخلی جداگانه‌ای دارند. مثال زیر این نکته را نشان می‌دهد: ```py def f(x): @@ -1940,6 +1988,7 @@ NameError: name 'e' is not defined ``` **خروجی:** + ```py >>> f(x) UnboundLocalError: local variable 'x' referenced before assignment @@ -1951,9 +2000,10 @@ NameError: name 'e' is not defined [5, 4, 3] ``` -* در پایتون نسخه‌ی ۲.x، نام متغیر `e` به یک نمونه از `Exception()` انتساب داده می‌شود، بنابراین وقتی سعی کنید آن را چاپ کنید، چیزی نمایش داده نمی‌شود. +- در پایتون نسخه‌ی ۲.x، نام متغیر `e` به یک نمونه از `Exception()` انتساب داده می‌شود، بنابراین وقتی سعی کنید آن را چاپ کنید، چیزی نمایش داده نمی‌شود. **خروجی (Python 2.x):** + ```py >>> e Exception() @@ -1963,7 +2013,6 @@ NameError: name 'e' is not defined --- - ### ◀ تبدیل اسرارآمیز نوع کلید ```py @@ -1974,6 +2023,7 @@ some_dict = {'s': 42} ``` **خروجی:** + ```py >>> type(list(some_dict.keys())[0]) str @@ -1987,10 +2037,11 @@ str #### 💡 توضیح: -* هر دو شیء `s` و رشته‌ی `"s"` به دلیل ارث‌بری `SomeClass` از متد `__hash__` کلاس `str`، هش یکسانی دارند. -* عبارت `SomeClass("s") == "s"` به دلیل ارث‌بری `SomeClass` از متد `__eq__` کلاس `str` برابر با `True` ارزیابی می‌شود. -* از آنجا که این دو شیء هش یکسان و برابری دارند، به عنوان یک کلید مشترک در دیکشنری در نظر گرفته می‌شوند. -* برای رسیدن به رفتار دلخواه، می‌توانیم متد `__eq__` را در کلاس `SomeClass` بازتعریف کنیم. +- هر دو شیء `s` و رشته‌ی `"s"` به دلیل ارث‌بری `SomeClass` از متد `__hash__` کلاس `str`، هش یکسانی دارند. +- عبارت `SomeClass("s") == "s"` به دلیل ارث‌بری `SomeClass` از متد `__eq__` کلاس `str` برابر با `True` ارزیابی می‌شود. +- از آنجا که این دو شیء هش یکسان و برابری دارند، به عنوان یک کلید مشترک در دیکشنری در نظر گرفته می‌شوند. +- برای رسیدن به رفتار دلخواه، می‌توانیم متد `__eq__` را در کلاس `SomeClass` بازتعریف کنیم. + ```py class SomeClass(str): def __eq__(self, other): @@ -2008,6 +2059,7 @@ str ``` **خروجی:** + ```py >>> s = SomeClass('s') >>> some_dict[s] = 40 @@ -2027,6 +2079,7 @@ a, b = a[b] = {}, 5 ``` **خروجی:** + ```py >>> a {5: ({...}, 5)} @@ -2034,7 +2087,7 @@ a, b = a[b] = {}, 5 #### 💡 توضیح: -* طبق [مرجع زبان پایتون](https://docs.python.org/3/reference/simple_stmts.html#assignment-statements)، دستورات انتساب فرم زیر را دارند: +- طبق [مرجع زبان پایتون](https://docs.python.org/3/reference/simple_stmts.html#assignment-statements)، دستورات انتساب فرم زیر را دارند: ``` (target_list "=")+ (expression_list | yield_expression) @@ -2044,15 +2097,16 @@ a, b = a[b] = {}, 5 > یک دستور انتساب ابتدا فهرست عبارت‌ها (expression list) را ارزیابی می‌کند (توجه کنید این عبارت می‌تواند یک عبارت تکی یا فهرستی از عبارت‌ها جداشده با ویرگول باشد که دومی به یک تاپل منجر می‌شود)، سپس شیء حاصل را به هریک از اهداف انتساب از **چپ به راست** تخصیص می‌دهد. -* علامت `+` در `(target_list "=")+` به این معناست که می‌توان **یک یا چند** هدف انتساب داشت. در این حالت، اهداف انتساب ما `a, b` و `a[b]` هستند (توجه کنید که عبارت ارزیابی‌شده دقیقاً یکی است، که در اینجا `{}` و `5` است). +- علامت `+` در `(target_list "=")+` به این معناست که می‌توان **یک یا چند** هدف انتساب داشت. در این حالت، اهداف انتساب ما `a, b` و `a[b]` هستند (توجه کنید که عبارت ارزیابی‌شده دقیقاً یکی است، که در اینجا `{}` و `5` است). -* پس از ارزیابی عبارت، نتیجه از **چپ به راست** به اهداف انتساب داده می‌شود. در این مثال ابتدا تاپل `({}, 5)` به `a, b` باز می‌شود، بنابراین `a = {}` و `b = 5` خواهیم داشت. +- پس از ارزیابی عبارت، نتیجه از **چپ به راست** به اهداف انتساب داده می‌شود. در این مثال ابتدا تاپل `({}, 5)` به `a, b` باز می‌شود، بنابراین `a = {}` و `b = 5` خواهیم داشت. -* حالا `a` یک شیء قابل تغییر (mutable) است (`{}`). +- حالا `a` یک شیء قابل تغییر (mutable) است (`{}`). -* هدف انتساب بعدی `a[b]` است (شاید انتظار داشته باشید که اینجا خطا بگیریم زیرا پیش از این هیچ مقداری برای `a` و `b` مشخص نشده است؛ اما به یاد داشته باشید که در گام قبل به `a` مقدار `{}` و به `b` مقدار `5` دادیم). +- هدف انتساب بعدی `a[b]` است (شاید انتظار داشته باشید که اینجا خطا بگیریم زیرا پیش از این هیچ مقداری برای `a` و `b` مشخص نشده است؛ اما به یاد داشته باشید که در گام قبل به `a` مقدار `{}` و به `b` مقدار `5` دادیم). + +- اکنون، کلید `5` در دیکشنری به تاپل `({}, 5)` مقداردهی می‌شود و یک مرجع دوری (Circular Reference) ایجاد می‌کند (علامت `{...}` در خروجی به همان شیئی اشاره دارد که قبلاً توسط `a` به آن ارجاع داده شده است). یک مثال ساده‌تر از مرجع دوری می‌تواند به این صورت باشد: -* اکنون، کلید `5` در دیکشنری به تاپل `({}, 5)` مقداردهی می‌شود و یک مرجع دوری (Circular Reference) ایجاد می‌کند (علامت `{...}` در خروجی به همان شیئی اشاره دارد که قبلاً توسط `a` به آن ارجاع داده شده است). یک مثال ساده‌تر از مرجع دوری می‌تواند به این صورت باشد: ```py >>> some_list = some_list[0] = [0] >>> some_list @@ -2064,24 +2118,27 @@ a, b = a[b] = {}, 5 >>> some_list[0][0][0][0][0][0] == some_list True ``` + در مثال ما نیز شرایط مشابه است (`a[b][0]` همان شیئی است که `a` به آن اشاره دارد). +- بنابراین برای جمع‌بندی، می‌توانید مثال بالا را به این صورت ساده کنید: -* بنابراین برای جمع‌بندی، می‌توانید مثال بالا را به این صورت ساده کنید: ```py a, b = {}, 5 a[b] = a, b ``` + و مرجع دوری به این دلیل قابل توجیه است که `a[b][0]` همان شیئی است که `a` به آن اشاره دارد. + ```py >>> a[b][0] is a True ``` - --- ### ◀ از حد مجاز برای تبدیل رشته به عدد صحیح فراتر می‌رود + ```py >>> # Python 3.10.6 >>> int("2" * 5432) @@ -2091,6 +2148,7 @@ a, b = a[b] = {}, 5 ``` **خروجی:** + ```py >>> # Python 3.10.6 222222222222222222222222222222222222222222222222222222222222222... @@ -2104,6 +2162,7 @@ ValueError: Exceeds the limit (4300) for integer string conversion: ``` #### 💡 توضیح: + فراخوانی تابع `int()` در نسخه‌ی Python 3.10.6 به‌خوبی کار می‌کند اما در نسخه‌ی Python 3.10.8 منجر به خطای `ValueError` می‌شود. توجه کنید که پایتون همچنان قادر به کار با اعداد صحیح بزرگ است. این خطا تنها هنگام تبدیل اعداد صحیح به رشته یا برعکس رخ می‌دهد. خوشبختانه می‌توانید در صورت انتظار عبور از این حد مجاز، مقدار آن را افزایش دهید. برای انجام این کار می‌توانید از یکی از روش‌های زیر استفاده کنید: @@ -2114,10 +2173,8 @@ ValueError: Exceeds the limit (4300) for integer string conversion: برای جزئیات بیشتر درباره‌ی تغییر مقدار پیش‌فرض این حد مجاز، [مستندات رسمی پایتون](https://docs.python.org/3/library/stdtypes.html#int-max-str-digits) را مشاهده کنید. - --- - ## بخش: شیب‌های لغزنده ### ◀ تغییر یک دیکشنری هنگام پیمایش روی آن @@ -2168,6 +2225,7 @@ class SomeClass: **خروجی:** 1\. + ```py >>> x = SomeClass() >>> y = x @@ -2179,6 +2237,7 @@ Deleted! «خُب، بالاخره حذف شد.» احتمالاً حدس زده‌اید چه چیزی جلوی فراخوانی `__del__` را در اولین تلاشی که برای حذف `x` داشتیم، گرفته بود. بیایید مثال را پیچیده‌تر کنیم. 2\. + ```py >>> x = SomeClass() >>> y = x @@ -2194,6 +2253,7 @@ Deleted! «باشه، حالا حذف شد» :confused: #### 💡 توضیح: + - عبارت `del x` مستقیماً باعث فراخوانی `x.__del__()` نمی‌شود. - وقتی به دستور `del x` می‌رسیم، پایتون نام `x` را از حوزه‌ی فعلی حذف کرده و شمارنده‌ی مراجع شیٔ‌ای که `x` به آن اشاره می‌کرد را یک واحد کاهش می‌دهد. فقط وقتی شمارنده‌ی مراجع شیٔ به صفر برسد، تابع `__del__()` فراخوانی می‌شود. - در خروجی دوم، متد `__del__()` فراخوانی نشد چون دستور قبلی (`>>> y`) در مفسر تعاملی یک ارجاع دیگر به شیٔ ایجاد کرده بود (به صورت خاص، متغیر جادویی `_` به مقدار آخرین عبارت غیر `None` در REPL اشاره می‌کند). بنابراین مانع از رسیدن شمارنده‌ی مراجع به صفر در هنگام اجرای `del y` شد. @@ -2205,6 +2265,7 @@ Deleted! 1\. + ```py a = 1 def some_func(): @@ -2216,6 +2277,7 @@ def another_func(): ``` 2\. + ```py def some_closure_func(): a = 1 @@ -2232,6 +2294,7 @@ def another_closure_func(): ``` **خروجی:** + ```py >>> some_func() 1 @@ -2245,8 +2308,10 @@ UnboundLocalError: local variable 'a' referenced before assignment ``` #### 💡 توضیح: -* وقتی در محدوده (Scope) یک تابع به متغیری مقداردهی می‌کنید، آن متغیر در همان حوزه محلی تعریف می‌شود. بنابراین `a` در تابع `another_func` تبدیل به متغیر محلی می‌شود، اما پیش‌تر در همان حوزه مقداردهی نشده است، و این باعث خطا می‌شود. -* برای تغییر متغیر سراسری `a` در تابع `another_func`، باید از کلیدواژه‌ی `global` استفاده کنیم. + +- وقتی در محدوده (Scope) یک تابع به متغیری مقداردهی می‌کنید، آن متغیر در همان حوزه محلی تعریف می‌شود. بنابراین `a` در تابع `another_func` تبدیل به متغیر محلی می‌شود، اما پیش‌تر در همان حوزه مقداردهی نشده است، و این باعث خطا می‌شود. +- برای تغییر متغیر سراسری `a` در تابع `another_func`، باید از کلیدواژه‌ی `global` استفاده کنیم. + ```py def another_func() global a @@ -2255,12 +2320,15 @@ UnboundLocalError: local variable 'a' referenced before assignment ``` **خروجی:** + ```py >>> another_func() 2 ``` -* در تابع `another_closure_func`، متغیر `a` در حوزه‌ی `another_inner_func` محلی می‌شود ولی پیش‌تر در آن حوزه مقداردهی نشده است. به همین دلیل خطا می‌دهد. -* برای تغییر متغیر حوزه‌ی بیرونی `a` در `another_inner_func`، باید از کلیدواژه‌ی `nonlocal` استفاده کنیم. دستور `nonlocal` به مفسر می‌گوید که متغیر را در نزدیک‌ترین حوزه‌ی بیرونی (به‌جز حوزه‌ی global) جستجو کند. + +- در تابع `another_closure_func`، متغیر `a` در حوزه‌ی `another_inner_func` محلی می‌شود ولی پیش‌تر در آن حوزه مقداردهی نشده است. به همین دلیل خطا می‌دهد. +- برای تغییر متغیر حوزه‌ی بیرونی `a` در `another_inner_func`، باید از کلیدواژه‌ی `nonlocal` استفاده کنیم. دستور `nonlocal` به مفسر می‌گوید که متغیر را در نزدیک‌ترین حوزه‌ی بیرونی (به‌جز حوزه‌ی global) جستجو کند. + ```py def another_func(): a = 1 @@ -2272,12 +2340,14 @@ UnboundLocalError: local variable 'a' referenced before assignment ``` **خروجی:** + ```py >>> another_func() 2 ``` -* کلیدواژه‌های `global` و `nonlocal` به مفسر پایتون می‌گویند که متغیر جدیدی را تعریف نکند و به جای آن در حوزه‌های بیرونی (سراسری یا میانجی) آن را بیابد. -* برای مطالعه‌ی بیشتر در مورد نحوه‌ی کار فضای نام‌ها و مکانیزم تعیین حوزه‌ها در پایتون، می‌توانید این [مقاله کوتاه ولی عالی](https://sebastianraschka.com/Articles/2014_python_scope_and_namespaces.html) را بخوانید. + +- کلیدواژه‌های `global` و `nonlocal` به مفسر پایتون می‌گویند که متغیر جدیدی را تعریف نکند و به جای آن در حوزه‌های بیرونی (سراسری یا میانجی) آن را بیابد. +- برای مطالعه‌ی بیشتر در مورد نحوه‌ی کار فضای نام‌ها و مکانیزم تعیین حوزه‌ها در پایتون، می‌توانید این [مقاله کوتاه ولی عالی](https://sebastianraschka.com/Articles/2014_python_scope_and_namespaces.html) را بخوانید. --- @@ -2303,6 +2373,7 @@ for idx, item in enumerate(list_4): ``` **خروجی:** + ```py >>> list_1 [1, 2, 3, 4] @@ -2318,7 +2389,7 @@ for idx, item in enumerate(list_4): #### 💡 توضیح: -* هیچ‌وقت ایده‌ی خوبی نیست که شیئی را که روی آن پیمایش می‌کنید تغییر دهید. روش درست این است که روی یک کپی از آن شیء پیمایش کنید؛ در این‌جا `list_3[:]` دقیقاً همین کار را می‌کند. +- هیچ‌وقت ایده‌ی خوبی نیست که شیئی را که روی آن پیمایش می‌کنید تغییر دهید. روش درست این است که روی یک کپی از آن شیء پیمایش کنید؛ در این‌جا `list_3[:]` دقیقاً همین کار را می‌کند. ```py >>> some_list = [1, 2, 3, 4] @@ -2329,19 +2400,20 @@ for idx, item in enumerate(list_4): ``` **تفاوت بین `del`، `remove` و `pop`:** -* اینجا، `del var_name` فقط اتصال `var_name` را از فضای نام محلی یا سراسری حذف می‌کند (به همین دلیل است که `list_1` تحت تأثیر قرار نمی‌گیرد). -* متد `remove` اولین مقدار مطابق را حذف می‌کند، نه یک اندیس خاص را؛ اگر مقدار مورد نظر پیدا نشود، خطای `ValueError` ایجاد می‌شود. -* متد `pop` عنصری را در یک اندیس مشخص حذف کرده و آن را برمی‌گرداند؛ اگر اندیس نامعتبری مشخص شود، خطای `IndexError` ایجاد می‌شود. + +- اینجا، `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](https://stackoverflow.com/questions/45946228/what-happens-when-you-try-to-delete-a-list-element-while-iterating-over-it) را ببینید. -* همچنین برای نمونه مشابهی مربوط به دیکشنری‌ها در پایتون، این [تاپیک مفید StackOverflow](https://stackoverflow.com/questions/45877614/how-to-change-all-the-dictionary-keys-in-a-for-loop-with-d-items) را ببینید. +- برای توضیح بیشتر این مثال، این [تاپیک StackOverflow](https://stackoverflow.com/questions/45946228/what-happens-when-you-try-to-delete-a-list-element-while-iterating-over-it) را ببینید. +- همچنین برای نمونه مشابهی مربوط به دیکشنری‌ها در پایتون، این [تاپیک مفید StackOverflow](https://stackoverflow.com/questions/45877614/how-to-change-all-the-dictionary-keys-in-a-for-loop-with-d-items) را ببینید. --- - ### ◀ زیپِ دارای اتلاف برای پیمایشگرها * @@ -2359,6 +2431,7 @@ for idx, item in enumerate(list_4): >>> list(zip(numbers_iter, remaining)) [(4, 3), (5, 4), (6, 5)] ``` + عنصر `3` از لیست `numbers` چه شد؟ #### 💡 توضیح: @@ -2398,6 +2471,7 @@ for idx, item in enumerate(list_4): ### ◀ نشت کردن متغیرهای حلقه! 1\. + ```py for x in range(7): if x == 6: @@ -2406,6 +2480,7 @@ print(x, ': x in global') ``` **خروجی:** + ```py 6 : for x inside loop 6 : x in global @@ -2414,6 +2489,7 @@ print(x, ': x in global') اما متغیر `x` هرگز خارج از محدوده (scope) حلقه `for` تعریف نشده بود... 2\. + ```py # این دفعه، مقدار ایکس را در ابتدا مقداردهی اولیه میکنیم. x = -1 @@ -2424,6 +2500,7 @@ print(x, ': x in global') ``` **خروجی:** + ```py 6 : for x inside loop 6 : x in global @@ -2432,6 +2509,7 @@ print(x, ': x in global') 3\. **خروجی (Python 2.x):** + ```py >>> x = 1 >>> print([x for x in range(5)]) @@ -2441,6 +2519,7 @@ print(x, ': x in global') ``` **خروجی (Python 3.x):** + ```py >>> x = 1 >>> print([x for x in range(5)]) @@ -2469,6 +2548,7 @@ def some_func(default_arg=[]): ``` **خروجی:** + ```py >>> some_func() ['some_string'] @@ -2491,6 +2571,7 @@ def some_func(default_arg=[]): ``` **خروجی:** + ```py >>> some_func.__defaults__ # مقادیر پیشفرض این تابع را نمایش می دهد. ([],) @@ -2535,6 +2616,7 @@ except IndexError, ValueError: ``` **خروجی (Python 2.x):** + ```py Caught! @@ -2542,6 +2624,7 @@ ValueError: list.remove(x): x not in list ``` **خروجی (Python 3.x):** + ```py File "", line 3 except IndexError, ValueError: @@ -2551,7 +2634,7 @@ SyntaxError: invalid syntax #### 💡 توضیح -* برای افزودن چندین استثنا به عبارت `except`، باید آن‌ها را به صورت یک تاپل پرانتزدار به عنوان آرگومان اول وارد کنید. آرگومان دوم یک نام اختیاری است که در صورت ارائه، نمونهٔ Exception ایجادشده را به آن متصل می‌کند. برای مثال: +- برای افزودن چندین استثنا به عبارت `except`، باید آن‌ها را به صورت یک تاپل پرانتزدار به عنوان آرگومان اول وارد کنید. آرگومان دوم یک نام اختیاری است که در صورت ارائه، نمونهٔ Exception ایجادشده را به آن متصل می‌کند. برای مثال: ```py some_list = [1, 2, 3] @@ -2579,7 +2662,7 @@ SyntaxError: invalid syntax IndentationError: unindent does not match any outer indentation level ``` -* جدا کردن استثنا از متغیر با استفاده از ویرگول منسوخ شده و در پایتون 3 کار نمی‌کند؛ روش صحیح استفاده از `as` است. برای مثال: +- جدا کردن استثنا از متغیر با استفاده از ویرگول منسوخ شده و در پایتون 3 کار نمی‌کند؛ روش صحیح استفاده از `as` است. برای مثال: ```py some_list = [1, 2, 3] @@ -2603,6 +2686,7 @@ SyntaxError: invalid syntax ### ◀ عملوندهای یکسان، داستانی متفاوت! 1\. + ```py a = [1, 2, 3, 4] b = a @@ -2610,6 +2694,7 @@ a = a + [5, 6, 7, 8] ``` **خروجی:** + ```py >>> a [1, 2, 3, 4, 5, 6, 7, 8] @@ -2618,6 +2703,7 @@ a = a + [5, 6, 7, 8] ``` 2\. + ```py a = [1, 2, 3, 4] b = a @@ -2625,6 +2711,7 @@ a += [5, 6, 7, 8] ``` **خروجی:** + ```py >>> a [1, 2, 3, 4, 5, 6, 7, 8] @@ -2633,17 +2720,19 @@ a += [5, 6, 7, 8] ``` #### 💡 توضیح: -* عملگر `a += b` همیشه همانند `a = a + b` رفتار نمی‌کند. کلاس‌ها *ممکن است* عملگرهای *`op=`* را به گونه‌ای متفاوت پیاده‌سازی کنند، و لیست‌ها نیز چنین می‌کنند. -* عبارت `a = a + [5,6,7,8]` یک لیست جدید ایجاد می‌کند و مرجع `a` را به این لیست جدید اختصاص می‌دهد، بدون آنکه `b` را تغییر دهد. +- عملگر `a += b` همیشه همانند `a = a + b` رفتار نمی‌کند. کلاس‌ها *ممکن است* عملگرهای *`op=`* را به گونه‌ای متفاوت پیاده‌سازی کنند، و لیست‌ها نیز چنین می‌کنند. -* عبارت `a += [5,6,7,8]` در واقع به تابعی معادل «extend» ترجمه می‌شود که روی لیست اصلی عمل می‌کند؛ بنابراین `a` و `b` همچنان به همان لیست اشاره می‌کنند که به‌صورت درجا (in-place) تغییر کرده است. +- عبارت `a = a + [5,6,7,8]` یک لیست جدید ایجاد می‌کند و مرجع `a` را به این لیست جدید اختصاص می‌دهد، بدون آنکه `b` را تغییر دهد. + +- عبارت `a += [5,6,7,8]` در واقع به تابعی معادل «extend» ترجمه می‌شود که روی لیست اصلی عمل می‌کند؛ بنابراین `a` و `b` همچنان به همان لیست اشاره می‌کنند که به‌صورت درجا (in-place) تغییر کرده است. --- ### ◀ تفکیک نام‌ها با نادیده گرفتن حوزه‌ی کلاس 1\. + ```py x = 5 class SomeClass: @@ -2652,12 +2741,14 @@ class SomeClass: ``` **خروجی:** + ```py >>> list(SomeClass.y)[0] 5 ``` 2\. + ```py x = 5 class SomeClass: @@ -2666,18 +2757,21 @@ class SomeClass: ``` **خروجی (Python 2.x):** + ```py >>> SomeClass.y[0] 17 ``` **خروجی (Python 3.x):** + ```py >>> SomeClass.y[0] 5 ``` #### 💡 توضیح + - حوزه‌هایی که درون تعریف کلاس تو در تو هستند، نام‌های تعریف‌شده در سطح کلاس را نادیده می‌گیرند. - عبارت‌های جنراتور (generator expressions) حوزه‌ی مختص به خود دارند. - از پایتون نسخه‌ی ۳ به بعد، لیست‌های فشرده (list comprehensions) نیز حوزه‌ی مختص به خود دارند. @@ -2687,6 +2781,7 @@ class SomeClass: ### ◀ گرد کردن به روش بانکدار * بیایید یک تابع ساده برای به‌دست‌آوردن عنصر میانی یک لیست پیاده‌سازی کنیم: + ```py def get_middle(some_list): mid_index = round(len(some_list) / 2) @@ -2694,6 +2789,7 @@ def get_middle(some_list): ``` **Python 3.x:** + ```py >>> get_middle([1]) # خوب به نظر می رسد. 1 @@ -2706,6 +2802,7 @@ def get_middle(some_list): >>> round(len([1,2,3,4,5]) / 2) # چرا? 2 ``` + به نظر می‌رسد که پایتون عدد ۲٫۵ را به ۲ گرد کرده است. #### 💡 توضیح: @@ -2869,21 +2966,23 @@ def similar_recursive_func(a): ``` #### 💡 توضیح: -* برای مورد ۱، عبارت صحیح برای رفتار مورد انتظار این است: + +- برای مورد ۱، عبارت صحیح برای رفتار مورد انتظار این است: `x, y = (0, 1) if True else (None, None)` -* برای مورد ۲، عبارت صحیح برای رفتار مورد انتظار این است: +- برای مورد ۲، عبارت صحیح برای رفتار مورد انتظار این است: اینجا، `t = ('one',)` یا `t = 'one',` (ویرگول از قلم افتاده است). در غیر این صورت مفسر `t` را به عنوان یک `str` در نظر گرفته و به صورت کاراکتر به کاراکتر روی آن پیمایش می‌کند. -* علامت `()` یک توکن خاص است و نشان‌دهنده‌ی یک `tuple` خالی است. +- علامت `()` یک توکن خاص است و نشان‌دهنده‌ی یک `tuple` خالی است. + +- در مورد ۳، همان‌طور که احتمالاً متوجه شدید، بعد از عنصر پنجم (`"that"`) یک ویرگول از قلم افتاده است. بنابراین با الحاق ضمنی رشته‌ها، -* در مورد ۳، همان‌طور که احتمالاً متوجه شدید، بعد از عنصر پنجم (`"that"`) یک ویرگول از قلم افتاده است. بنابراین با الحاق ضمنی رشته‌ها، ```py >>> ten_words_list ['some', 'very', 'big', 'list', 'thatconsists', 'of', 'exactly', 'ten', 'words'] ``` -* در قطعه‌ی چهارم هیچ `AssertionError`ای رخ نداد؛ زیرا به جای ارزیابی عبارت تکی `a == b`، کل یک تاپل ارزیابی شده است. قطعه‌ی کد زیر این موضوع را روشن‌تر می‌کند: +- در قطعه‌ی چهارم هیچ `AssertionError`ای رخ نداد؛ زیرا به جای ارزیابی عبارت تکی `a == b`، کل یک تاپل ارزیابی شده است. قطعه‌ی کد زیر این موضوع را روشن‌تر می‌کند: ```py >>> a = "python" @@ -2902,15 +3001,14 @@ def similar_recursive_func(a): AssertionError: Values are not equal ``` -* در قطعه‌ی پنجم، بیشتر متدهایی که اشیای ترتیبی (Sequence) یا نگاشت‌ها (Mapping) را تغییر می‌دهند (مانند `list.append`، `dict.update`، `list.sort` و غیره)، شیء اصلی را به‌صورت درجا (in-place) تغییر داده و مقدار `None` برمی‌گردانند. منطق پشت این تصمیم، بهبود عملکرد با جلوگیری از کپی کردن شیء است (به این [منبع](https://docs.python.org/3/faq/design.html#why-doesn-t-list-sort-return-the-sorted-list) مراجعه کنید). +- در قطعه‌ی پنجم، بیشتر متدهایی که اشیای ترتیبی (Sequence) یا نگاشت‌ها (Mapping) را تغییر می‌دهند (مانند `list.append`، `dict.update`، `list.sort` و غیره)، شیء اصلی را به‌صورت درجا (in-place) تغییر داده و مقدار `None` برمی‌گردانند. منطق پشت این تصمیم، بهبود عملکرد با جلوگیری از کپی کردن شیء است (به این [منبع](https://docs.python.org/3/faq/design.html#why-doesn-t-list-sort-return-the-sorted-list) مراجعه کنید). -* قطعه‌ی آخر نیز نسبتاً واضح است؛ شیء تغییرپذیر (mutable)، مثل `list`، می‌تواند در داخل تابع تغییر کند، درحالی‌که انتساب دوباره‌ی یک شیء تغییرناپذیر (مانند `a -= 1`) باعث تغییر مقدار اصلی آن نخواهد شد. +- قطعه‌ی آخر نیز نسبتاً واضح است؛ شیء تغییرپذیر (mutable)، مثل `list`، می‌تواند در داخل تابع تغییر کند، درحالی‌که انتساب دوباره‌ی یک شیء تغییرناپذیر (مانند `a -= 1`) باعث تغییر مقدار اصلی آن نخواهد شد. -* آگاهی از این نکات ظریف در بلندمدت می‌تواند ساعت‌ها از زمان شما برای رفع اشکال را صرفه‌جویی کند. +- آگاهی از این نکات ظریف در بلندمدت می‌تواند ساعت‌ها از زمان شما برای رفع اشکال را صرفه‌جویی کند. --- - ### ◀ تقسیم‌ها * ```py @@ -2979,12 +3077,15 @@ NameError: name '_another_weird_name_func' is not defined - اغلب توصیه می‌شود از واردسازی عمومی (wildcard imports) استفاده نکنید. اولین دلیل واضح آن این است که در این نوع واردسازی‌ها، اسامی که با زیرخط (`_`) شروع شوند، وارد نمی‌شوند. این مسئله ممکن است در زمان اجرا به خطا منجر شود. - اگر از ساختار `from ... import a, b, c` استفاده کنیم، خطای `NameError` فوق اتفاق نمی‌افتاد. + ```py >>> from module import some_weird_name_func_, _another_weird_name_func >>> _another_weird_name_func() works! ``` + - اگر واقعاً تمایل دارید از واردسازی عمومی استفاده کنید، لازم است فهرستی به نام `__all__` را در ماژول خود تعریف کنید که شامل نام اشیاء عمومی (public) قابل‌دسترس هنگام واردسازی عمومی است. + ```py __all__ = ['_another_weird_name_func'] @@ -2994,6 +3095,7 @@ NameError: name '_another_weird_name_func' is not defined def _another_weird_name_func(): print("works!") ``` + **خروجی** ```py @@ -3034,6 +3136,7 @@ False >>> type(x), type(sorted(x)) (tuple, list) ``` + - برخلاف متد `sorted`، متد `reversed` یک تکرارکننده (iterator) برمی‌گرداند. چرا؟ زیرا مرتب‌سازی نیاز به تغییر درجا (in-place) یا استفاده از ظرف جانبی (مانند یک لیست اضافی) دارد، در حالی که معکوس کردن می‌تواند به‌سادگی با پیمایش از اندیس آخر به اول انجام شود. - بنابراین در مقایسه‌ی `sorted(y) == sorted(y)`، فراخوانی اولِ `sorted()` تمام عناصرِ تکرارکننده‌ی `y` را مصرف می‌کند، و فراخوانی بعدی یک لیست خالی برمی‌گرداند. @@ -3070,6 +3173,7 @@ if noon_time: ```py ('Time at noon is', datetime.time(12, 0)) ``` + زمان نیمه‌شب چاپ نمی‌شود. #### 💡 توضیح: @@ -3079,8 +3183,6 @@ if noon_time: --- --- - - ## بخش: گنجینه‌های پنهان! این بخش شامل چند مورد جالب و کمتر شناخته‌شده درباره‌ی پایتون است که بیشتر مبتدی‌هایی مثل من از آن بی‌خبرند (البته دیگر اینطور نیست). @@ -3097,9 +3199,10 @@ import antigravity Sshh... It's a super-secret. #### 💡 توضیح: -+ ماژول `antigravity` یکی از معدود ایستر اِگ‌هایی است که توسط توسعه‌دهندگان پایتون ارائه شده است. -+ دستور `import antigravity` باعث می‌شود مرورگر وب به سمت [کمیک کلاسیک XKCD](https://xkcd.com/353/) در مورد پایتون باز شود. -+ البته موضوع عمیق‌تر است؛ در واقع یک **ایستر اگ دیگر داخل این ایستر اگ** وجود دارد. اگر به [کد منبع](https://github.com/python/cpython/blob/master/Lib/antigravity.py#L7-L17) نگاه کنید، یک تابع تعریف شده که ادعا می‌کند [الگوریتم جئوهشینگ XKCD](https://xkcd.com/426/) را پیاده‌سازی کرده است. + +- ماژول `antigravity` یکی از معدود ایستر اِگ‌هایی است که توسط توسعه‌دهندگان پایتون ارائه شده است. +- دستور `import antigravity` باعث می‌شود مرورگر وب به سمت [کمیک کلاسیک XKCD](https://xkcd.com/353/) در مورد پایتون باز شود. +- البته موضوع عمیق‌تر است؛ در واقع یک **ایستر اگ دیگر داخل این ایستر اگ** وجود دارد. اگر به [کد منبع](https://github.com/python/cpython/blob/master/Lib/antigravity.py#L7-L17) نگاه کنید، یک تابع تعریف شده که ادعا می‌کند [الگوریتم جئوهشینگ XKCD](https://xkcd.com/426/) را پیاده‌سازی کرده است. --- @@ -3119,6 +3222,7 @@ print("Freedom!") ``` **خروجی (پایتون ۲.۳):** + ```py I am trapped, please rescue! I am trapped, please rescue! @@ -3126,6 +3230,7 @@ Freedom! ``` #### 💡 توضیح: + - نسخه‌ی قابل استفاده‌ای از `goto` در پایتون به عنوان یک شوخی [در اول آوریل ۲۰۰۴ معرفی شد](https://mail.python.org/pipermail/python-announce-list/2004-April/002982.html). - نسخه‌های فعلی پایتون فاقد این ماژول هستند. - اگرچه این ماژول واقعاً کار می‌کند، ولی لطفاً از آن استفاده نکنید. در [این صفحه](https://docs.python.org/3/faq/design.html#why-is-there-no-goto) می‌توانید دلیل عدم حضور دستور `goto` در پایتون را مطالعه کنید. @@ -3141,6 +3246,7 @@ from __future__ import braces ``` **خروجی:** + ```py File "some_file.py", line 1 from __future__ import braces @@ -3150,16 +3256,18 @@ SyntaxError: not a chance آکولاد؟ هرگز! اگر از این بابت ناامید شدید، بهتر است از جاوا استفاده کنید. خب، یک چیز شگفت‌آور دیگر؛ آیا می‌توانید تشخیص دهید که ارور `SyntaxError` در کجای کد ماژول `__future__` [اینجا](https://github.com/python/cpython/blob/master/Lib/__future__.py) ایجاد می‌شود؟ #### 💡 توضیح: -+ ماژول `__future__` معمولاً برای ارائه قابلیت‌هایی از نسخه‌های آینده پایتون به کار می‌رود. اما کلمه «future» (آینده) در این زمینه خاص، حالت طنز و کنایه دارد. -+ این مورد یک «ایستر اگ» (easter egg) است که به احساسات جامعه برنامه‌نویسان پایتون در این خصوص اشاره دارد. -+ کد مربوط به این موضوع در واقع [اینجا](https://github.com/python/cpython/blob/025eb98dc0c1dc27404df6c544fc2944e0fa9f3a/Python/future.c#L49) در فایل `future.c` قرار دارد. -+ زمانی که کامپایلر CPython با یک [عبارت future](https://docs.python.org/3.3/reference/simple_stmts.html#future-statements) مواجه می‌شود، ابتدا کد مرتبط در `future.c` را اجرا کرده و سپس آن را همانند یک دستور ایمپورت عادی در نظر می‌گیرد. + +- ماژول `__future__` معمولاً برای ارائه قابلیت‌هایی از نسخه‌های آینده پایتون به کار می‌رود. اما کلمه «future» (آینده) در این زمینه خاص، حالت طنز و کنایه دارد. +- این مورد یک «ایستر اگ» (easter egg) است که به احساسات جامعه برنامه‌نویسان پایتون در این خصوص اشاره دارد. +- کد مربوط به این موضوع در واقع [اینجا](https://github.com/python/cpython/blob/025eb98dc0c1dc27404df6c544fc2944e0fa9f3a/Python/future.c#L49) در فایل `future.c` قرار دارد. +- زمانی که کامپایلر CPython با یک [عبارت future](https://docs.python.org/3.3/reference/simple_stmts.html#future-statements) مواجه می‌شود، ابتدا کد مرتبط در `future.c` را اجرا کرده و سپس آن را همانند یک دستور ایمپورت عادی در نظر می‌گیرد. --- ### ◀ بیایید با «عمو زبان مهربان برای همیشه» آشنا شویم **خروجی (Python 3.x)** + ```py >>> from __future__ import barry_as_FLUFL >>> "Ruby" != "Python" # شکی در این نیست. @@ -3175,6 +3283,7 @@ True حالا می‌رسیم به اصل ماجرا. #### 💡 توضیح: + - این مورد مربوط به [PEP-401](https://www.python.org/dev/peps/pep-0401/) است که در تاریخ ۱ آوریل ۲۰۰۹ منتشر شد (اکنون می‌دانید این یعنی چه!). - نقل قولی از PEP-401: @@ -3199,6 +3308,7 @@ import this صبر کن، **این** چیه؟ `this` عشقه :heart: **خروجی:** + ``` The Zen of Python, by Tim Peters @@ -3241,9 +3351,9 @@ True #### 💡 توضیح: -* ماژول `this` در پایتون، یک ایستر اگ برای «ذنِ پایتون» ([PEP 20](https://www.python.org/dev/peps/pep-0020)) است. -* اگر این موضوع به‌اندازه کافی جالب است، حتماً پیاده‌سازی [this.py](https://hg.python.org/cpython/file/c3896275c0f6/Lib/this.py) را ببینید. نکته جالب این است که **کد مربوط به ذنِ پایتون، خودش اصول ذن را نقض کرده است** (و احتمالاً این تنها جایی است که چنین اتفاقی می‌افتد). -* درباره جمله `love is not True or False; love is love`، اگرچه طعنه‌آمیز است، اما خود گویاست. (اگر واضح نیست، لطفاً مثال‌های مربوط به عملگرهای `is` و `is not` را مشاهده کنید.) +- ماژول `this` در پایتون، یک ایستر اگ برای «ذنِ پایتون» ([PEP 20](https://www.python.org/dev/peps/pep-0020)) است. +- اگر این موضوع به‌اندازه کافی جالب است، حتماً پیاده‌سازی [this.py](https://hg.python.org/cpython/file/c3896275c0f6/Lib/this.py) را ببینید. نکته جالب این است که **کد مربوط به ذنِ پایتون، خودش اصول ذن را نقض کرده است** (و احتمالاً این تنها جایی است که چنین اتفاقی می‌افتد). +- درباره جمله `love is not True or False; love is love`، اگرچه طعنه‌آمیز است، اما خود گویاست. (اگر واضح نیست، لطفاً مثال‌های مربوط به عملگرهای `is` و `is not` را مشاهده کنید.) --- @@ -3262,6 +3372,7 @@ True ``` **خروجی:** + ```py >>> some_list = [1, 2, 3, 4, 5] >>> does_exists_num(some_list, 4) @@ -3282,15 +3393,18 @@ else: ``` **خروجی:** + ```py Try block executed successfully... ``` #### 💡 توضیح: + - عبارت `else` بعد از حلقه‌ها تنها زمانی اجرا می‌شود که در هیچ‌کدام از تکرارها (`iterations`) از دستور `break` استفاده نشده باشد. می‌توانید آن را به عنوان یک شرط «بدون شکست» (nobreak) در نظر بگیرید. - عبارت `else` پس از بلاک `try` به عنوان «عبارت تکمیل» (`completion clause`) نیز شناخته می‌شود؛ چراکه رسیدن به عبارت `else` در ساختار `try` به این معنی است که بلاک `try` بدون رخ دادن استثنا با موفقیت تکمیل شده است. --- + ### ◀ عملگر Ellipsis * ```py @@ -3299,6 +3413,7 @@ def some_func(): ``` **خروجی** + ```py >>> some_func() # بدون خروجی و بدون خطا @@ -3313,14 +3428,17 @@ Ellipsis ``` #### 💡توضیح + - در پایتون، `Ellipsis` یک شیء درونی (`built-in`) است که به صورت سراسری (`global`) در دسترس است و معادل `...` است. + ```py >>> ... Ellipsis ``` + - عملگر `Ellipsis` می‌تواند برای چندین منظور استفاده شود: - + به عنوان یک نگه‌دارنده برای کدی که هنوز نوشته نشده است (مانند دستور `pass`) - + در سینتکس برش (`slicing`) برای نمایش برش کامل در ابعاد باقی‌مانده + - به عنوان یک نگه‌دارنده برای کدی که هنوز نوشته نشده است (مانند دستور `pass`) + - در سینتکس برش (`slicing`) برای نمایش برش کامل در ابعاد باقی‌مانده ```py >>> import numpy as np @@ -3337,7 +3455,9 @@ Ellipsis ] ]) ``` + بنابراین، آرایه‌ی `three_dimensional_array` ما، آرایه‌ای از آرایه‌ها از آرایه‌ها است. فرض کنیم می‌خواهیم عنصر دوم (اندیس `1`) از تمامی آرایه‌های درونی را چاپ کنیم؛ در این حالت می‌توانیم از `Ellipsis` برای عبور از تمامی ابعاد قبلی استفاده کنیم: + ```py >>> three_dimensional_array[:,:,1] array([[1, 3], @@ -3346,10 +3466,10 @@ Ellipsis array([[1, 3], [5, 7]]) ``` - نکته: این روش برای آرایه‌هایی با هر تعداد بُعد کار می‌کند. حتی می‌توانید از برش (`slice`) در بُعد اول و آخر استفاده کرده و ابعاد میانی را نادیده بگیرید (به صورت `n_dimensional_array[first_dim_slice, ..., last_dim_slice]`). - + در [نوع‌دهی (`type hinting`)](https://docs.python.org/3/library/typing.html) برای اشاره به بخشی از نوع (مانند `Callable[..., int]` یا `Tuple[str, ...]`) استفاده می‌شود. - + همچنین می‌توانید از `Ellipsis` به عنوان آرگومان پیش‌فرض تابع استفاده کنید (برای مواردی که می‌خواهید میان «آرگومانی ارسال نشده است» و «مقدار `None` ارسال شده است» تمایز قائل شوید). + نکته: این روش برای آرایه‌هایی با هر تعداد بُعد کار می‌کند. حتی می‌توانید از برش (`slice`) در بُعد اول و آخر استفاده کرده و ابعاد میانی را نادیده بگیرید (به صورت `n_dimensional_array[first_dim_slice, ..., last_dim_slice]`). + - در [نوع‌دهی (`type hinting`)](https://docs.python.org/3/library/typing.html) برای اشاره به بخشی از نوع (مانند `Callable[..., int]` یا `Tuple[str, ...]`) استفاده می‌شود. + - همچنین می‌توانید از `Ellipsis` به عنوان آرگومان پیش‌فرض تابع استفاده کنید (برای مواردی که می‌خواهید میان «آرگومانی ارسال نشده است» و «مقدار `None` ارسال شده است» تمایز قائل شوید). --- @@ -3358,6 +3478,7 @@ Ellipsis این املای کلمه تعمداً به همین شکل نوشته شده است. لطفاً برای اصلاح آن درخواست (`patch`) ارسال نکنید. **خروجی (پایتون 3.x):** + ```py >>> infinity = float('infinity') >>> hash(infinity) @@ -3367,6 +3488,7 @@ Ellipsis ``` #### 💡 توضیح: + - هش (`hash`) مقدار بی‌نهایت برابر با 10⁵ × π است. - نکته جالب اینکه در پایتون ۳ هشِ مقدار `float('-inf')` برابر با «-10⁵ × π» است، در حالی که در پایتون ۲ برابر با «-10⁵ × e» است. @@ -3375,6 +3497,7 @@ Ellipsis ### ◀ بیایید خرابکاری کنیم 1\. + ```py class Yo(object): def __init__(self): @@ -3383,6 +3506,7 @@ class Yo(object): ``` **خروجی:** + ```py >>> Yo().bro True @@ -3393,6 +3517,7 @@ True ``` 2\. + ```py class Yo(object): def __init__(self): @@ -3402,6 +3527,7 @@ class Yo(object): ``` **خروجی:** + ```py >>> Yo().bro True @@ -3425,6 +3551,7 @@ class A(object): ``` **خروجی:** + ```py >>> A().__variable Traceback (most recent call last): @@ -3435,15 +3562,14 @@ AttributeError: 'A' object has no attribute '__variable' 'Some value' ``` - #### 💡 توضیح: -* [تغییر نام](https://en.wikipedia.org/wiki/Name_mangling) برای جلوگیری از برخورد نام‌ها بین فضاهای نام مختلف استفاده می‌شود. -* در پایتون، مفسر نام‌های اعضای کلاس که با `__` (دو آندرلاین که به عنوان "دندر" شناخته می‌شود) شروع می‌شوند و بیش از یک آندرلاین انتهایی ندارند را با اضافه کردن `_NameOfTheClass` در ابتدای آنها تغییر می‌دهد. -* بنابراین، برای دسترسی به ویژگی `__honey` در اولین قطعه کد، مجبور بودیم `_Yo` را به ابتدای آن اضافه کنیم، که از بروز تعارض با ویژگی با همان نام تعریف‌شده در هر کلاس دیگری جلوگیری می‌کند. -* اما چرا در دومین قطعه کد کار نکرد؟ زیرا تغییر نام، نام‌هایی که با دو آندرلاین خاتمه می‌یابند را شامل نمی‌شود. -* قطعه سوم نیز نتیجه تغییر نام بود. نام `__variable` در عبارت `return __variable` به `_A__variable` تغییر یافت، که همچنین همان نام متغیری است که در محدوده بیرونی تعریف کرده بودیم. -* همچنین، اگر نام تغییر یافته بیش از ۲۵۵ کاراکتر باشد، برش داده می‌شود. +- [تغییر نام](https://en.wikipedia.org/wiki/Name_mangling) برای جلوگیری از برخورد نام‌ها بین فضاهای نام مختلف استفاده می‌شود. +- در پایتون، مفسر نام‌های اعضای کلاس که با `__` (دو آندرلاین که به عنوان "دندر" شناخته می‌شود) شروع می‌شوند و بیش از یک آندرلاین انتهایی ندارند را با اضافه کردن `_NameOfTheClass` در ابتدای آنها تغییر می‌دهد. +- بنابراین، برای دسترسی به ویژگی `__honey` در اولین قطعه کد، مجبور بودیم `_Yo` را به ابتدای آن اضافه کنیم، که از بروز تعارض با ویژگی با همان نام تعریف‌شده در هر کلاس دیگری جلوگیری می‌کند. +- اما چرا در دومین قطعه کد کار نکرد؟ زیرا تغییر نام، نام‌هایی که با دو آندرلاین خاتمه می‌یابند را شامل نمی‌شود. +- قطعه سوم نیز نتیجه تغییر نام بود. نام `__variable` در عبارت `return __variable` به `_A__variable` تغییر یافت، که همچنین همان نام متغیری است که در محدوده بیرونی تعریف کرده بودیم. +- همچنین، اگر نام تغییر یافته بیش از ۲۵۵ کاراکتر باشد، برش داده می‌شود. --- --- @@ -3453,6 +3579,7 @@ AttributeError: 'A' object has no attribute '__variable' ### ◀ خطوط را رد می‌کند؟ **خروجی:** + ```py >>> value = 11 >>> valuе = 32 @@ -3504,6 +3631,7 @@ def energy_receive(): ``` **خروجی:** + ```py >>> energy_send(123.456) >>> energy_receive() @@ -3514,8 +3642,8 @@ def energy_receive(): #### 💡 توضیح: -* توجه کنید که آرایه‌ی numpy ایجادشده در تابع `energy_send` برگردانده نشده است، بنابراین فضای حافظه‌ی آن آزاد شده و مجدداً قابل استفاده است. -* تابع `numpy.empty()` نزدیک‌ترین فضای حافظه‌ی آزاد را بدون مقداردهی مجدد برمی‌گرداند. این فضای حافظه معمولاً همان فضایی است که به‌تازگی آزاد شده است (البته معمولاً این اتفاق می‌افتد و نه همیشه). +- توجه کنید که آرایه‌ی numpy ایجادشده در تابع `energy_send` برگردانده نشده است، بنابراین فضای حافظه‌ی آن آزاد شده و مجدداً قابل استفاده است. +- تابع `numpy.empty()` نزدیک‌ترین فضای حافظه‌ی آزاد را بدون مقداردهی مجدد برمی‌گرداند. این فضای حافظه معمولاً همان فضایی است که به‌تازگی آزاد شده است (البته معمولاً این اتفاق می‌افتد و نه همیشه). --- @@ -3545,12 +3673,12 @@ def square(x): #### 💡 توضیح -* **تب‌ها و فاصله‌ها (space) را با هم ترکیب نکنید!** کاراکتری که دقیقاً قبل از دستور return آمده یک «تب» است، در حالی که در بقیۀ مثال، کد با مضربی از «۴ فاصله» تورفتگی دارد. -* نحوۀ برخورد پایتون با تب‌ها به این صورت است: +- **تب‌ها و فاصله‌ها (space) را با هم ترکیب نکنید!** کاراکتری که دقیقاً قبل از دستور return آمده یک «تب» است، در حالی که در بقیۀ مثال، کد با مضربی از «۴ فاصله» تورفتگی دارد. +- نحوۀ برخورد پایتون با تب‌ها به این صورت است: > ابتدا تب‌ها (از چپ به راست) با یک تا هشت فاصله جایگزین می‌شوند به‌طوری که تعداد کل کاراکترها تا انتهای آن جایگزینی، مضربی از هشت باشد <...> -* بنابراین «تب» در آخرین خط تابع `square` با هشت فاصله جایگزین شده و به همین دلیل داخل حلقه قرار می‌گیرد. -* پایتون ۳ آنقدر هوشمند هست که چنین مواردی را به‌صورت خودکار با خطا اعلام کند. +- بنابراین «تب» در آخرین خط تابع `square` با هشت فاصله جایگزین شده و به همین دلیل داخل حلقه قرار می‌گیرد. +- پایتون ۳ آنقدر هوشمند هست که چنین مواردی را به‌صورت خودکار با خطا اعلام کند. **خروجی (Python 3.x):** @@ -3563,7 +3691,6 @@ def square(x): ## بخش: متفرقه - ### ◀ `+=` سریع‌تر است @@ -3576,8 +3703,9 @@ def square(x): 0.012188911437988281 ``` -#### 💡 توضیح: -+ استفاده از `+=` برای اتصال بیش از دو رشته سریع‌تر از `+` است، زیرا هنگام محاسبه رشته‌ی نهایی، رشته‌ی اول (به‌عنوان مثال `s1` در عبارت `s1 += s2 + s3`) از بین نمی‌رود. +#### 💡 توضیح: + +- استفاده از `+=` برای اتصال بیش از دو رشته سریع‌تر از `+` است، زیرا هنگام محاسبه رشته‌ی نهایی، رشته‌ی اول (به‌عنوان مثال `s1` در عبارت `s1 += s2 + s3`) از بین نمی‌رود. --- @@ -3653,12 +3781,15 @@ timeit.timeit('add_string_with_plus(10000)', number=1000, globals=globals()) ``` #### 💡 توضیح + توضیحات -- برای اطلاعات بیشتر درباره‌ی [timeit](https://docs.python.org/3/library/timeit.html) یا [%timeit](https://ipython.org/ipython-doc/dev/interactive/magics.html#magic-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"`)، افزایش زمان اجرا درجه دو می‌شد. + +- برای اطلاعات بیشتر درباره‌ی [timeit](https://docs.python.org/3/library/timeit.html) یا [%timeit](https://ipython.org/ipython-doc/dev/interactive/magics.html#magic-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"`)، افزایش زمان اجرا درجه دو می‌شد. + ```py def add_string_with_plus(iters): s = "" @@ -3671,10 +3802,10 @@ timeit.timeit('add_string_with_plus(10000)', number=1000, globals=globals()) >>> %timeit -n100 add_string_with_plus(10000) # افزایش درجه دو در زمان اجرا 9 ms ± 298 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) ``` + - وجود راه‌های متعدد برای قالب‌بندی و ایجاد رشته‌های بزرگ تا حدودی در تضاد با [ذِن پایتون](https://www.python.org/dev/peps/pep-0020/) است که می‌گوید: - - > «باید یک راه — و ترجیحاً فقط یک راه — واضح برای انجام آن وجود داشته باشد.» + > «باید یک راه — و ترجیحاً فقط یک راه — واضح برای انجام آن وجود داشته باشد.» --- @@ -3686,6 +3817,7 @@ another_dict = {str(i): 1 for i in range(1_000_000)} ``` **خروجی:** + ```py >>> %timeit some_dict['5'] 28.6 ns ± 0.115 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each) @@ -3702,14 +3834,15 @@ 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`](https://github.com/python/cpython/blob/522691c46e2ae51faaad5bbbce7d959dd61770df/Objects/dictobject.c#L841) شناخته می‌شود) فرض می‌کند که تمام کلیدهای موجود در دیکشنری (از جمله کلیدی که در حال جستجوی آن هستید) رشته (`str`) هستند و برای مقایسه‌ی کلیدها، به‌جای فراخوانی متد `__eq__`، از مقایسه‌ی سریع‌تر و ساده‌تر رشته‌ای استفاده می‌کند. -+ اولین باری که یک دیکشنری (`dict`) با کلیدی غیر از `str` فراخوانی شود، این حالت تغییر می‌کند و جستجوهای بعدی از تابع عمومی استفاده خواهند کرد. -+ این فرایند برای آن نمونه‌ی خاص از دیکشنری غیرقابل بازگشت است و حتی لازم نیست کلید موردنظر در دیکشنری موجود باشد. به همین دلیل است که حتی تلاش ناموفق برای دسترسی به کلیدی ناموجود نیز باعث ایجاد همین تأثیر (کند شدن جستجو) می‌شود. +#### 💡 توضیح: +- در CPython یک تابع عمومی برای جستجوی کلید در دیکشنری‌ها وجود دارد که از تمام انواع کلیدها (`str`، `int` و هر شیء دیگر) پشتیبانی می‌کند؛ اما برای حالت متداولی که تمام کلیدها از نوع `str` هستند، یک تابع بهینه‌شده‌ی اختصاصی نیز وجود دارد. +- تابع اختصاصی (که در کد منبع CPython با نام [`lookdict_unicode`](https://github.com/python/cpython/blob/522691c46e2ae51faaad5bbbce7d959dd61770df/Objects/dictobject.c#L841) شناخته می‌شود) فرض می‌کند که تمام کلیدهای موجود در دیکشنری (از جمله کلیدی که در حال جستجوی آن هستید) رشته (`str`) هستند و برای مقایسه‌ی کلیدها، به‌جای فراخوانی متد `__eq__`، از مقایسه‌ی سریع‌تر و ساده‌تر رشته‌ای استفاده می‌کند. +- اولین باری که یک دیکشنری (`dict`) با کلیدی غیر از `str` فراخوانی شود، این حالت تغییر می‌کند و جستجوهای بعدی از تابع عمومی استفاده خواهند کرد. +- این فرایند برای آن نمونه‌ی خاص از دیکشنری غیرقابل بازگشت است و حتی لازم نیست کلید موردنظر در دیکشنری موجود باشد. به همین دلیل است که حتی تلاش ناموفق برای دسترسی به کلیدی ناموجود نیز باعث ایجاد همین تأثیر (کند شدن جستجو) می‌شود. ### ◀ حجیم کردن دیکشنری نمونه‌ها (`instance dicts`) * @@ -3730,6 +3863,7 @@ def dict_size(o): ``` **خروجی:** (پایتون ۳.۸؛ سایر نسخه‌های پایتون ۳ ممکن است کمی متفاوت باشند) + ```py >>> o1 = SomeClass() >>> o2 = SomeClass() @@ -3766,25 +3900,25 @@ def dict_size(o): چه چیزی باعث حجیم‌شدن این دیکشنری‌ها می‌شود؟ و چرا اشیاء تازه ساخته‌شده نیز حجیم هستند؟ #### 💡 توضیح: -+ در CPython، امکان استفاده‌ی مجدد از یک شیء «کلیدها» (`keys`) در چندین دیکشنری وجود دارد. این ویژگی در [PEP 412](https://www.python.org/dev/peps/pep-0412/) معرفی شد تا مصرف حافظه کاهش یابد، به‌ویژه برای دیکشنری‌هایی که به نمونه‌ها (instances) تعلق دارند و معمولاً کلیدها (نام صفات نمونه‌ها) بین آن‌ها مشترک است. -+ این بهینه‌سازی برای دیکشنری‌های نمونه‌ها کاملاً شفاف و خودکار است؛ اما اگر بعضی فرضیات نقض شوند، غیرفعال می‌شود. -+ دیکشنری‌هایی که کلیدهایشان به اشتراک گذاشته شده باشد، از حذف کلید پشتیبانی نمی‌کنند؛ بنابراین اگر صفتی از یک نمونه حذف شود، دیکشنریِ آن نمونه «غیر مشترک» (`unshared`) شده و این قابلیت اشتراک‌گذاری کلیدها برای تمام نمونه‌هایی که در آینده از آن کلاس ساخته می‌شوند، غیرفعال می‌گردد. -+ همچنین اگر اندازه‌ی دیکشنری به‌علت اضافه‌شدن کلیدهای جدید تغییر کند (`resize` شود)، اشتراک‌گذاری کلیدها تنها زمانی ادامه می‌یابد که فقط یک دیکشنری در حال استفاده از آن‌ها باشد (این اجازه می‌دهد در متد `__init__` برای اولین نمونه‌ی ساخته‌شده، صفات متعددی تعریف کنید بدون آن‌که اشتراک‌گذاری کلیدها از بین برود). اما اگر چند نمونه همزمان وجود داشته باشند و تغییر اندازه‌ی دیکشنری رخ دهد، قابلیت اشتراک‌گذاری کلیدها برای نمونه‌های بعدی همان کلاس غیرفعال خواهد شد. زیرا CPython دیگر نمی‌تواند مطمئن باشد که آیا نمونه‌های بعدی دقیقاً از مجموعه‌ی یکسانی از صفات استفاده خواهند کرد یا خیر. -+ نکته‌ای کوچک برای کاهش مصرف حافظه‌ی برنامه: هرگز صفات نمونه‌ها را حذف نکنید و حتماً تمام صفات را در متد `__init__` تعریف و مقداردهی اولیه کنید! +- در CPython، امکان استفاده‌ی مجدد از یک شیء «کلیدها» (`keys`) در چندین دیکشنری وجود دارد. این ویژگی در [PEP 412](https://www.python.org/dev/peps/pep-0412/) معرفی شد تا مصرف حافظه کاهش یابد، به‌ویژه برای دیکشنری‌هایی که به نمونه‌ها (instances) تعلق دارند و معمولاً کلیدها (نام صفات نمونه‌ها) بین آن‌ها مشترک است. +- این بهینه‌سازی برای دیکشنری‌های نمونه‌ها کاملاً شفاف و خودکار است؛ اما اگر بعضی فرضیات نقض شوند، غیرفعال می‌شود. +- دیکشنری‌هایی که کلیدهایشان به اشتراک گذاشته شده باشد، از حذف کلید پشتیبانی نمی‌کنند؛ بنابراین اگر صفتی از یک نمونه حذف شود، دیکشنریِ آن نمونه «غیر مشترک» (`unshared`) شده و این قابلیت اشتراک‌گذاری کلیدها برای تمام نمونه‌هایی که در آینده از آن کلاس ساخته می‌شوند، غیرفعال می‌گردد. +- همچنین اگر اندازه‌ی دیکشنری به‌علت اضافه‌شدن کلیدهای جدید تغییر کند (`resize` شود)، اشتراک‌گذاری کلیدها تنها زمانی ادامه می‌یابد که فقط یک دیکشنری در حال استفاده از آن‌ها باشد (این اجازه می‌دهد در متد `__init__` برای اولین نمونه‌ی ساخته‌شده، صفات متعددی تعریف کنید بدون آن‌که اشتراک‌گذاری کلیدها از بین برود). اما اگر چند نمونه همزمان وجود داشته باشند و تغییر اندازه‌ی دیکشنری رخ دهد، قابلیت اشتراک‌گذاری کلیدها برای نمونه‌های بعدی همان کلاس غیرفعال خواهد شد. زیرا CPython دیگر نمی‌تواند مطمئن باشد که آیا نمونه‌های بعدی دقیقاً از مجموعه‌ی یکسانی از صفات استفاده خواهند کرد یا خیر. +- نکته‌ای کوچک برای کاهش مصرف حافظه‌ی برنامه: هرگز صفات نمونه‌ها را حذف نکنید و حتماً تمام صفات را در متد `__init__` تعریف و مقداردهی اولیه کنید! -### ◀ موارد جزئی * +### ◀ موارد جزئی * -* متد `join()` عملیاتی مربوط به رشته (`str`) است، نه لیست (`list`). (در نگاه اول کمی برخلاف انتظار است.) +- متد `join()` عملیاتی مربوط به رشته (`str`) است، نه لیست (`list`). (در نگاه اول کمی برخلاف انتظار است.) **توضیح:** اگر `join()` به‌عنوان متدی روی رشته پیاده‌سازی شود، می‌تواند روی هر شیء قابل پیمایش (`iterable`) از جمله لیست، تاپل و هر نوع تکرارشونده‌ی دیگر کار کند. اگر به‌جای آن روی لیست تعریف می‌شد، باید به‌طور جداگانه برای هر نوع دیگری نیز پیاده‌سازی می‌شد. همچنین منطقی نیست که یک متد مختص رشته روی یک شیء عمومی مانند `list` پیاده شود. -* تعدادی عبارت با ظاهری عجیب اما از نظر معنا صحیح: - + عبارت `[] = ()` از نظر معنایی صحیح است (باز کردن یا `unpack` کردن یک تاپل خالی درون یک لیست خالی). - + عبارت `'a'[0][0][0][0][0]` نیز از نظر معنایی صحیح است، زیرا پایتون برخلاف زبان‌هایی که از C منشعب شده‌اند، نوع داده‌ای جداگانه‌ای برای کاراکتر ندارد. بنابراین انتخاب یک کاراکتر از یک رشته، منجر به بازگشت یک رشته‌ی تک‌کاراکتری می‌شود. - + عبارات `3 --0-- 5 == 8` و `--5 == 5` هر دو از لحاظ معنایی درست بوده و مقدارشان برابر `True` است. +- تعدادی عبارت با ظاهری عجیب اما از نظر معنا صحیح: + - عبارت `[] = ()` از نظر معنایی صحیح است (باز کردن یا `unpack` کردن یک تاپل خالی درون یک لیست خالی). + - عبارت `'a'[0][0][0][0][0]` نیز از نظر معنایی صحیح است، زیرا پایتون برخلاف زبان‌هایی که از C منشعب شده‌اند، نوع داده‌ای جداگانه‌ای برای کاراکتر ندارد. بنابراین انتخاب یک کاراکتر از یک رشته، منجر به بازگشت یک رشته‌ی تک‌کاراکتری می‌شود. + - عبارات `3 --0-- 5 == 8` و `--5 == 5` هر دو از لحاظ معنایی درست بوده و مقدارشان برابر `True` است. -* با فرض اینکه `a` یک عدد باشد، عبارات `++a` و `--a` هر دو در پایتون معتبر هستند؛ اما رفتاری مشابه با عبارات مشابه در زبان‌هایی مانند C، ++C یا جاوا ندارند. +- با فرض اینکه `a` یک عدد باشد، عبارات `++a` و `--a` هر دو در پایتون معتبر هستند؛ اما رفتاری مشابه با عبارات مشابه در زبان‌هایی مانند C، ++C یا جاوا ندارند. ```py >>> a = 5 @@ -3797,11 +3931,12 @@ def dict_size(o): ``` 💡 **توضیح:** - + در گرامر پایتون عملگری به‌نام `++` وجود ندارد. در واقع `++` دو عملگر `+` جداگانه است. - + عبارت `++a` به‌شکل `+(+a)` تفسیر می‌شود که معادل `a` است. به‌همین ترتیب، خروجی عبارت `--a` نیز قابل توجیه است. - + این [تاپیک در StackOverflow](https://stackoverflow.com/questions/3654830/why-are-there-no-and-operators-in-python) دلایل نبودن عملگرهای افزایش (`++`) و کاهش (`--`) در پایتون را بررسی می‌کند. -* احتمالاً با عملگر Walrus (گراز دریایی) در پایتون آشنا هستید؛ اما تا به حال در مورد *عملگر Space-invader (مهاجم فضایی)* شنیده‌اید؟ +- در گرامر پایتون عملگری به‌نام `++` وجود ندارد. در واقع `++` دو عملگر `+` جداگانه است. +- عبارت `++a` به‌شکل `+(+a)` تفسیر می‌شود که معادل `a` است. به‌همین ترتیب، خروجی عبارت `--a` نیز قابل توجیه است. +- این [تاپیک در StackOverflow](https://stackoverflow.com/questions/3654830/why-are-there-no-and-operators-in-python) دلایل نبودن عملگرهای افزایش (`++`) و کاهش (`--`) در پایتون را بررسی می‌کند. + +- احتمالاً با عملگر Walrus (گراز دریایی) در پایتون آشنا هستید؛ اما تا به حال در مورد *عملگر Space-invader (مهاجم فضایی)* شنیده‌اید؟ ```py >>> a = 42 @@ -3809,16 +3944,19 @@ def dict_size(o): >>> a 43 ``` + از آن به‌عنوان جایگزینی برای عملگر افزایش (increment)، در ترکیب با یک عملگر دیگر استفاده می‌شود. + ```py >>> a +=+ 1 >>> a >>> 44 ``` + **💡 توضیح:** این شوخی از [توییت Raymond Hettinger](https://twitter.com/raymondh/status/1131103570856632321?lang=en) برگرفته شده است. عملگر «مهاجم فضایی» در واقع همان عبارت بدفرمت‌شده‌ی `a -= (-1)` است که معادل با `a = a - (- 1)` می‌باشد. حالت مشابهی برای عبارت `a += (+ 1)` نیز وجود دارد. -* پایتون یک عملگر مستندنشده برای [استلزام معکوس (converse implication)](https://en.wikipedia.org/wiki/Converse_implication) دارد. - +- پایتون یک عملگر مستندنشده برای [استلزام معکوس (converse implication)](https://en.wikipedia.org/wiki/Converse_implication) دارد. + ```py >>> False ** False == True True @@ -3832,7 +3970,7 @@ def dict_size(o): **💡 توضیح:** اگر مقادیر `False` و `True` را به‌ترتیب با اعداد ۰ و ۱ جایگزین کرده و محاسبات را انجام دهید، جدول درستی حاصل، معادل یک عملگر استلزام معکوس خواهد بود. ([منبع](https://github.com/cosmologicon/pywat/blob/master/explanation.md#the-undocumented-converse-implication-operator)) -* حالا که صحبت از عملگرها شد، عملگر `@` نیز برای ضرب ماتریسی در پایتون وجود دارد (نگران نباشید، این بار واقعی است). +- حالا که صحبت از عملگرها شد، عملگر `@` نیز برای ضرب ماتریسی در پایتون وجود دارد (نگران نباشید، این بار واقعی است). ```py >>> import numpy as np @@ -3842,15 +3980,16 @@ def dict_size(o): **💡 توضیح:** عملگر `@` در پایتون ۳٫۵ با در نظر گرفتن نیازهای جامعه علمی اضافه شد. هر شی‌ای می‌تواند متد جادویی `__matmul__` را بازنویسی کند تا رفتار این عملگر را مشخص نماید. -* از پایتون ۳٫۸ به بعد می‌توانید از نحو متداول f-string مانند `f'{some_var=}'` برای اشکال‌زدایی سریع استفاده کنید. مثال, +- از پایتون ۳٫۸ به بعد می‌توانید از نحو متداول f-string مانند `f'{some_var=}'` برای اشکال‌زدایی سریع استفاده کنید. مثال, + ```py >>> some_string = "wtfpython" >>> f'{some_string=}' "some_string='wtfpython'" - ``` + ``` + +- پایتون برای ذخیره‌سازی متغیرهای محلی در توابع از ۲ بایت استفاده می‌کند. از نظر تئوری، این به معنای امکان تعریف حداکثر ۶۵۵۳۶ متغیر در یک تابع است. با این حال، پایتون راهکار مفیدی ارائه می‌کند که می‌توان با استفاده از آن بیش از ۲^۱۶ نام متغیر را ذخیره کرد. کد زیر نشان می‌دهد وقتی بیش از ۶۵۵۳۶ متغیر محلی تعریف شود، در پشته (stack) چه اتفاقی رخ می‌دهد (هشدار: این کد تقریباً ۲^۱۸ خط متن چاپ می‌کند، بنابراین آماده باشید!): -* پایتون برای ذخیره‌سازی متغیرهای محلی در توابع از ۲ بایت استفاده می‌کند. از نظر تئوری، این به معنای امکان تعریف حداکثر ۶۵۵۳۶ متغیر در یک تابع است. با این حال، پایتون راهکار مفیدی ارائه می‌کند که می‌توان با استفاده از آن بیش از ۲^۱۶ نام متغیر را ذخیره کرد. کد زیر نشان می‌دهد وقتی بیش از ۶۵۵۳۶ متغیر محلی تعریف شود، در پشته (stack) چه اتفاقی رخ می‌دهد (هشدار: این کد تقریباً ۲^۱۸ خط متن چاپ می‌کند، بنابراین آماده باشید!): - ```py import dis exec(""" @@ -3862,10 +4001,10 @@ def dict_size(o): print(dis.dis(f)) ``` - -* چندین رشته (Thread) در پایتون، کدِ *پایتونی* شما را به‌صورت همزمان اجرا نمی‌کنند (بله، درست شنیدید!). شاید به نظر برسد که ایجاد چندین رشته و اجرای همزمان آن‌ها منطقی است، اما به دلیل وجود [قفل مفسر سراسری (GIL)](https://wiki.python.org/moin/GlobalInterpreterLock) در پایتون، تمام کاری که انجام می‌دهید این است که رشته‌هایتان به‌نوبت روی یک هسته اجرا می‌شوند. رشته‌ها در پایتون برای وظایفی مناسب هستند که عملیات I/O دارند، اما برای رسیدن به موازی‌سازی واقعی در وظایف پردازشی سنگین (CPU-bound)، بهتر است از ماژول [multiprocessing](https://docs.python.org/3/library/multiprocessing.html) در پایتون استفاده کنید. -* گاهی اوقات، متد `print` ممکن است مقادیر را فوراً چاپ نکند. برای مثال، +- چندین رشته (Thread) در پایتون، کدِ *پایتونی* شما را به‌صورت همزمان اجرا نمی‌کنند (بله، درست شنیدید!). شاید به نظر برسد که ایجاد چندین رشته و اجرای همزمان آن‌ها منطقی است، اما به دلیل وجود [قفل مفسر سراسری (GIL)](https://wiki.python.org/moin/GlobalInterpreterLock) در پایتون، تمام کاری که انجام می‌دهید این است که رشته‌هایتان به‌نوبت روی یک هسته اجرا می‌شوند. رشته‌ها در پایتون برای وظایفی مناسب هستند که عملیات I/O دارند، اما برای رسیدن به موازی‌سازی واقعی در وظایف پردازشی سنگین (CPU-bound)، بهتر است از ماژول [multiprocessing](https://docs.python.org/3/library/multiprocessing.html) در پایتون استفاده کنید. + +- گاهی اوقات، متد `print` ممکن است مقادیر را فوراً چاپ نکند. برای مثال، ```py # File some_file.py @@ -3877,14 +4016,16 @@ def dict_size(o): این کد عبارت `wtfpython` را به دلیل آرگومان `end` پس از ۳ ثانیه چاپ می‌کند؛ چرا که بافر خروجی تنها پس از رسیدن به کاراکتر `\n` یا در زمان اتمام اجرای برنامه تخلیه می‌شود. برای تخلیه‌ی اجباری بافر می‌توانید از آرگومان `flush=True` استفاده کنید. -* برش لیست‌ها (List slicing) با اندیس‌های خارج از محدوده، خطایی ایجاد نمی‌کند. +- برش لیست‌ها (List slicing) با اندیس‌های خارج از محدوده، خطایی ایجاد نمی‌کند. + ```py >>> some_list = [1, 2, 3, 4, 5] >>> some_list[111:] [] ``` -* برش زدن (slicing) یک شئ قابل پیمایش (iterable) همیشه یک شئ جدید ایجاد نمی‌کند. به‌عنوان مثال، +- برش زدن (slicing) یک شئ قابل پیمایش (iterable) همیشه یک شئ جدید ایجاد نمی‌کند. به‌عنوان مثال، + ```py >>> some_str = "wtfpython" >>> some_list = ['w', 't', 'f', 'p', 'y', 't', 'h', 'o', 'n'] @@ -3894,9 +4035,9 @@ def dict_size(o): True ``` -* در پایتون ۳، فراخوانی `int('١٢٣٤٥٦٧٨٩')` مقدار `123456789` را برمی‌گرداند. در پایتون، نویسه‌های ده‌دهی (Decimal characters) شامل تمام ارقامی هستند که می‌توانند برای تشکیل اعداد در مبنای ده استفاده شوند؛ به‌عنوان مثال نویسه‌ی U+0660 که همان رقم صفر عربی-هندی است. [اینجا](https://chris.improbable.org/2014/8/25/adventures-in-unicode-digits/) داستان جالبی درباره این رفتار پایتون آمده است. +- در پایتون ۳، فراخوانی `int('١٢٣٤٥٦٧٨٩')` مقدار `123456789` را برمی‌گرداند. در پایتون، نویسه‌های ده‌دهی (Decimal characters) شامل تمام ارقامی هستند که می‌توانند برای تشکیل اعداد در مبنای ده استفاده شوند؛ به‌عنوان مثال نویسه‌ی U+0660 که همان رقم صفر عربی-هندی است. [اینجا](https://chris.improbable.org/2014/8/25/adventures-in-unicode-digits/) داستان جالبی درباره این رفتار پایتون آمده است. -* از پایتون ۳ به بعد، می‌توانید برای افزایش خوانایی، اعداد را با استفاده از زیرخط (`_`) جدا کنید. +- از پایتون ۳ به بعد، می‌توانید برای افزایش خوانایی، اعداد را با استفاده از زیرخط (`_`) جدا کنید. ```py >>> six_million = 6_000_000 @@ -3907,7 +4048,8 @@ def dict_size(o): 4027435774 ``` -* عبارت `'abc'.count('') == 4` مقدار `True` برمی‌گرداند. در اینجا یک پیاده‌سازی تقریبی از متد `count` آورده شده که این موضوع را شفاف‌تر می‌کند: +- عبارت `'abc'.count('') == 4` مقدار `True` برمی‌گرداند. در اینجا یک پیاده‌سازی تقریبی از متد `count` آورده شده که این موضوع را شفاف‌تر می‌کند: + ```py def count(s, sub): result = 0 @@ -3915,6 +4057,7 @@ def dict_size(o): result += (s[i:i + len(sub)] == sub) return result ``` + این رفتار به این دلیل است که زیررشته‌ی خالی (`''`) با برش‌هایی (slices) به طول صفر در رشته‌ی اصلی مطابقت پیدا می‌کند. --- @@ -3938,17 +4081,17 @@ def dict_size(o): ایده و طراحی این مجموعه ابتدا از پروژه عالی [wtfjs](https://github.com/denysdovhan/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](https://news.ycombinator.com/item?id=21862073) and [Reddit](https://www.reddit.com/r/programming/comments/edsh3q/what_the_fck_python_30_exploring_and/). + +- 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](https://news.ycombinator.com/item?id=21862073) and [Reddit](https://www.reddit.com/r/programming/comments/edsh3q/what_the_fck_python_30_exploring_and/). # 🎓 مجوز @@ -3965,10 +4108,8 @@ def dict_size(o): [توییتر](https://twitter.com/intent/tweet?url=https://github.com/satwikkansal/wtfpython&text=If%20you%20really%20think%20you%20know%20Python,%20think%20once%20more!%20Check%20out%20wtfpython&hashtags=python,wtfpython) | [لینکدین](https://www.linkedin.com/shareArticle?url=https://github.com/satwikkansal&title=What%20the%20f*ck%20Python!&summary=If%20you%20really%20thing%20you%20know%20Python,%20think%20once%20more!) | [فیسبوک](https://www.facebook.com/dialog/share?app_id=536779657179021&display=page&href=https%3A%2F%2Fgithub.com%2Fsatwikkansal%2Fwtfpython"e=If%20you%20really%20think%20you%20know%20Python%2C%20think%20once%20more!) - ## آیا به یک نسخه pdf نیاز دارید؟ - من چند درخواست برای نسخه PDF (و epub) کتاب wtfpython دریافت کرده‌ام. برای دریافت این نسخه‌ها به محض آماده شدن، می‌توانید اطلاعات خود را [اینجا](https://form.jotform.com/221593245656057) وارد کنید. **همین بود دوستان!** برای دریافت مطالب آینده مشابه این، می‌توانید ایمیل خود را [اینجا](https://form.jotform.com/221593598380062) اضافه کنید. From 55e5ae206a1b66049226dc8948e601f36da91d9e Mon Sep 17 00:00:00 2001 From: Leo Alavi Date: Tue, 29 Apr 2025 16:11:30 +0200 Subject: [PATCH 33/33] Fix liniting issues --- README.md | 755 +++++++++++++++++++------------- translations/fa-farsi/README.md | 686 +++++++++++++++++------------ 2 files changed, 844 insertions(+), 597 deletions(-) diff --git a/README.md b/README.md index a82e11e..e1114cc 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,4 @@ +

@@ -35,23 +36,23 @@ So, here we go... - [Usage](#usage) - [👀 Examples](#-examples) - [Section: Strain your brain!](#section-strain-your-brain) - - [▶ First things first! *](#-first-things-first-) + - [▶ First things first! \*](#-first-things-first-) - [▶ Strings can be tricky sometimes](#-strings-can-be-tricky-sometimes) - [▶ Be careful with chained operations](#-be-careful-with-chained-operations) - [▶ How not to use `is` operator](#-how-not-to-use-is-operator) - [▶ Hash brownies](#-hash-brownies) - [▶ Deep down, we're all the same.](#-deep-down-were-all-the-same) - - [▶ Disorder within order *](#-disorder-within-order-) - - [▶ Keep trying... *](#-keep-trying-) + - [▶ Disorder within order \*](#-disorder-within-order-) + - [▶ Keep trying... \*](#-keep-trying-) - [▶ For what?](#-for-what) - [▶ Evaluation time discrepancy](#-evaluation-time-discrepancy) - [▶ `is not ...` is not `is (not ...)`](#-is-not--is-not-is-not-) - [▶ A tic-tac-toe where X wins in the first attempt!](#-a-tic-tac-toe-where-x-wins-in-the-first-attempt) - [▶ Schrödinger's variable](#-schrödingers-variable-) - - [▶ The chicken-egg problem *](#-the-chicken-egg-problem-) + - [▶ The chicken-egg problem \*](#-the-chicken-egg-problem-) - [▶ Subclass relationships](#-subclass-relationships) - [▶ Methods equality and identity](#-methods-equality-and-identity) - - [▶ All-true-ation *](#-all-true-ation-) + - [▶ All-true-ation \*](#-all-true-ation-) - [▶ The surprising comma](#-the-surprising-comma) - [▶ Strings and the backslashes](#-strings-and-the-backslashes) - [▶ not knot!](#-not-knot) @@ -59,8 +60,8 @@ So, here we go... - [▶ What's wrong with booleans?](#-whats-wrong-with-booleans) - [▶ Class attributes and instance attributes](#-class-attributes-and-instance-attributes) - [▶ yielding None](#-yielding-none) - - [▶ Yielding from... return! *](#-yielding-from-return-) - - [▶ Nan-reflexivity *](#-nan-reflexivity-) + - [▶ Yielding from... return! \*](#-yielding-from-return-) + - [▶ Nan-reflexivity \*](#-nan-reflexivity-) - [▶ Mutating the immutable!](#-mutating-the-immutable) - [▶ The disappearing variable from outer scope](#-the-disappearing-variable-from-outer-scope) - [▶ The mysterious key type conversion](#-the-mysterious-key-type-conversion) @@ -71,17 +72,17 @@ So, here we go... - [▶ Stubborn `del` operation](#-stubborn-del-operation) - [▶ The out of scope variable](#-the-out-of-scope-variable) - [▶ Deleting a list item while iterating](#-deleting-a-list-item-while-iterating) - - [▶ Lossy zip of iterators *](#-lossy-zip-of-iterators-) + - [▶ Lossy zip of iterators \*](#-lossy-zip-of-iterators-) - [▶ Loop variables leaking out!](#-loop-variables-leaking-out) - [▶ Beware of default mutable arguments!](#-beware-of-default-mutable-arguments) - [▶ Catching the Exceptions](#-catching-the-exceptions) - [▶ Same operands, different story!](#-same-operands-different-story) - [▶ Name resolution ignoring class scope](#-name-resolution-ignoring-class-scope) - - [▶ Rounding like a banker *](#-rounding-like-a-banker-) - - [▶ Needles in a Haystack *](#-needles-in-a-haystack-) - - [▶ Splitsies *](#-splitsies-) - - [▶ Wild imports *](#-wild-imports-) - - [▶ All sorted? *](#-all-sorted-) + - [▶ Rounding like a banker \*](#-rounding-like-a-banker-) + - [▶ Needles in a Haystack \*](#-needles-in-a-haystack-) + - [▶ Splitsies \*](#-splitsies-) + - [▶ Wild imports \*](#-wild-imports-) + - [▶ All sorted? \*](#-all-sorted-) - [▶ Midnight time doesn't exist?](#-midnight-time-doesnt-exist) - [Section: The Hidden treasures!](#section-the-hidden-treasures) - [▶ Okay Python, Can you make me fly?](#-okay-python-can-you-make-me-fly) @@ -90,7 +91,7 @@ So, here we go... - [▶ Let's meet Friendly Language Uncle For Life](#-lets-meet-friendly-language-uncle-for-life) - [▶ Even Python understands that love is complicated](#-even-python-understands-that-love-is-complicated) - [▶ Yes, it exists!](#-yes-it-exists) - - [▶ Ellipsis *](#-ellipsis-) + - [▶ Ellipsis \*](#-ellipsis-) - [▶ Inpinity](#-inpinity) - [▶ Let's mangle](#-lets-mangle) - [Section: Appearances are deceptive!](#section-appearances-are-deceptive) @@ -100,9 +101,9 @@ So, here we go... - [Section: Miscellaneous](#section-miscellaneous) - [▶ `+=` is faster](#--is-faster) - [▶ Let's make a giant string!](#-lets-make-a-giant-string) - - [▶ Slowing down `dict` lookups *](#-slowing-down-dict-lookups-) - - [▶ Bloating instance `dict`s *](#-bloating-instance-dicts-) - - [▶ Minor Ones *](#-minor-ones-) + - [▶ Slowing down `dict` lookups \*](#-slowing-down-dict-lookups-) + - [▶ Bloating instance `dict`s \*](#-bloating-instance-dicts-) + - [▶ Minor Ones \*](#-minor-ones-) - [Contributing](#contributing) - [Acknowledgements](#acknowledgements) - [🎓 License](#-license) @@ -131,7 +132,6 @@ All the examples are structured like below: > > (Optional): One line describing the unexpected output. > -> > #### 💡 Explanation: > > - Brief explanation of what's happening and why is it happening. @@ -167,7 +167,7 @@ A nice way to get the most out of these examples, in my opinion, is to read them ## Section: Strain your brain! -### ▶ First things first! * +### ▶ First things first! \* @@ -264,7 +264,7 @@ if a := some_func(): This saved one line of code, and implicitly prevented invoking `some_func` twice. -- Unparenthesized "assignment expression" (use of walrus operator), is restricted at the top level, hence the `SyntaxError` in the `a := "wtf_walrus"` statement of the first snippet. Parenthesizing it worked as expected and assigned `a`. +- Unparenthesized "assignment expression" (use of walrus operator), is restricted at the top level, hence the `SyntaxError` in the `a := "wtf_walrus"` statement of the first snippet. Parenthesizing it worked as expected and assigned `a`. - As usual, parenthesizing of an expression containing `=` operator is not allowed. Hence the syntax error in `(a, b = 6, 9)`. @@ -319,7 +319,7 @@ a = "wtf!"; b = "wtf!" assert a is b ``` -4\. __Disclaimer - snippet is not relavant in modern Python versions__ +4\. **Disclaimer - snippet is not relavant in modern Python versions** **Output (< Python3.7 )** @@ -333,6 +333,7 @@ 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: @@ -350,13 +351,15 @@ Makes sense, right? - 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](https://github.com/satwikkansal/wtfpython/issues/100) 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](https://en.wikipedia.org/wiki/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](https://github.com/python/cpython/blob/3.6/Python/peephole.c#L288) the implementation source for the same. +- The abrupt change in the output of the fourth snippet is due to a [peephole optimization](https://en.wikipedia.org/wiki/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](https://github.com/python/cpython/blob/3.6/Python/peephole.c#L288) 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](https://bugs.python.org/issue11549). --- ### ▶ Be careful with chained operations + + ```py >>> (False == False) in [False] # makes sense False @@ -403,7 +406,9 @@ While such behavior might seem silly to you in the above examples, it's fantasti --- ### ▶ How not to use `is` operator + + The following is a very famous example present all over the internet. 1\. @@ -470,6 +475,7 @@ False 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. :-) ```py @@ -528,7 +534,9 @@ Similar optimization applies to other **immutable** objects like empty tuples as --- ### ▶ Hash brownies + + 1\. ```py @@ -545,7 +553,7 @@ some_dict[5] = "Python" "JavaScript" >>> some_dict[5.0] # "Python" destroyed the existence of "Ruby"? "Python" ->>> some_dict[5] +>>> some_dict[5] "Python" >>> complex_five = 5 + 0j @@ -559,7 +567,7 @@ 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`): +- 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`): ```py >>> 5 == 5.0 == 5 + 0j @@ -573,6 +581,7 @@ So, why is Python all over the place? >>> (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. ```py @@ -582,6 +591,7 @@ So, why is Python all over the place? >>> 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](https://docs.python.org/3/reference/datamodel.html#object.__hash__) here), `5`, `5.0`, and `5 + 0j` have the same hash value. @@ -593,12 +603,14 @@ So, why is Python all over the place? 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](https://en.wikipedia.org/wiki/Collision_(computer_science)), and degrades the constant-time performance that hashing usually provides.) + **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. + + ```py class WTF: pass @@ -651,8 +663,10 @@ True --- -### ▶ Disorder within order * +### ▶ Disorder within order \* + + ```py from collections import OrderedDict @@ -715,45 +729,48 @@ 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](https://docs.python.org/3/library/collections.html#ordereddict-objects) - - > 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. + + > 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, - ```py - >>> 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 + ```py + >>> 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 - ``` + >>> 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`. + 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... * +### ▶ Keep trying... \* + + ```py def some_func(): try: @@ -761,7 +778,7 @@ def some_func(): finally: return 'from_finally' -def another_func(): +def another_func(): for _ in range(3): try: continue @@ -813,7 +830,9 @@ Iteration 0 --- ### ▶ For what? + + ```py some_string = "wtf" some_dict = {} @@ -872,7 +891,9 @@ for i, some_dict[i] in enumerate(some_string): --- ### ▶ Evaluation time discrepancy + + 1\. ```py @@ -937,13 +958,15 @@ array_4 = [400, 500, 600] - 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](https://www.python.org/dev/peps/pep-0289/#the-details) - - > Only the outermost for-expression is evaluated immediately, the other expressions are deferred until the generator is run. + + > Only the outermost for-expression is evaluated immediately, the other expressions are deferred until the generator is run. --- ### ▶ `is not ...` is not `is (not ...)` + + ```py >>> 'something' is not None True @@ -960,6 +983,7 @@ False --- ### ▶ A tic-tac-toe where X wins in the first attempt! + ```py @@ -1018,7 +1042,8 @@ We can avoid this scenario here by not using `row` variable to generate `board`. --- -### ▶ Schrödinger's variable * +### ▶ Schrödinger's variable \* + ```py @@ -1053,7 +1078,8 @@ The values of `x` were different in every iteration prior to appending `some_fun ``` #### 💡 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: + +- 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: ```py >>> import inspect @@ -1069,7 +1095,7 @@ Since `x` is a global value, we can change the value that the `funcs` will looku [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. +- 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. ```py funcs = [] @@ -1096,8 +1122,10 @@ ClosureVars(nonlocals={}, globals={}, builtins={}, unbound=set()) --- -### ▶ The chicken-egg problem * +### ▶ The chicken-egg problem \* + + 1\. ```py @@ -1147,7 +1175,9 @@ False --- ### ▶ Subclass relationships + + **Output:** ```py @@ -1160,7 +1190,7 @@ True 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`) +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: @@ -1172,6 +1202,7 @@ The Subclass relationships were expected to be transitive, right? (i.e., if `A` --- ### ▶ Methods equality and identity + 1. @@ -1203,7 +1234,7 @@ True True ``` -Accessing `classm` twice, we get an equal object, but not the *same* one? Let's see what happens +Accessing `classm` twice, we get an equal object, but not the _same_ one? Let's see what happens with instances of `SomeClass`: 2. @@ -1230,44 +1261,49 @@ True True ``` -Accessing `classm` or `method` twice, creates equal but not *same* objects for the same instance of `SomeClass`. +Accessing `classm` or `method` twice, creates equal but not _same_ objects for the same instance of `SomeClass`. #### 💡 Explanation + - Functions are [descriptors](https://docs.python.org/3/howto/descriptor.html). Whenever a function is accessed as an -attribute, the descriptor is invoked, creating a method object which "binds" the function with the object owning the -attribute. If called, the method calls the function, implicitly passing the bound object as the first argument -(this is how we get `self` as the first argument, despite not passing it explicitly). + attribute, the descriptor is invoked, creating a method object which "binds" the function with the object owning the + attribute. If called, the method calls the function, implicitly passing the bound object as the first argument + (this is how we get `self` as the first argument, despite not passing it explicitly). ```py >>> o1.method > ``` + - Accessing the attribute multiple times creates a method object every time! Therefore `o1.method is o1.method` is -never truthy. Accessing functions as class attributes (as opposed to instance) does not create methods, however; so -`SomeClass.method is SomeClass.method` is truthy. + never truthy. Accessing functions as class attributes (as opposed to instance) does not create methods, however; so + `SomeClass.method is SomeClass.method` is truthy. ```py >>> SomeClass.method ``` + - `classmethod` transforms functions into class methods. Class methods are descriptors that, when accessed, create -a method object which binds the *class* (type) of the object, instead of the object itself. + a method object which binds the _class_ (type) of the object, instead of the object itself. ```py >>> o1.classm > ``` + - Unlike functions, `classmethod`s will create a method also when accessed as class attributes (in which case they -bind the class, not to the type of it). So `SomeClass.classm is SomeClass.classm` is falsy. + bind the class, not to the type of it). So `SomeClass.classm is SomeClass.classm` is falsy. ```py >>> SomeClass.classm > ``` + - A method object compares equal when both the functions are equal, and the bound objects are the same. So -`o1.method == o1.method` is truthy, although not the same object in memory. + `o1.method == o1.method` is truthy, although not the same object in memory. - `staticmethod` transforms functions into a "no-op" descriptor, which returns the function as-is. No method -objects are ever created, so comparison with `is` is truthy. + objects are ever created, so comparison with `is` is truthy. ```py >>> o1.staticm @@ -1275,13 +1311,14 @@ objects are ever created, so comparison with `is` is truthy. >>> SomeClass.staticm ``` -- Having to create new "method" objects every time Python calls instance methods and having to modify the arguments -every time in order to insert `self` affected performance badly. -CPython 3.7 [solved it](https://bugs.python.org/issue26110) by introducing new opcodes that deal with calling methods -without creating the temporary method objects. This is used only when the accessed function is actually called, so the -snippets here are not affected, and still generate methods :) -### ▶ All-true-ation * +- Having to create new "method" objects every time Python calls instance methods and having to modify the arguments + every time in order to insert `self` affected performance badly. + CPython 3.7 [solved it](https://bugs.python.org/issue26110) by introducing new opcodes that deal with calling methods + without creating the temporary method objects. This is used only when the accessed function is actually called, so the + snippets here are not affected, and still generate methods :) + +### ▶ All-true-ation \* @@ -1320,7 +1357,9 @@ Why's this True-False alteration? --- ### ▶ The surprising comma + + **Output (< 3.6):** ```py @@ -1352,7 +1391,9 @@ SyntaxError: invalid syntax --- ### ▶ Strings and the backslashes + + **Output:** ```py @@ -1376,31 +1417,33 @@ True - In a usual python string, the backslash is used to escape characters that may have a special meaning (like single-quote, double-quote, and the backslash itself). - ```py - >>> "wt\"f" - 'wt"f' - ``` + ```py + >>> "wt\"f" + 'wt"f' + ``` -- In a raw string literal (as indicated by the prefix `r`), the backslashes pass themselves as is along with the behavior of escaping the following character. +- In a raw string literal (as indicated by the prefix `r`), the backslashes pass themselves as is along with the behavior of escaping the following character. - ```py - >>> r'wt\"f' == 'wt\\"f' - True - >>> print(repr(r'wt\"f')) - 'wt\\"f' + ```py + >>> r'wt\"f' == 'wt\\"f' + True + >>> print(repr(r'wt\"f')) + 'wt\\"f' - >>> print("\n") + >>> print("\n") - >>> print(r"\\n") - '\\n' - ``` + >>> print(r"\\n") + '\\n' + ``` - This means when a parser encounters a backslash in a raw string, it expects another character following it. And in our case (`print(r"\")`), the backslash escaped the trailing quote, leaving the parser without a terminating quote (hence the `SyntaxError`). That's why backslashes don't work at the end of a raw string. --- ### ▶ not knot! + + ```py x = True y = False @@ -1428,7 +1471,9 @@ SyntaxError: invalid syntax --- ### ▶ Half triple-quoted strings + + **Output:** ```py @@ -1446,6 +1491,7 @@ SyntaxError: EOF while scanning triple-quoted string literal ``` #### 💡 Explanation: + - Python supports implicit [string literal concatenation](https://docs.python.org/3/reference/lexical_analysis.html#string-literal-concatenation), Example, ``` @@ -1454,12 +1500,15 @@ SyntaxError: EOF while scanning triple-quoted string literal >>> print("wtf" "") # or "wtf""" wtf ``` + - `'''` and `"""` are also string delimiters in Python which causes a SyntaxError because the Python interpreter was expecting a terminating triple quote as delimiter while scanning the currently encountered triple quoted string literal. --- ### ▶ What's wrong with booleans? + + 1\. ```py @@ -1516,12 +1565,12 @@ I have lost faith in truth! - `bool` is a subclass of `int` in Python - ```py - >>> issubclass(bool, int) - True - >>> issubclass(int, bool) - False - ``` + ```py + >>> issubclass(bool, int) + True + >>> issubclass(int, bool) + False + ``` - And thus, `True` and `False` are instances of `int` @@ -1543,14 +1592,16 @@ I have lost faith in truth! - See this StackOverflow [answer](https://stackoverflow.com/a/8169049/4354153) for the rationale behind it. -- Initially, Python used to have no `bool` type (people used 0 for false and non-zero value like 1 for true). `True`, `False`, and a `bool` type was added in 2.x versions, but, for backward compatibility, `True` and `False` couldn't be made constants. They just were built-in variables, and it was possible to reassign them +- Initially, Python used to have no `bool` type (people used 0 for false and non-zero value like 1 for true). `True`, `False`, and a `bool` type was added in 2.x versions, but, for backward compatibility, `True` and `False` couldn't be made constants. They just were built-in variables, and it was possible to reassign them - Python 3 was backward-incompatible, the issue was finally fixed, and thus the last snippet won't work with Python 3.x! --- ### ▶ Class attributes and instance attributes + + 1\. ```py @@ -1623,7 +1674,9 @@ True --- ### ▶ yielding None + + ```py some_iterable = ('a', 'b') @@ -1655,8 +1708,10 @@ def some_func(val): --- -### ▶ Yielding from... return! * +### ▶ Yielding from... return! \* + + 1\. ```py @@ -1720,7 +1775,7 @@ The same result, this didn't work either. --- -### ▶ Nan-reflexivity * +### ▶ Nan-reflexivity \* @@ -1775,7 +1830,7 @@ True - `'inf'` and `'nan'` are special strings (case-insensitive), which, when explicitly typecast-ed to `float` type, are used to represent mathematical "infinity" and "not a number" respectively. -- Since according to IEEE standards `NaN != NaN`, obeying this rule breaks the reflexivity assumption of a collection element in Python i.e. if `x` is a part of a collection like `list`, the implementations like comparison are based on the assumption that `x == x`. Because of this assumption, the identity is compared first (since it's faster) while comparing two elements, and the values are compared only when the identities mismatch. The following snippet will make things clearer, +- Since according to IEEE standards `NaN != NaN`, obeying this rule breaks the reflexivity assumption of a collection element in Python i.e. if `x` is a part of a collection like `list`, the implementations like comparison are based on the assumption that `x == x`. Because of this assumption, the identity is compared first (since it's faster) while comparing two elements, and the values are compared only when the identities mismatch. The following snippet will make things clearer, ```py >>> x = float('nan') @@ -1825,7 +1880,8 @@ But I thought tuples were immutable... - Quoting from https://docs.python.org/3/reference/datamodel.html - > Immutable sequences + > Immutable sequences + An object of an immutable sequence type cannot change once it is created. (If the object contains references to other objects, these other objects may be mutable and may be modified; however, the collection of objects directly referenced by an immutable object cannot change.) - `+=` operator changes the list in-place. The item assignment doesn't work, but when the exception occurs, the item has already been changed in place. @@ -1834,6 +1890,7 @@ But I thought tuples were immutable... --- ### ▶ The disappearing variable from outer scope + ```py @@ -1883,43 +1940,45 @@ NameError: name 'e' is not defined - The clauses are not scoped in Python. Everything in the example is present in the same scope, and the variable `e` got removed due to the execution of the `except` clause. The same is not the case with functions that have their separate inner-scopes. The example below illustrates this: - ```py - def f(x): - del(x) - print(x) + ```py + def f(x): + del(x) + print(x) - x = 5 - y = [5, 4, 3] - ``` + x = 5 + y = [5, 4, 3] + ``` - **Output:** + **Output:** - ```py - >>> f(x) - UnboundLocalError: local variable 'x' referenced before assignment - >>> f(y) - UnboundLocalError: local variable 'x' referenced before assignment - >>> x - 5 - >>> y - [5, 4, 3] - ``` + ```py + >>> f(x) + UnboundLocalError: local variable 'x' referenced before assignment + >>> f(y) + UnboundLocalError: local variable 'x' referenced before assignment + >>> x + 5 + >>> y + [5, 4, 3] + ``` - In Python 2.x, the variable name `e` gets assigned to `Exception()` instance, so when you try to print, it prints nothing. - **Output (Python 2.x):** + **Output (Python 2.x):** - ```py - >>> e - Exception() - >>> print e - # Nothing is printed! - ``` + ```py + >>> e + Exception() + >>> print e + # Nothing is printed! + ``` --- ### ▶ The mysterious key type conversion + + ```py class SomeClass(str): pass @@ -1978,7 +2037,9 @@ str --- ### ▶ Let's see if you can guess this? + + ```py a, b = a[b] = {}, 5 ``` @@ -1999,7 +2060,7 @@ a, b = a[b] = {}, 5 ``` and - + > An assignment statement evaluates the expression list (remember that this can be a single expression or a comma-separated list, the latter yielding a tuple) and assigns the single resulting object to each of the target lists, from left to right. - The `+` in `(target_list "=")+` means there can be **one or more** target lists. In this case, target lists are `a, b` and `a[b]` (note the expression list is exactly one, which in our case is `{}, 5`). @@ -2083,7 +2144,9 @@ Fortunately, you can increase the limit for the allowed number of digits when yo ## Section: Slippery Slopes ### ▶ Modifying a dictionary while iterating over it + + ```py x = {0: None} @@ -2119,6 +2182,7 @@ Yes, it runs for exactly **eight** times and stops. --- ### ▶ Stubborn `del` operation + @@ -2158,6 +2222,7 @@ Deleted! Okay, now it's deleted :confused: #### 💡 Explanation: + - `del x` doesn’t directly call `x.__del__()`. - When `del x` is encountered, Python deletes the name `x` from current scope and decrements by 1 the reference count of the object `x` referenced. `__del__()` is called only when the object's reference count reaches zero. - In the second output snippet, `__del__()` was not called because the previous statement (`>>> y`) in the interactive interpreter created another reference to the same object (specifically, the `_` magic variable which references the result value of the last non `None` expression on the REPL), thus preventing the reference count from reaching zero when `del y` was encountered. @@ -2166,6 +2231,7 @@ Okay, now it's deleted :confused: --- ### ▶ The out of scope variable + 1\. @@ -2212,6 +2278,7 @@ UnboundLocalError: local variable 'a' referenced before assignment ``` #### 💡 Explanation: + - When you make an assignment to a variable in scope, it becomes local to that scope. So `a` becomes local to the scope of `another_func`, but it has not been initialized previously in the same scope, which throws an error. - To modify the outer scope variable `a` in `another_func`, we have to use the `global` keyword. @@ -2228,6 +2295,7 @@ UnboundLocalError: local variable 'a' referenced before assignment >>> another_func() 2 ``` + - In `another_closure_func`, `a` becomes local to the scope of `another_inner_func`, but it has not been initialized previously in the same scope, which is why it throws an error. - To modify the outer scope variable `a` in `another_inner_func`, use the `nonlocal` keyword. The nonlocal statement is used to refer to variables defined in the nearest outer (excluding the global) scope. @@ -2247,13 +2315,16 @@ UnboundLocalError: local variable 'a' referenced before assignment >>> another_func() 2 ``` + - The keywords `global` and `nonlocal` tell the python interpreter to not declare new variables and look them up in the corresponding outer scopes. - Read [this](https://sebastianraschka.com/Articles/2014_python_scope_and_namespaces.html) short but an awesome guide to learn more about how namespaces and scope resolution works in Python. --- ### ▶ Deleting a list item while iterating + + ```py list_1 = [1, 2, 3, 4] list_2 = [1, 2, 3, 4] @@ -2292,15 +2363,16 @@ Can you guess why the output is `[2, 4]`? - It's never a good idea to change the object you're iterating over. The correct way to do so is to iterate over a copy of the object instead, and `list_3[:]` does just that. - ```py - >>> some_list = [1, 2, 3, 4] - >>> id(some_list) - 139798789457608 - >>> id(some_list[:]) # Notice that python creates new object for sliced list. - 139798779601192 - ``` + ```py + >>> some_list = [1, 2, 3, 4] + >>> id(some_list) + 139798789457608 + >>> id(some_list[:]) # Notice that python creates new object for sliced list. + 139798779601192 + ``` **Difference between `del`, `remove`, and `pop`:** + - `del var_name` just removes the binding of the `var_name` from the local or global namespace (That's why the `list_1` is unaffected). - `remove` removes the first matching value, not a specific index, raises `ValueError` if the value is not found. - `pop` removes the element at a specific index and returns it, raises `IndexError` if an invalid index is specified. @@ -2314,7 +2386,8 @@ Can you guess why the output is `[2, 4]`? --- -### ▶ Lossy zip of iterators * +### ▶ Lossy zip of iterators \* + ```py @@ -2325,7 +2398,7 @@ Can you guess why the output is `[2, 4]`? >>> first_three, remaining ([0, 1, 2], [3, 4, 5, 6]) >>> numbers_iter = iter(numbers) ->>> list(zip(numbers_iter, first_three)) +>>> 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)) @@ -2338,38 +2411,40 @@ Where did element `3` go from the `numbers` list? - From Python [docs](https://docs.python.org/3.3/library/functions.html#zip), here's an approximate implementation of zip function, - ```py - 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) - ``` + ```py + 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) + ``` - So the function takes in arbitrary number of iterable objects, adds each of their items to the `result` list by calling the `next` function on them, and stops whenever any of the iterable is exhausted. - The caveat here is when any iterable is exhausted, the existing elements in the `result` list are discarded. That's what happened with `3` in the `numbers_iter`. - The correct way to do the above using `zip` would be, - ```py - >>> 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)] - ``` + ```py + >>> 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)] + ``` - The first argument of zip should be the one with fewest elements. + The first argument of zip should be the one with fewest elements. --- ### ▶ Loop variables leaking out! + + 1\. ```py @@ -2434,11 +2509,12 @@ print(x, ': x in global') - The differences in the output of Python 2.x and Python 3.x interpreters for list comprehension example can be explained by following change documented in [What’s New In Python 3.0](https://docs.python.org/3/whatsnew/3.0.html) changelog: - > "List comprehensions no longer support the syntactic form `[... for var in item1, item2, ...]`. Use `[... for var in (item1, item2, ...)]` instead. Also, note that list comprehensions have different semantics: they are closer to syntactic sugar for a generator expression inside a `list()` constructor, and in particular, the loop control variables are no longer leaked into the surrounding scope." + > "List comprehensions no longer support the syntactic form `[... for var in item1, item2, ...]`. Use `[... for var in (item1, item2, ...)]` instead. Also, note that list comprehensions have different semantics: they are closer to syntactic sugar for a generator expression inside a `list()` constructor, and in particular, the loop control variables are no longer leaked into the surrounding scope." --- ### ▶ Beware of default mutable arguments! + ```py @@ -2464,42 +2540,44 @@ def some_func(default_arg=[]): - The default mutable arguments of functions in Python aren't really initialized every time you call the function. Instead, the recently assigned value to them is used as the default value. When we explicitly passed `[]` to `some_func` as the argument, the default value of the `default_arg` variable was not used, so the function returned as expected. - ```py - def some_func(default_arg=[]): - default_arg.append("some_string") - return default_arg - ``` + ```py + def some_func(default_arg=[]): + default_arg.append("some_string") + return default_arg + ``` - **Output:** + **Output:** - ```py - >>> some_func.__defaults__ #This will show the default argument values for the function - ([],) - >>> 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'],) - ``` + ```py + >>> some_func.__defaults__ #This will show the default argument values for the function + ([],) + >>> 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'],) + ``` - A common practice to avoid bugs due to mutable arguments is to assign `None` as the default value and later check if any value is passed to the function corresponding to that argument. Example: - ```py - def some_func(default_arg=None): - if default_arg is None: - default_arg = [] - default_arg.append("some_string") - return default_arg - ``` + ```py + def some_func(default_arg=None): + if default_arg is None: + default_arg = [] + default_arg.append("some_string") + return default_arg + ``` --- ### ▶ Catching the Exceptions + + ```py some_list = [1, 2, 3] try: @@ -2584,7 +2662,9 @@ SyntaxError: invalid syntax --- ### ▶ Same operands, different story! + + 1\. ```py @@ -2621,7 +2701,7 @@ a += [5, 6, 7, 8] #### 💡 Explanation: -- `a += b` doesn't always behave the same way as `a = a + b`. Classes *may* implement the *`op=`* operators differently, and lists do this. +- `a += b` doesn't always behave the same way as `a = a + b`. Classes _may_ implement the _`op=`_ operators differently, and lists do this. - The expression `a = a + [5,6,7,8]` generates a new list and sets `a`'s reference to that new list, leaving `b` unchanged. @@ -2630,7 +2710,9 @@ a += [5, 6, 7, 8] --- ### ▶ Name resolution ignoring class scope + + 1\. ```py @@ -2678,7 +2760,7 @@ class SomeClass: --- -### ▶ Rounding like a banker * +### ▶ Rounding like a banker \* Let's implement a naive function to get the middle element of a list: @@ -2731,7 +2813,7 @@ It seems as though Python rounded 2.5 to 2. --- -### ▶ Needles in a Haystack * +### ▶ Needles in a Haystack \* @@ -2825,7 +2907,7 @@ some_dict = { "key_3": 3 } -some_list = some_list.append(4) +some_list = some_list.append(4) some_dict = some_dict.update({"key_4": 4}) ``` @@ -2889,10 +2971,10 @@ def similar_recursive_func(a): Traceback (most recent call last): File "", line 1, in AssertionError - + >>> assert (a == b, "Values are not equal") :1: SyntaxWarning: assertion is always true, perhaps remove parentheses? - + >>> assert a == b, "Values are not equal" Traceback (most recent call last): File "", line 1, in @@ -2907,8 +2989,10 @@ def similar_recursive_func(a): --- -### ▶ Splitsies * +### ▶ Splitsies \* + + ```py >>> 'a'.split() ['a'] @@ -2929,22 +3013,23 @@ def similar_recursive_func(a): #### 💡 Explanation: - It might appear at first that the default separator for split is a single space `' '`, but as per the [docs](https://docs.python.org/3/library/stdtypes.html#str.split) - > If sep is not specified or is `None`, a different splitting algorithm is applied: runs of consecutive whitespace are regarded as a single separator, and the result will contain no empty strings at the start or end if the string has leading or trailing whitespace. Consequently, splitting an empty string or a string consisting of just whitespace with a None separator returns `[]`. - > If sep is given, consecutive delimiters are not grouped together and are deemed to delimit empty strings (for example, `'1,,2'.split(',')` returns `['1', '', '2']`). Splitting an empty string with a specified separator returns `['']`. + > If sep is not specified or is `None`, a different splitting algorithm is applied: runs of consecutive whitespace are regarded as a single separator, and the result will contain no empty strings at the start or end if the string has leading or trailing whitespace. Consequently, splitting an empty string or a string consisting of just whitespace with a None separator returns `[]`. + > If sep is given, consecutive delimiters are not grouped together and are deemed to delimit empty strings (for example, `'1,,2'.split(',')` returns `['1', '', '2']`). Splitting an empty string with a specified separator returns `['']`. - Noticing how the leading and trailing whitespaces are handled in the following snippet will make things clear, - ```py - >>> ' a '.split(' ') - ['', 'a', ''] - >>> ' a '.split() - ['a'] - >>> ''.split(' ') - [''] - ``` + ```py + >>> ' a '.split(' ') + ['', 'a', ''] + >>> ' a '.split() + ['a'] + >>> ''.split(' ') + [''] + ``` --- -### ▶ Wild imports * +### ▶ Wild imports \* + @@ -2976,38 +3061,38 @@ NameError: name '_another_weird_name_func' is not defined - It is often advisable to not use wildcard imports. The first obvious reason for this is, in wildcard imports, the names with a leading underscore don't get imported. This may lead to errors during runtime. - Had we used `from ... import a, b, c` syntax, the above `NameError` wouldn't have occurred. - ```py - >>> from module import some_weird_name_func_, _another_weird_name_func - >>> _another_weird_name_func() - works! - ``` + ```py + >>> from module import some_weird_name_func_, _another_weird_name_func + >>> _another_weird_name_func() + works! + ``` - If you really want to use wildcard imports, then you'd have to define the list `__all__` in your module that will contain a list of public objects that'll be available when we do wildcard imports. - ```py - __all__ = ['_another_weird_name_func'] + ```py + __all__ = ['_another_weird_name_func'] - def some_weird_name_func_(): - print("works!") + def some_weird_name_func_(): + print("works!") - def _another_weird_name_func(): - print("works!") - ``` + def _another_weird_name_func(): + print("works!") + ``` - **Output** + **Output** - ```py - >>> _another_weird_name_func() - "works!" - >>> some_weird_name_func_() - Traceback (most recent call last): - File "", line 1, in - NameError: name 'some_weird_name_func_' is not defined - ``` + ```py + >>> _another_weird_name_func() + "works!" + >>> some_weird_name_func_() + Traceback (most recent call last): + File "", line 1, in + NameError: name 'some_weird_name_func_' is not defined + ``` --- -### ▶ All sorted? * +### ▶ All sorted? \* @@ -3049,7 +3134,9 @@ False --- ### ▶ Midnight time doesn't exist? + + ```py from datetime import datetime @@ -3079,6 +3166,7 @@ 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." --- + --- ## Section: The Hidden treasures! @@ -3086,7 +3174,9 @@ Before Python 3.5, the boolean value for `datetime.time` object was considered t This section contains a few lesser-known and interesting things about Python that most beginners like me are unaware of (well, not anymore). ### ▶ Okay Python, Can you make me fly? + + Well, here you go ```py @@ -3097,6 +3187,7 @@ import antigravity Sshh... It's a super-secret. #### 💡 Explanation: + - `antigravity` module is one of the few easter eggs released by Python developers. - `import antigravity` opens up a web browser pointing to the [classic XKCD comic](https://xkcd.com/353/) about Python. - Well, there's more to it. There's **another easter egg inside the easter egg**. If you look at the [code](https://github.com/python/cpython/blob/master/Lib/antigravity.py#L7-L17), there's a function defined that purports to implement the [XKCD's geohashing algorithm](https://xkcd.com/426/). @@ -3104,6 +3195,7 @@ Sshh... It's a super-secret. --- ### ▶ `goto`, but why? + ```py @@ -3135,7 +3227,9 @@ Freedom! --- ### ▶ Brace yourself! + + If you are one of the people who doesn't like using whitespace in Python to denote scopes, you can use the C-style {} by importing, ```py @@ -3153,6 +3247,7 @@ SyntaxError: not a chance Braces? No way! If you think that's disappointing, use Java. Okay, another surprising thing, can you find where's the `SyntaxError` raised in `__future__` module [code](https://github.com/python/cpython/blob/master/Lib/__future__.py)? #### 💡 Explanation: + - The `__future__` module is normally used to provide features from future versions of Python. The "future" in this specific context is however, ironic. - This is an easter egg concerned with the community's feelings on this issue. - The code is actually present [here](https://github.com/python/cpython/blob/025eb98dc0c1dc27404df6c544fc2944e0fa9f3a/Python/future.c#L49) in `future.c` file. @@ -3161,7 +3256,9 @@ Braces? No way! If you think that's disappointing, use Java. Okay, another surpr --- ### ▶ Let's meet Friendly Language Uncle For Life + + **Output (Python 3.x)** ```py @@ -3182,20 +3279,23 @@ There we go. - This is relevant to [PEP-401](https://www.python.org/dev/peps/pep-0401/) released on April 1, 2009 (now you know, what it means). - Quoting from the PEP-401 - + > Recognized that the != inequality operator in Python 3.0 was a horrible, finger-pain inducing mistake, the FLUFL reinstates the <> diamond operator as the sole spelling. + - There were more things that Uncle Barry had to share in the PEP; you can read them [here](https://www.python.org/dev/peps/pep-0401/). - It works well in an interactive environment, but it will raise a `SyntaxError` when you run via python file (see this [issue](https://github.com/satwikkansal/wtfpython/issues/94)). However, you can wrap the statement inside an `eval` or `compile` to get it working, - ```py - from __future__ import barry_as_FLUFL - print(eval('"Ruby" <> "Python"')) - ``` + ```py + from __future__ import barry_as_FLUFL + print(eval('"Ruby" <> "Python"')) + ``` --- ### ▶ Even Python understands that love is complicated + + ```py import this ``` @@ -3253,7 +3353,9 @@ True --- ### ▶ Yes, it exists! + + **The `else` clause for loops.** One typical example might be: ```py @@ -3300,8 +3402,10 @@ Try block executed successfully... --- -### ▶ Ellipsis * +### ▶ Ellipsis \* + + ```py def some_func(): Ellipsis @@ -3326,12 +3430,13 @@ Ellipsis - In Python, `Ellipsis` is a globally available built-in object which is equivalent to `...`. - ```py - >>> ... - Ellipsis - ``` + ```py + >>> ... + Ellipsis + ``` - Ellipsis can be used for several purposes, + - As a placeholder for code that hasn't been written yet (just like `pass` statement) - In slicing syntax to represent the full slices in remaining direction @@ -3363,13 +3468,16 @@ Ellipsis ``` Note: this will work for any number of dimensions. You can even select slice in first and last dimension and ignore the middle ones this way (`n_dimensional_array[firs_dim_slice, ..., last_dim_slice]`) + - In [type hinting](https://docs.python.org/3/library/typing.html) to indicate only a part of the type (like `(Callable[..., int]` or `Tuple[str, ...]`)) - You may also use Ellipsis as a default function argument (in the cases when you want to differentiate between the "no argument passed" and "None value passed" scenarios). --- ### ▶ Inpinity + + The spelling is intended. Please, don't submit a patch for this. **Output (Python 3.x):** @@ -3390,7 +3498,9 @@ The spelling is intended. Please, don't submit a patch for this. --- ### ▶ Let's mangle + + 1\. ```py @@ -3467,12 +3577,15 @@ AttributeError: 'A' object has no attribute '__variable' - Also, if the mangled name is longer than 255 characters, truncation will happen. --- + --- ## Section: Appearances are deceptive! ### ▶ Skipping lines? + + **Output:** ```py @@ -3543,7 +3656,9 @@ Where's the Nobel Prize? --- ### ▶ Well, something is fishy... + + ```py def square(x): """ @@ -3568,25 +3683,28 @@ Shouldn't that be 100? #### 💡 Explanation -- **Don't mix tabs and spaces!** The character just preceding return is a "tab", and the code is indented by multiple of "4 spaces" elsewhere in the example. +- **Don't mix tabs and spaces!** The character just preceding return is a "tab", and the code is indented by multiple of "4 spaces" elsewhere in the example. - This is how Python handles tabs: - + > First, tabs are replaced (from left to right) by one to eight spaces such that the total number of characters up to and including the replacement is a multiple of eight <...> + - So the "tab" at the last line of `square` function is replaced with eight spaces, and it gets into the loop. - Python 3 is kind enough to throw an error for such cases automatically. - **Output (Python 3.x):** + **Output (Python 3.x):** - ```py - TabError: inconsistent use of tabs and spaces in indentation - ``` + ```py + TabError: inconsistent use of tabs and spaces in indentation + ``` --- + --- ## Section: Miscellaneous ### ▶ `+=` is faster + ```py @@ -3599,12 +3717,15 @@ Shouldn't that be 100? ``` #### 💡 Explanation: + - `+=` is faster than `+` for concatenating more than two strings because the first string (example, `s1` for `s1 += s2 + s3`) is not destroyed while calculating the complete string. --- ### ▶ Let's make a giant string! + + ```py def add_string_with_plus(iters): s = "" @@ -3695,13 +3816,15 @@ Let's increase the number of iterations by a factor of 10. ``` - So many ways to format and create a giant string are somewhat in contrast to the [Zen of Python](https://www.python.org/dev/peps/pep-0020/), according to which, - - > There should be one-- and preferably only one --obvious way to do it. + + > There should be one-- and preferably only one --obvious way to do it. --- -### ▶ Slowing down `dict` lookups * +### ▶ Slowing down `dict` lookups \* + + ```py some_dict = {str(i): 1 for i in range(1_000_000)} another_dict = {str(i): 1 for i in range(1_000_000)} @@ -3729,13 +3852,16 @@ KeyError: 1 Why are same lookups becoming slower? #### 💡 Explanation: + - CPython has a generic dictionary lookup function that handles all types of keys (`str`, `int`, any object ...), and a specialized one for the common case of dictionaries composed of `str`-only keys. - The specialized function (named `lookdict_unicode` in CPython's [source](https://github.com/python/cpython/blob/522691c46e2ae51faaad5bbbce7d959dd61770df/Objects/dictobject.c#L841)) knows all existing keys (including the looked-up key) are strings, and uses the faster & simpler string comparison to compare keys, instead of calling the `__eq__` method. - The first time a `dict` instance is accessed with a non-`str` key, it's modified so future lookups use the generic function. - This process is not reversible for the particular `dict` instance, and the key doesn't even have to exist in the dictionary. That's why attempting a failed lookup has the same effect. -### ▶ Bloating instance `dict`s * +### ▶ Bloating instance `dict`s \* + + ```py import sys @@ -3790,19 +3916,23 @@ Let's try again... In a new interpreter: What makes those dictionaries become bloated? And why are newly created objects bloated as well? #### 💡 Explanation: + - CPython is able to reuse the same "keys" object in multiple dictionaries. This was added in [PEP 412](https://www.python.org/dev/peps/pep-0412/) with the motivation to reduce memory usage, specifically in dictionaries of instances - where keys (instance attributes) tend to be common to all instances. - This optimization is entirely seamless for instance dictionaries, but it is disabled if certain assumptions are broken. - Key-sharing dictionaries do not support deletion; if an instance attribute is deleted, the dictionary is "unshared", and key-sharing is disabled for all future instances of the same class. -- Additionally, if the dictionary keys have been resized (because new keys are inserted), they are kept shared *only* if they are used by a exactly single dictionary (this allows adding many attributes in the `__init__` of the very first created instance, without causing an "unshare"). If multiple instances exist when a resize happens, key-sharing is disabled for all future instances of the same class: CPython can't tell if your instances are using the same set of attributes anymore, and decides to bail out on attempting to share their keys. +- Additionally, if the dictionary keys have been resized (because new keys are inserted), they are kept shared _only_ if they are used by a exactly single dictionary (this allows adding many attributes in the `__init__` of the very first created instance, without causing an "unshare"). If multiple instances exist when a resize happens, key-sharing is disabled for all future instances of the same class: CPython can't tell if your instances are using the same set of attributes anymore, and decides to bail out on attempting to share their keys. - A small tip, if you aim to lower your program's memory footprint: don't delete instance attributes, and make sure to initialize all attributes in your `__init__`! -### ▶ Minor Ones * +### ▶ Minor Ones \* + + - `join()` is a string operation instead of list operation. (sort of counter-intuitive at first usage) **💡 Explanation:** If `join()` is a method on a string, then it can operate on any iterable (list, tuple, iterators). If it were a method on a list, it'd have to be implemented separately by every type. Also, it doesn't make much sense to put a string-specific method on a generic `list` object API. - + - Few weird looking but semantically correct statements: + - `[] = ()` is a semantically correct statement (unpacking an empty `tuple` into an empty `list`) - `'a'[0][0][0][0][0]` is also semantically correct, because Python doesn't have a character data type like other languages branched from C. So selecting a single character from a string returns a single-character string. - `3 --0-- 5 == 8` and `--5 == 5` are both semantically correct statements and evaluate to `True`. @@ -3820,11 +3950,12 @@ What makes those dictionaries become bloated? And why are newly created objects ``` **💡 Explanation:** + - There is no `++` operator in Python grammar. It is actually two `+` operators. - `++a` parses as `+(+a)` which translates to `a`. Similarly, the output of the statement `--a` can be justified. - This StackOverflow [thread](https://stackoverflow.com/questions/3654830/why-are-there-no-and-operators-in-python) discusses the rationale behind the absence of increment and decrement operators in Python. -- You must be aware of the Walrus operator in Python. But have you ever heard about *the space-invader operator*? +- You must be aware of the Walrus operator in Python. But have you ever heard about _the space-invader operator_? ```py >>> a = 42 @@ -3842,67 +3973,67 @@ What makes those dictionaries become bloated? And why are newly created objects ``` **💡 Explanation:** This prank comes from [Raymond Hettinger's tweet](https://twitter.com/raymondh/status/1131103570856632321?lang=en). The space invader operator is actually just a malformatted `a -= (-1)`. Which is equivalent to `a = a - (- 1)`. Similar for the `a += (+ 1)` case. - + - Python has an undocumented [converse implication](https://en.wikipedia.org/wiki/Converse_implication) operator. - ```py - >>> False ** False == True - True - >>> False ** True == False - True - >>> True ** False == True - True - >>> True ** True == True - True - ``` + ```py + >>> False ** False == True + True + >>> False ** True == False + True + >>> True ** False == True + True + >>> True ** True == True + True + ``` - **💡 Explanation:** If you replace `False` and `True` by 0 and 1 and do the maths, the truth table is equivalent to a converse implication operator. ([Source](https://github.com/cosmologicon/pywat/blob/master/explanation.md#the-undocumented-converse-implication-operator)) + **💡 Explanation:** If you replace `False` and `True` by 0 and 1 and do the maths, the truth table is equivalent to a converse implication operator. ([Source](https://github.com/cosmologicon/pywat/blob/master/explanation.md#the-undocumented-converse-implication-operator)) - Since we are talking operators, there's also `@` operator for matrix multiplication (don't worry, this time it's for real). - ```py - >>> import numpy as np - >>> np.array([2, 2, 2]) @ np.array([7, 8, 8]) - 46 - ``` + ```py + >>> import numpy as np + >>> np.array([2, 2, 2]) @ np.array([7, 8, 8]) + 46 + ``` - **💡 Explanation:** The `@` operator was added in Python 3.5 keeping the scientific community in mind. Any object can overload `__matmul__` magic method to define behavior for this operator. + **💡 Explanation:** The `@` operator was added in Python 3.5 keeping the scientific community in mind. Any object can overload `__matmul__` magic method to define behavior for this operator. - From Python 3.8 onwards you can use a typical f-string syntax like `f'{some_var=}` for quick debugging. Example, - ```py - >>> some_string = "wtfpython" - >>> f'{some_string=}' - "some_string='wtfpython'" - ``` + ```py + >>> some_string = "wtfpython" + >>> f'{some_string=}' + "some_string='wtfpython'" + ``` - Python uses 2 bytes for local variable storage in functions. In theory, this means that only 65536 variables can be defined in a function. However, python has a handy solution built in that can be used to store more than 2^16 variable names. The following code demonstrates what happens in the stack when more than 65536 local variables are defined (Warning: This code prints around 2^18 lines of text, so be prepared!): - ```py - import dis - exec(""" - def f(): - """ + """ - """.join(["X" + str(x) + "=" + str(x) for x in range(65539)])) + ```py + import dis + exec(""" + def f(): + """ + """ + """.join(["X" + str(x) + "=" + str(x) for x in range(65539)])) - f() + f() - print(dis.dis(f)) - ``` + print(dis.dis(f)) + ``` -- Multiple Python threads won't run your *Python code* concurrently (yes, you heard it right!). It may seem intuitive to spawn several threads and let them execute your Python code concurrently, but, because of the [Global Interpreter Lock](https://wiki.python.org/moin/GlobalInterpreterLock) in Python, all you're doing is making your threads execute on the same core turn by turn. Python threads are good for IO-bound tasks, but to achieve actual parallelization in Python for CPU-bound tasks, you might want to use the Python [multiprocessing](https://docs.python.org/3/library/multiprocessing.html) module. +- Multiple Python threads won't run your _Python code_ concurrently (yes, you heard it right!). It may seem intuitive to spawn several threads and let them execute your Python code concurrently, but, because of the [Global Interpreter Lock](https://wiki.python.org/moin/GlobalInterpreterLock) in Python, all you're doing is making your threads execute on the same core turn by turn. Python threads are good for IO-bound tasks, but to achieve actual parallelization in Python for CPU-bound tasks, you might want to use the Python [multiprocessing](https://docs.python.org/3/library/multiprocessing.html) module. - Sometimes, the `print` method might not print values immediately. For example, - ```py - # File some_file.py - import time - - print("wtfpython", end="_") - time.sleep(3) - ``` + ```py + # File some_file.py + import time - This will print the `wtfpython` after 3 seconds due to the `end` argument because the output buffer is flushed either after encountering `\n` or when the program finishes execution. We can force the buffer to flush by passing `flush=True` argument. + print("wtfpython", end="_") + time.sleep(3) + ``` + + This will print the `wtfpython` after 3 seconds due to the `end` argument because the output buffer is flushed either after encountering `\n` or when the program finishes execution. We can force the buffer to flush by passing `flush=True` argument. - List slicing with out of the bounds indices throws no errors @@ -3914,27 +4045,27 @@ What makes those dictionaries become bloated? And why are newly created objects - Slicing an iterable not always creates a new object. For example, - ```py - >>> 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 - ``` + ```py + >>> 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('١٢٣٤٥٦٧٨٩')` returns `123456789` in Python 3. In Python, Decimal characters include digit characters, and all characters that can be used to form decimal-radix numbers, e.g. U+0660, ARABIC-INDIC DIGIT ZERO. Here's an [interesting story](https://chris.improbable.org/2014/8/25/adventures-in-unicode-digits/) related to this behavior of Python. - You can separate numeric literals with underscores (for better readability) from Python 3 onwards. - ```py - >>> six_million = 6_000_000 - >>> six_million - 6000000 - >>> hex_address = 0xF00D_CAFE - >>> hex_address - 4027435774 - ``` + ```py + >>> six_million = 6_000_000 + >>> six_million + 6000000 + >>> hex_address = 0xF00D_CAFE + >>> hex_address + 4027435774 + ``` - `'abc'.count('') == 4`. Here's an approximate implementation of `count` method, which would make the things more clear @@ -3949,6 +4080,7 @@ What makes those dictionaries become bloated? And why are newly created objects The behavior is due to the matching of empty substring(`''`) with slices of length 0 in the original string. --- + --- # Contributing @@ -3970,6 +4102,7 @@ PS: Please don't reach out with backlinking requests, no links will be added unl The idea and design for this collection were initially inspired by Denys Dovhan's awesome project [wtfjs](https://github.com/denysdovhan/wtfjs). The overwhelming support by Pythonistas gave it the shape it is in right now. #### Some nice Links! + - 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 @@ -3993,7 +4126,7 @@ The idea and design for this collection were initially inspired by Denys Dovhan' If you like wtfpython, you can use these quick links to share it with your friends, -[Twitter](https://twitter.com/intent/tweet?url=https://github.com/satwikkansal/wtfpython&text=If%20you%20really%20think%20you%20know%20Python,%20think%20once%20more!%20Check%20out%20wtfpython&hashtags=python,wtfpython) | [Linkedin](https://www.linkedin.com/shareArticle?url=https://github.com/satwikkansal&title=What%20the%20f*ck%20Python!&summary=If%20you%20really%20thing%20you%20know%20Python,%20think%20once%20more!) | [Facebook](https://www.facebook.com/dialog/share?app_id=536779657179021&display=page&href=https%3A%2F%2Fgithub.com%2Fsatwikkansal%2Fwtfpython"e=If%20you%20really%20think%20you%20know%20Python%2C%20think%20once%20more!) +[Twitter](https://twitter.com/intent/tweet?url=https://github.com/satwikkansal/wtfpython&text=If%20you%20really%20think%20you%20know%20Python,%20think%20once%20more!%20Check%20out%20wtfpython&hashtags=python,wtfpython) | [Linkedin](https://www.linkedin.com/shareArticle?url=https://github.com/satwikkansal&title=What%20the%20f*ck%20Python!&summary=If%20you%20really%20thing%20you%20know%20Python,%20think%20once%20more!) | [Facebook](https://www.facebook.com/dialog/share?app_id=536779657179021&display=page&href=https%3A%2F%2Fgithub.com%2Fsatwikkansal%2Fwtfpython"e=If%20you%20really%20think%20you%20know%20Python%2C%20think%20once%20more!) ## Need a pdf version? diff --git a/translations/fa-farsi/README.md b/translations/fa-farsi/README.md index 22e7eb2..cddeb0b 100644 --- a/translations/fa-farsi/README.md +++ b/translations/fa-farsi/README.md @@ -1,3 +1,6 @@ + + +

@@ -148,7 +151,7 @@ - [💡 توضیح:](#-توضیح-50) - [◀ بله، این واقعاً وجود دارد!](#-بله-این-واقعاً-وجود-دارد) - [💡 توضیح:](#-توضیح-51) - - [◀ عملگر Ellipsis \*](#-عملگر-ellipsis--) + - [◀ عملگر Ellipsis \*](#-عملگر-ellipsis-) - [💡توضیح](#توضیح) - [◀ بی‌نهایت (`Inpinity`)](#-بینهایت-inpinity) - [💡 توضیح:](#-توضیح-52) @@ -166,14 +169,13 @@ - [💡 توضیح:](#-توضیح-57) - [◀ بیایید یک رشته‌ی بزرگ بسازیم!](#-بیایید-یک-رشتهی-بزرگ-بسازیم) - [💡 توضیح](#-توضیح-58) - - [◀ کُند کردن جستجوها در `dict` \*](#--کُند-کردن-جستجوها-در-dict-) + - [◀ کُند کردن جستجوها در `dict` \*](#-کُند-کردن-جستجوها-در-dict-) - [💡 توضیح:](#-توضیح-59) - [◀ حجیم کردن دیکشنری نمونه‌ها (`instance dicts`) \*](#-حجیم-کردن-دیکشنری-نمونهها-instance-dicts-) - [💡 توضیح:](#-توضیح-60) - [◀ موارد جزئی \*](#-موارد-جزئی-) - [مشارکت](#مشارکت) -- [تقدیر و تشکر](#تقدیر-و-تشکر) - - [چند لینک جالب!](#چند-لینک-جالب) +- [تقدیر و تشکر](#تقدیر-و-تشکر) - [چند لینک جالب!](#چند-لینک-جالب) - [🎓 مجوز](#-مجوز) - [دوستانتان را هم شگفت‌زده کنید!](#دوستانتان-را-هم-شگفتزده-کنید) - [آیا به یک نسخه pdf نیاز دارید؟](#آیا-به-یک-نسخه-pdf-نیاز-دارید) @@ -200,7 +202,6 @@ > > (دلخواه): توضیح یک‌خطی خروجی غیرمنتظره > -> > #### 💡 توضیح: > > - توضیح کوتاه درمورد این‌که چی داره اتفاق میافته و چرا. @@ -239,7 +240,7 @@ ## بخش: ذهن خود را به چالش بکشید! -### ◀ اول از همه! * +### ◀ اول از همه! \* @@ -363,6 +364,7 @@ if a := some_func(): ### ◀ بعضی وقت‌ها رشته‌ها می‌توانند دردسرساز شوند + 1\. ```py @@ -447,7 +449,9 @@ False --- ### ◀ مراقب عملیات‌های زنجیره‌ای باشید + + ```py >>> (False == False) in [False] # منطقیه False @@ -472,7 +476,8 @@ 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، ...، 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` عالی عمل می‌کنه. @@ -493,7 +498,9 @@ False --- ### ◀ چطور از عملگر `is` استفاده نکنیم + + عبارت پایین خیلی معروفه و تو کل اینترنت موجوده. 1\. @@ -543,7 +550,7 @@ False #### 💡 توضیح: -**فرض بین عملگرهای `is` و `==`** +**فرض بین عملگرهای `is` و `==`** - عملگر `is` بررسی میکنه که دو متغیر در حافظه دستگاه به یک شیء اشاره میکنند یا نه (یعنی شناسه متغیرها رو با هم تطبیق میده). - عملگر `==` مقدار متغیرها رو با هم مقایسه میکنه و یکسان بودنشون رو بررسی میکنه. @@ -560,6 +567,7 @@ False وقتی پایتون رو اجرا می‌کنید اعداد از `-5` تا `256` در حافظه ذخیره میشن. چون این اعداد خیلی پرکاربرد هستند پس منطقیه که اون‌ها رو در حافظه دستگاه، آماده داشته باشیم. نقل قول از https://docs.python.org/3/c-api/long.html + > در پیاده سازی فعلی یک آرایه از اشیاء عددی صحیح برای تمام اعداد صحیح بین `-5` تا `256` نگه‌داری می‌شود. وقتی شما یک عدد صحیح در این بازه به مقداردهی می‌کنید، فقط یک ارجاع به آن عدد که از قبل در حافظه ذخیره شده است دریافت می‌کنید. پس تغییر مقدار عدد 1 باید ممکن باشد. که در این مورد من به رفتار پایتون شک دارم تعریف‌نشده است. :-) ```py @@ -618,7 +626,9 @@ False --- ### ◀ کلیدهای هش + + 1\. ```py @@ -635,7 +645,7 @@ some_dict[5] = "Python" "JavaScript" >>> some_dict[5.0] # رشته ("Python")، رشته ("Ruby") رو از بین برد؟ "Python" ->>> some_dict[5] +>>> some_dict[5] "Python" >>> complex_five = 5 + 0j @@ -685,12 +695,14 @@ complex True ``` - **توجه:** برعکس این قضیه لزوما درست نیست. شیءهای میتونن هش های یکسانی داشته باشند ولی مقادیر نابرابری داشته باشند. (این باعث به وجود اومدن پدیده‌ای معروف [تصادف هش](https://en.wikipedia.org/wiki/Collision_(disambiguation)#Other_uses) میشه)، در این صورت توابع هش عملکرد خودشون رو کندتر از حالت عادی انجام می‌دهند. + **توجه:** برعکس این قضیه لزوما درست نیست. شیءهای میتونن هش های یکسانی داشته باشند ولی مقادیر نابرابری داشته باشند. (این باعث به وجود اومدن پدیده‌ای معروف [تصادف هش]() میشه)، در این صورت توابع هش عملکرد خودشون رو کندتر از حالت عادی انجام می‌دهند. --- ### ◀ در عمق وجود همه ما یکسان هستیم + + ```py class WTF: pass @@ -743,8 +755,10 @@ True --- -### ◀ بی‌نظمی در خود نظم * +### ◀ بی‌نظمی در خود نظم \* + + ```py from collections import OrderedDict @@ -807,7 +821,7 @@ TypeError: unhashable type: 'dict' #### 💡 توضیح: - دلیل اینکه این مقایسه بین متغیرهای `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 به ترتیب اعضای آن‌ها هم بستگی دارد و به صورت `list(od1.items())==list(od2.items())` پیاده سازی شده است. مقایسه برابری بین شیءهای `OrderedDict` و شیءهای قابل نگاشت دیگر به ترتیب اعضای آن‌ها بستگی ندارد و مقایسه همانند دیکشنری‌های عادی انجام می‌شود. - این رفتار باعث میشه که بتونیم `OrderedDict` ها رو هرجایی که یک دیکشنری عادی کاربرد داره، جایگزین کنیم و استفاده کنیم. - خب، حالا چرا تغییر ترتیب روی طول مجموعه‌ای که از دیکشنری‌ها ساختیم، تاثیر گذاشت؟ جوابش همین رفتار مقایسه‌ای غیرانتقالی بین این شیءهاست. از اونجایی که `set` ها مجموعه‌ای از عناصر غیرتکراری و بدون نظم هستند، ترتیبی که عناصر تو این مجموعه‌ها درج میشن نباید مهم باشه. ولی در این مورد، مهم هست. بیاید کمی تجزیه و تحلیلش کنیم. @@ -837,14 +851,16 @@ TypeError: unhashable type: 'dict' >>> 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` هست. + پس بی‌ثباتی تو این رفتار به خاطر اینه که مقدار `another_ordered_dict in another_set` برابر با `False` هست چون `ordered_dict` از قبل داخل `another_set` هست و همونطور که قبلا مشاهده کردید، مقدار `ordered_dict == another_ordered_dict` برابر با `False` هست. --- -### ◀ تلاش کن... * +### ◀ تلاش کن... \* + + ```py def some_func(): try: @@ -852,7 +868,7 @@ def some_func(): finally: return 'from_finally' -def another_func(): +def another_func(): for _ in range(3): try: continue @@ -905,7 +921,9 @@ Iteration 0 --- ### ◀ برای چی؟ + + ```py some_string = "wtf" some_dict = {} @@ -924,7 +942,7 @@ for i, some_dict[i] in enumerate(some_string): - یک حلقه `for` در [گرامر پایتون](https://docs.python.org/3/reference/grammar.html) این طور تعریف میشه: - ``` + ```bash for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite] ``` @@ -939,7 +957,7 @@ for i, some_dict[i] in enumerate(some_string): **خروجی:** - ``` + ```bash 0 1 2 @@ -964,7 +982,9 @@ for i, some_dict[i] in enumerate(some_string): --- ### ◀ اختلاف زمانی در محاسبه + + 1\. ```py @@ -1030,12 +1050,14 @@ array_4 = [400, 500, 600] - در مورد دوم، مقداردهی برشی به `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` بلافاصله محاسبه میشه و باقی عبارت‌ها به تعویق انداخته میشن تا زمانی که تولیدکننده اجرا بشه. + > فقط بیرونی‌ترین عبارت حلقه `for` بلافاصله محاسبه میشه و باقی عبارت‌ها به تعویق انداخته میشن تا زمانی که تولیدکننده اجرا بشه. --- ### ◀ هر گردی، گردو نیست + + ```py >>> 'something' is not None True @@ -1052,6 +1074,7 @@ False --- ### ◀ یک بازی دوز که توش X همون اول برنده میشه! + ```py @@ -1115,9 +1138,12 @@ board = [row] * 3 --- -### ◀ متغیر شرودینگر * +### ◀ متغیر شرودینگر \* + +مثال اول: + ```py funcs = [] results = [] @@ -1141,7 +1167,7 @@ funcs_results = [func() for func in funcs] مقدار `x` در هر تکرار حلقه قبل از اضافه کردن `some_func` به لیست `funcs` متفاوت بود، ولی همه توابع در خارج از حلقه مقدار `6` رو برمیگردونند. -2. +مثال دوم: ```py >>> powers_of_x = [lambda x: x**i for i in range(10)] @@ -1151,7 +1177,7 @@ funcs_results = [func() for func in funcs] #### 💡 توضیح: -- وقتی یک تابع رو در داخل یک حلقه تعریف می‌کنیم که در بدنه‌اش از متغیر اون حلقه استفاده شده، بست این تابع به *متغیر* وصله، نه *مقدار* اون. تابع به جای اینکه از مقدار `x` در زمان تعریف تابع استفاده کنه، در زمینه اطرافش دنبال `x` می‌گرده. پس همه این توابع از آخرین مقداری که به متغیر `x` مقداردهی شده برای محاسباتشون استفاده می‌کنند. ما می‌تونیم ببینیم که این توابع از متغیر `x` که در زمینه اطرافشون (*نه* از متغیر محلی) هست، استفاده می‌کنند، به این صورت: +- وقتی یک تابع رو در داخل یک حلقه تعریف می‌کنیم که در بدنه‌اش از متغیر اون حلقه استفاده شده، بست این تابع به _متغیر_ وصله، نه _مقدار_ اون. تابع به جای اینکه از مقدار `x` در زمان تعریف تابع استفاده کنه، در زمینه اطرافش دنبال `x` می‌گرده. پس همه این توابع از آخرین مقداری که به متغیر `x` مقداردهی شده برای محاسباتشون استفاده می‌کنند. ما می‌تونیم ببینیم که این توابع از متغیر `x` که در زمینه اطرافشون (_نه_ از متغیر محلی) هست، استفاده می‌کنند، به این صورت: ```py >>> import inspect @@ -1194,8 +1220,10 @@ ClosureVars(nonlocals={}, globals={}, builtins={}, unbound=set()) --- -### ◀ اول مرغ بوده یا تخم مرغ؟ * +### ◀ اول مرغ بوده یا تخم مرغ؟ \* + + 1\. ```py @@ -1245,7 +1273,9 @@ False --- ### ◀ روابط بین زیرمجموعه کلاس‌ها + + **خروجی:** ```py @@ -1270,9 +1300,10 @@ False --- ### ◀ برابری و هویت متدها + -1. +مثال اول ```py class SomeClass: @@ -1301,10 +1332,10 @@ True True ``` -با دوبار دسترسی به `classm`، یک شیء برابر دریافت می‌کنیم، اما *همان* شیء نیست؟ بیایید ببینیم +با دوبار دسترسی به `classm`، یک شیء برابر دریافت می‌کنیم، اما _همان_ شیء نیست؟ بیایید ببینیم چه اتفاقی برای نمونه‌های `SomeClass` می‌افتد: -2. +مثال دوم ```py o1 = SomeClass() @@ -1328,7 +1359,7 @@ True True ``` -دسترسی به `classm` یا `method` دو بار، اشیایی برابر اما نه *یکسان* را برای همان نمونه از `SomeClass` ایجاد می‌کند. +دسترسی به `classm` یا `method` دو بار، اشیایی برابر اما نه _یکسان_ را برای همان نمونه از `SomeClass` ایجاد می‌کند. #### 💡 توضیح @@ -1346,7 +1377,7 @@ True ``` -- `classmethod` توابع را به متدهای کلاس تبدیل می‌کند. متدهای کلاس وصاف‌هایی هستند که هنگام دسترسی، یک شیء متد ایجاد می‌کنند که به *کلاس* (نوع) شیء متصل می‌شود، نه خود شیء. +- `classmethod` توابع را به متدهای کلاس تبدیل می‌کند. متدهای کلاس وصاف‌هایی هستند که هنگام دسترسی، یک شیء متد ایجاد می‌کنند که به _کلاس_ (نوع) شیء متصل می‌شود، نه خود شیء. ```py >>> o1.classm @@ -1371,9 +1402,9 @@ True ``` - ایجاد شیءهای "متد" جدید در هر بار فراخوانی متدهای نمونه و نیاز به اصلاح آرگومان‌ها برای درج `self`، عملکرد را به شدت تحت تأثیر قرار می‌داد. -CPython 3.7 [این مشکل را حل کرد](https://bugs.python.org/issue26110) با معرفی opcodeهای جدیدی که فراخوانی متدها را بدون ایجاد شیء متد موقتی مدیریت می‌کنند. این به شرطی است که تابع دسترسی‌یافته واقعاً فراخوانی شود، بنابراین قطعه‌کدهای اینجا تحت تأثیر قرار نمی‌گیرند و همچنان متد ایجاد می‌کنند :) + CPython 3.7 [این مشکل را حل کرد](https://bugs.python.org/issue26110) با معرفی opcodeهای جدیدی که فراخوانی متدها را بدون ایجاد شیء متد موقتی مدیریت می‌کنند. این به شرطی است که تابع دسترسی‌یافته واقعاً فراخوانی شود، بنابراین قطعه‌کدهای اینجا تحت تأثیر قرار نمی‌گیرند و همچنان متد ایجاد می‌کنند :) -### ◀ آل-ترو-یشن * +### ◀ آل-ترو-یشن \* @@ -1405,14 +1436,16 @@ True return True ``` -- `all([])` مقدار `True` را برمی‌گرداند چون iterable خالی است. -- `all([[]])` مقدار `False` را برمی‌گرداند چون آرایه‌ی داده‌شده یک عنصر دارد، یعنی `[]`، و در پایتون، لیست خالی مقدار falsy دارد. +- `all([])` مقدار `True` را برمی‌گرداند چون iterable خالی است. +- `all([[]])` مقدار `False` را برمی‌گرداند چون آرایه‌ی داده‌شده یک عنصر دارد، یعنی `[]`، و در پایتون، لیست خالی مقدار falsy دارد. - `all([[[]]])` و نسخه‌های بازگشتی بالاتر همیشه `True` هستند. دلیلش این است که عنصر واحد آرایه‌ی داده‌شده (`[[...]]`) دیگر خالی نیست، و لیست‌هایی که دارای مقدار باشند، truthy در نظر گرفته می‌شوند. --- ### ◀ کاما‌ی شگفت‌انگیز + + **خروجی (< 3.6):** ```py @@ -1444,7 +1477,9 @@ SyntaxError: invalid syntax --- ### ◀ رشته‌ها و بک‌اسلش‌ها + + **خروجی:** ```py @@ -1468,31 +1503,33 @@ True - در یک رشته‌ی معمولی در پایتون، بک‌اسلش برای فرار دادن (escape) نویسه‌هایی استفاده می‌شود که ممکن است معنای خاصی داشته باشند (مانند تک‌نقل‌قول، دوتا‌نقل‌قول، و خودِ بک‌اسلش). - ```py - >>> "wt\"f" - 'wt"f' - ``` + ```py + >>> "wt\"f" + 'wt"f' + ``` - در یک رشته‌ی خام (raw string literal) که با پیشوند `r` مشخص می‌شود، بک‌اسلش‌ها خودشان به همان شکل منتقل می‌شوند، به‌همراه رفتار فرار دادن نویسه‌ی بعدی. - ```py - >>> r'wt\"f' == 'wt\\"f' - True - >>> print(repr(r'wt\"f')) - 'wt\\"f' + ```py + >>> r'wt\"f' == 'wt\\"f' + True + >>> print(repr(r'wt\"f')) + 'wt\\"f' - >>> print("\n") + >>> print("\n") - >>> print(r"\\n") - '\\n' - ``` + >>> print(r"\\n") + '\\n' + ``` - در یک رشته‌ی خام (raw string) که با پیشوند `r` مشخص می‌شود، بک‌اسلش‌ها خودشان به همان صورت منتقل می‌شوند، همراه با رفتاری که کاراکتر بعدی را فرار می‌دهد (escape می‌کند). --- ### ◀ گره نیست، نَه! + + ```py x = True y = False @@ -1520,7 +1557,9 @@ SyntaxError: invalid syntax --- ### ◀ رشته‌های نیمه سه‌نقل‌قولی + + **خروجی:** ```py @@ -1541,7 +1580,7 @@ SyntaxError: EOF while scanning triple-quoted string literal - پایتون از الحاق ضمنی [رشته‌های متنی](https://docs.python.org/3/reference/lexical_analysis.html#string-literal-concatenation) پشتیبانی می‌کند. برای مثال، - ``` + ```python >>> print("wtf" "python") wtfpython >>> print("wtf" "") # or "wtf""" @@ -1553,7 +1592,9 @@ SyntaxError: EOF while scanning triple-quoted string literal --- ### ◀ مشکل بولین ها چیست؟ + + 1\. ‫ یک مثال ساده برای شمردن تعداد مقادیر بولی # اعداد صحیح در یک iterable با انواع داده‌ی مخلوط. @@ -1611,12 +1652,12 @@ I have lost faith in truth! - در پایتون، `bool` زیرکلاسی از `int` است - ```py - >>> issubclass(bool, int) - True - >>> issubclass(int, bool) - False - ``` + ```py + >>> issubclass(bool, int) + True + >>> issubclass(int, bool) + False + ``` - و بنابراین، `True` و `False` نمونه‌هایی از `int` هستند @@ -1645,7 +1686,9 @@ I have lost faith in truth! --- ### ◀ متغیرهای کلاس و متغیرهای نمونه + + 1\. ```py @@ -1718,7 +1761,9 @@ True --- ### ◀ واگذار کردن None + + ```py some_iterable = ('a', 'b') @@ -1751,7 +1796,9 @@ def some_func(val): --- ### ◀ بازگرداندن با استفاده از `yield from`! + + 1\. ```py @@ -1815,7 +1862,7 @@ def some_func(x): --- -### ◀ بازتاب‌ناپذیری * +### ◀ بازتاب‌ناپذیری \* @@ -1920,8 +1967,11 @@ TypeError: 'tuple' object does not support item assignment - نقل‌قول از https://docs.python.org/3/reference/datamodel.html - > دنباله‌های تغییرناپذیر - شیئی از نوع دنباله‌ی تغییرناپذیر، پس از ایجاد دیگر قابل تغییر نیست. (اگر شیء شامل ارجاع‌هایی به اشیای دیگر باشد، این اشیای دیگر ممکن است قابل تغییر باشند و تغییر کنند؛ اما مجموعه‌ی اشیایی که مستقیماً توسط یک شیء تغییرناپذیر ارجاع داده می‌شوند، نمی‌تواند تغییر کند.) + > دنباله‌های تغییرناپذیر + + ```text + شیئی از نوع دنباله‌ی تغییرناپذیر، پس از ایجاد دیگر قابل تغییر نیست. (اگر شیء شامل ارجاع‌هایی به اشیای دیگر باشد، این اشیای دیگر ممکن است قابل تغییر باشند و تغییر کنند؛ اما مجموعه‌ی اشیایی که مستقیماً توسط یک شیء تغییرناپذیر ارجاع داده می‌شوند، نمی‌تواند تغییر کند.) + ``` - عملگر `+=` لیست را به‌صورت درجا (in-place) تغییر می‌دهد. تخصیص به یک عضو کار نمی‌کند، اما زمانی که استثنا ایجاد می‌شود، عضو موردنظر پیش از آن به‌صورت درجا تغییر کرده است. - همچنین توضیحی در [پرسش‌های متداول رسمی پایتون](https://docs.python.org/3/faq/programming.html#why-does-a-tuple-i-item-raise-an-exception-when-the-addition-works) وجود دارد. @@ -1929,6 +1979,7 @@ TypeError: 'tuple' object does not support item assignment --- ### ◀ متغیری که از اسکوپ بیرونی ناپدید می‌شود + ```py @@ -1959,62 +2010,64 @@ NameError: name 'e' is not defined هنگامی که یک استثنا (Exception) با استفاده از کلمه‌ی کلیدی `as` به متغیری تخصیص داده شود، این متغیر در انتهای بلاکِ `except` پاک می‌شود. این رفتار مشابه کد زیر است: - ```py - except E as N: - foo - ``` +```py +except E as N: + foo +``` - به این شکل ترجمه شده باشد: +به این شکل ترجمه شده باشد: - ```py - except E as N: - try: - foo - finally: - del N - ``` +```py +except E as N: + try: + foo + finally: + del N +``` این بدان معناست که استثنا باید به نام دیگری انتساب داده شود تا بتوان پس از پایان بند `except` به آن ارجاع داد. استثناها پاک می‌شوند چون با داشتن «ردیابی» (traceback) ضمیمه‌شده، یک چرخه‌ی مرجع (reference cycle) با قاب پشته (stack frame) تشکیل می‌دهند که باعث می‌شود تمام متغیرهای محلی (locals) در آن قاب تا زمان پاکسازی حافظه (garbage collection) باقی بمانند. - در پایتون، بندها (`clauses`) حوزه‌ی مستقل ندارند. در مثال بالا، همه‌چیز در یک حوزه‌ی واحد قرار دارد، و متغیر `e` در اثر اجرای بند `except` حذف می‌شود. این موضوع در مورد توابع صادق نیست، زیرا توابع حوزه‌های داخلی جداگانه‌ای دارند. مثال زیر این نکته را نشان می‌دهد: - ```py - def f(x): - del(x) - print(x) + ```py + def f(x): + del(x) + print(x) - x = 5 - y = [5, 4, 3] - ``` + x = 5 + y = [5, 4, 3] + ``` - **خروجی:** + **خروجی:** - ```py - >>> f(x) - UnboundLocalError: local variable 'x' referenced before assignment - >>> f(y) - UnboundLocalError: local variable 'x' referenced before assignment - >>> x - 5 - >>> y - [5, 4, 3] - ``` + ```py + >>> 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):** + **خروجی (Python 2.x):** - ```py - >>> e - Exception() - >>> print e - # چیزی چاپ نمی شود. - ``` + ```py + >>> e + Exception() + >>> print e + # چیزی چاپ نمی شود. + ``` --- ### ◀ تبدیل اسرارآمیز نوع کلید + + ```py class SomeClass(str): pass @@ -2073,7 +2126,9 @@ str --- ### ◀ ببینیم می‌توانید این را حدس بزنید؟ + + ```py a, b = a[b] = {}, 5 ``` @@ -2089,12 +2144,12 @@ a, b = a[b] = {}, 5 - طبق [مرجع زبان پایتون](https://docs.python.org/3/reference/simple_stmts.html#assignment-statements)، دستورات انتساب فرم زیر را دارند: - ``` + ```text (target_list "=")+ (expression_list | yield_expression) ``` و - + > یک دستور انتساب ابتدا فهرست عبارت‌ها (expression list) را ارزیابی می‌کند (توجه کنید این عبارت می‌تواند یک عبارت تکی یا فهرستی از عبارت‌ها جداشده با ویرگول باشد که دومی به یک تاپل منجر می‌شود)، سپس شیء حاصل را به هریک از اهداف انتساب از **چپ به راست** تخصیص می‌دهد. - علامت `+` در `(target_list "=")+` به این معناست که می‌توان **یک یا چند** هدف انتساب داشت. در این حالت، اهداف انتساب ما `a, b` و `a[b]` هستند (توجه کنید که عبارت ارزیابی‌شده دقیقاً یکی است، که در اینجا `{}` و `5` است). @@ -2178,7 +2233,9 @@ ValueError: Exceeds the limit (4300) for integer string conversion: ## بخش: شیب‌های لغزنده ### ◀ تغییر یک دیکشنری هنگام پیمایش روی آن + + ```py x = {0: None} @@ -2190,7 +2247,7 @@ for i in x: **خروجی (پایتون 2.7تا پایتون 3.5):** -``` +```text 0 1 2 @@ -2214,6 +2271,7 @@ for i in x: --- ### ◀ عملیات سرسختانه‌ی `del` + @@ -2262,6 +2320,7 @@ Deleted! --- ### ◀ متغیری که از حوزه خارج است + 1\. @@ -2352,7 +2411,9 @@ UnboundLocalError: local variable 'a' referenced before assignment --- ### ◀ حذف المان‌های لیست در حین پیمایش + + ```py list_1 = [1, 2, 3, 4] list_2 = [1, 2, 3, 4] @@ -2391,13 +2452,13 @@ for idx, item in enumerate(list_4): - هیچ‌وقت ایده‌ی خوبی نیست که شیئی را که روی آن پیمایش می‌کنید تغییر دهید. روش درست این است که روی یک کپی از آن شیء پیمایش کنید؛ در این‌جا `list_3[:]` دقیقاً همین کار را می‌کند. - ```py - >>> some_list = [1, 2, 3, 4] - >>> id(some_list) - 139798789457608 - >>> id(some_list[:]) # دقت کنید که پایتون برای اسلایس کردن، یک شی جدید میسازد - 139798779601192 - ``` + ```py + >>> some_list = [1, 2, 3, 4] + >>> id(some_list) + 139798789457608 + >>> id(some_list[:]) # دقت کنید که پایتون برای اسلایس کردن، یک شی جدید میسازد + 139798779601192 + ``` **تفاوت بین `del`، `remove` و `pop`:** @@ -2414,7 +2475,8 @@ for idx, item in enumerate(list_4): --- -### ◀ زیپِ دارای اتلاف برای پیمایشگرها * +### ◀ زیپِ دارای اتلاف برای پیمایشگرها \* + ```py @@ -2425,7 +2487,7 @@ for idx, item in enumerate(list_4): >>> first_three, remaining ([0, 1, 2], [3, 4, 5, 6]) >>> numbers_iter = iter(numbers) ->>> list(zip(numbers_iter, first_three)) +>>> list(zip(numbers_iter, first_three)) [(0, 0), (1, 1), (2, 2)] # تاحالا که خوب بوده، حالا روی باقی مانده های زیپ رو امتحان می کنیم. >>> list(zip(numbers_iter, remaining)) @@ -2438,38 +2500,40 @@ for idx, item in enumerate(list_4): - بر اساس [مستندات](https://docs.python.org/3.3/library/functions.html#zip) پایتون، پیاده‌سازی تقریبی تابع `zip` به شکل زیر است: - ```py - 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) - ``` + ```py + 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` اضافه می‌کند. این فرایند زمانی متوقف می‌شود که اولین پیمایشگر به انتها برسد. +- بنابراین این تابع تعداد دلخواهی از اشیای قابل پیمایش (_iterable_) را دریافت می‌کند، و با فراخوانی تابع `next` روی آن‌ها، هر یک از عناصرشان را به لیست `result` اضافه می‌کند. این فرایند زمانی متوقف می‌شود که اولین پیمایشگر به انتها برسد. - نکته مهم اینجاست که هر زمان یکی از پیمایشگرها به پایان برسد، عناصر موجود در لیست `result` نیز دور ریخته می‌شوند. این دقیقاً همان اتفاقی است که برای عدد `3` در `numbers_iter` رخ داد. - روش صحیح برای انجام عملیات بالا با استفاده از تابع `zip` چنین است: - - ```py - >>> 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` باید پیمایشگری باشد که کمترین تعداد عنصر را دارد. + ```py + >>> 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\. ```py @@ -2530,15 +2594,16 @@ print(x, ': x in global') #### 💡 توضیح: -- در پایتون، حلقه‌های `for` از حوزه (*scope*) فعلی که در آن قرار دارند استفاده می‌کنند و متغیرهای تعریف‌شده در حلقه حتی بعد از اتمام حلقه نیز باقی می‌مانند. این قاعده حتی در مواردی که متغیر حلقه پیش‌تر در فضای نام سراسری (*global namespace*) تعریف شده باشد نیز صدق می‌کند؛ در چنین حالتی، متغیر موجود مجدداً به مقدار جدید متصل می‌شود. +- در پایتون، حلقه‌های `for` از حوزه (_scope_) فعلی که در آن قرار دارند استفاده می‌کنند و متغیرهای تعریف‌شده در حلقه حتی بعد از اتمام حلقه نیز باقی می‌مانند. این قاعده حتی در مواردی که متغیر حلقه پیش‌تر در فضای نام سراسری (_global namespace_) تعریف شده باشد نیز صدق می‌کند؛ در چنین حالتی، متغیر موجود مجدداً به مقدار جدید متصل می‌شود. -- تفاوت‌های موجود در خروجی مفسرهای Python 2.x و Python 3.x در مثال مربوط به «لیست‌های ادراکی» (*list comprehension*) به دلیل تغییراتی است که در مستند [«تغییرات جدید در Python 3.0»](https://docs.python.org/3/whatsnew/3.0.html) آمده است: +- تفاوت‌های موجود در خروجی مفسرهای Python 2.x و Python 3.x در مثال مربوط به «لیست‌های ادراکی» (_list comprehension_) به دلیل تغییراتی است که در مستند [«تغییرات جدید در Python 3.0»](https://docs.python.org/3/whatsnew/3.0.html) آمده است: - > «لیست‌های ادراکی دیگر فرم نحوی `[... for var in item1, item2, ...]` را پشتیبانی نمی‌کنند و به جای آن باید از `[... for var in (item1, item2, ...)]` استفاده شود. همچنین توجه داشته باشید که لیست‌های ادراکی در Python 3.x معنای متفاوتی دارند: آن‌ها از لحاظ معنایی به بیان ساده‌تر، مشابه یک عبارت تولیدکننده (*generator expression*) درون تابع `list()` هستند و در نتیجه، متغیرهای کنترل حلقه دیگر به فضای نام بیرونی نشت نمی‌کنند.» + > «لیست‌های ادراکی دیگر فرم نحوی `[... for var in item1, item2, ...]` را پشتیبانی نمی‌کنند و به جای آن باید از `[... for var in (item1, item2, ...)]` استفاده شود. همچنین توجه داشته باشید که لیست‌های ادراکی در Python 3.x معنای متفاوتی دارند: آن‌ها از لحاظ معنایی به بیان ساده‌تر، مشابه یک عبارت تولیدکننده (_generator expression_) درون تابع `list()` هستند و در نتیجه، متغیرهای کنترل حلقه دیگر به فضای نام بیرونی نشت نمی‌کنند.» --- ### ◀ مراقب آرگومان‌های تغییرپذیر پیش‌فرض باشید! + ```py @@ -2564,42 +2629,44 @@ def some_func(default_arg=[]): - آرگومان‌های تغییرپذیر پیش‌فرض در توابع پایتون، هر بار که تابع فراخوانی می‌شود مقداردهی نمی‌شوند؛ بلکه مقداردهی آنها تنها یک بار در زمان تعریف تابع انجام می‌شود و مقدار اختصاص‌یافته به آن‌ها به عنوان مقدار پیش‌فرض برای فراخوانی‌های بعدی استفاده خواهد شد. هنگامی که به صراحت مقدار `[]` را به عنوان آرگومان به `some_func` ارسال کردیم، مقدار پیش‌فرض برای متغیر `default_arg` مورد استفاده قرار نگرفت، بنابراین تابع همان‌طور که انتظار داشتیم عمل کرد. - ```py - def some_func(default_arg=[]): - default_arg.append("some_string") - return default_arg - ``` + ```py + def some_func(default_arg=[]): + default_arg.append("some_string") + return default_arg + ``` - **خروجی:** + **خروجی:** - ```py - >>> 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'],) - ``` + ```py + >>> 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` قرار داده و سپس درون تابع بررسی کنیم که آیا مقداری به آن آرگومان ارسال شده است یا خیر. مثال: - ```py - def some_func(default_arg=None): - if default_arg is None: - default_arg = [] - default_arg.append("some_string") - return default_arg - ``` + ```py + def some_func(default_arg=None): + if default_arg is None: + default_arg = [] + default_arg.append("some_string") + return default_arg + ``` --- ### ◀ گرفتن استثناها (Exceptions) + + ```py some_list = [1, 2, 3] try: @@ -2648,7 +2715,7 @@ SyntaxError: invalid syntax **خروجی (Python 2.x):** - ``` + ```text Caught again! list.remove(x): x not in list ``` @@ -2676,7 +2743,7 @@ SyntaxError: invalid syntax **خروجی:** - ``` + ```text Caught again! list.remove(x): x not in list ``` @@ -2684,7 +2751,9 @@ SyntaxError: invalid syntax --- ### ◀ عملوندهای یکسان، داستانی متفاوت! + + 1\. ```py @@ -2721,7 +2790,7 @@ a += [5, 6, 7, 8] #### 💡 توضیح: -- عملگر `a += b` همیشه همانند `a = a + b` رفتار نمی‌کند. کلاس‌ها *ممکن است* عملگرهای *`op=`* را به گونه‌ای متفاوت پیاده‌سازی کنند، و لیست‌ها نیز چنین می‌کنند. +- عملگر `a += b` همیشه همانند `a = a + b` رفتار نمی‌کند. کلاس‌ها _ممکن است_ عملگرهای _`op=`_ را به گونه‌ای متفاوت پیاده‌سازی کنند، و لیست‌ها نیز چنین می‌کنند. - عبارت `a = a + [5,6,7,8]` یک لیست جدید ایجاد می‌کند و مرجع `a` را به این لیست جدید اختصاص می‌دهد، بدون آنکه `b` را تغییر دهد. @@ -2730,7 +2799,9 @@ a += [5, 6, 7, 8] --- ### ◀ تفکیک نام‌ها با نادیده گرفتن حوزه‌ی کلاس + + 1\. ```py @@ -2778,7 +2849,7 @@ class SomeClass: --- -### ◀ گرد کردن به روش بانکدار * +### ◀ گرد کردن به روش بانکدار \* بیایید یک تابع ساده برای به‌دست‌آوردن عنصر میانی یک لیست پیاده‌سازی کنیم: @@ -2831,7 +2902,7 @@ def get_middle(some_list): --- -### ◀ سوزن‌هایی در انبار کاه * +### ◀ سوزن‌هایی در انبار کاه \* @@ -2878,7 +2949,7 @@ tuple() 3\. -``` +```python ten_words_list = [ "some", "very", @@ -2925,7 +2996,7 @@ some_dict = { "key_3": 3 } -some_list = some_list.append(4) +some_list = some_list.append(4) some_dict = some_dict.update({"key_4": 4}) ``` @@ -2968,10 +3039,10 @@ def similar_recursive_func(a): #### 💡 توضیح: - برای مورد ۱، عبارت صحیح برای رفتار مورد انتظار این است: -`x, y = (0, 1) if True else (None, None)` + `x, y = (0, 1) if True else (None, None)` - برای مورد ۲، عبارت صحیح برای رفتار مورد انتظار این است: -اینجا، `t = ('one',)` یا `t = 'one',` (ویرگول از قلم افتاده است). در غیر این صورت مفسر `t` را به عنوان یک `str` در نظر گرفته و به صورت کاراکتر به کاراکتر روی آن پیمایش می‌کند. + اینجا، `t = ('one',)` یا `t = 'one',` (ویرگول از قلم افتاده است). در غیر این صورت مفسر `t` را به عنوان یک `str` در نظر گرفته و به صورت کاراکتر به کاراکتر روی آن پیمایش می‌کند. - علامت `()` یک توکن خاص است و نشان‌دهنده‌ی یک `tuple` خالی است. @@ -2991,10 +3062,10 @@ def similar_recursive_func(a): Traceback (most recent call last): File "", line 1, in AssertionError - + >>> assert (a == b, "Values are not equal") :1: SyntaxWarning: assertion is always true, perhaps remove parentheses? - + >>> assert a == b, "Values are not equal" Traceback (most recent call last): File "", line 1, in @@ -3009,8 +3080,10 @@ def similar_recursive_func(a): --- -### ◀ تقسیم‌ها * +### ◀ تقسیم‌ها \* + + ```py >>> 'a'.split() ['a'] @@ -3031,22 +3104,23 @@ def similar_recursive_func(a): #### 💡 توضیح: - در نگاه اول ممکن است به نظر برسد جداکننده‌ی پیش‌فرض متد `split` یک فاصله‌ی تکی (`' '`) است؛ اما مطابق با [مستندات رسمی](https://docs.python.org/3/library/stdtypes.html#str.split): - > اگر `sep` مشخص نشده یا برابر با `None` باشد، یک الگوریتم متفاوت برای جدا کردن اعمال می‌شود: رشته‌هایی از فاصله‌های متوالی به عنوان یک جداکننده‌ی واحد در نظر گرفته شده و در نتیجه، هیچ رشته‌ی خالی‌ای در ابتدا یا انتهای لیست خروجی قرار نمی‌گیرد، حتی اگر رشته‌ی اولیه دارای فاصله‌های اضافی در ابتدا یا انتها باشد. به همین دلیل، تقسیم یک رشته‌ی خالی یا رشته‌ای که فقط شامل فضای خالی است با جداکننده‌ی `None` باعث بازگشت یک لیست خالی `[]` می‌شود. - > اگر `sep` مشخص شود، جداکننده‌های متوالی در کنار هم قرار نمی‌گیرند و هر جداکننده، یک رشته‌ی خالی جدید ایجاد می‌کند. (مثلاً `'1,,2'.split(',')` مقدار `['1', '', '2']` را برمی‌گرداند.) تقسیم یک رشته‌ی خالی با یک جداکننده‌ی مشخص‌شده نیز باعث بازگشت `['']` می‌شود. + > اگر `sep` مشخص نشده یا برابر با `None` باشد، یک الگوریتم متفاوت برای جدا کردن اعمال می‌شود: رشته‌هایی از فاصله‌های متوالی به عنوان یک جداکننده‌ی واحد در نظر گرفته شده و در نتیجه، هیچ رشته‌ی خالی‌ای در ابتدا یا انتهای لیست خروجی قرار نمی‌گیرد، حتی اگر رشته‌ی اولیه دارای فاصله‌های اضافی در ابتدا یا انتها باشد. به همین دلیل، تقسیم یک رشته‌ی خالی یا رشته‌ای که فقط شامل فضای خالی است با جداکننده‌ی `None` باعث بازگشت یک لیست خالی `[]` می‌شود. + > اگر `sep` مشخص شود، جداکننده‌های متوالی در کنار هم قرار نمی‌گیرند و هر جداکننده، یک رشته‌ی خالی جدید ایجاد می‌کند. (مثلاً `'1,,2'.split(',')` مقدار `['1', '', '2']` را برمی‌گرداند.) تقسیم یک رشته‌ی خالی با یک جداکننده‌ی مشخص‌شده نیز باعث بازگشت `['']` می‌شود. - توجه به اینکه چگونه فضای خالی در ابتدا و انتهای رشته در قطعه‌ی کد زیر مدیریت شده است، این مفهوم را روشن‌تر می‌کند: - ```py - >>> ' a '.split(' ') - ['', 'a', ''] - >>> ' a '.split() - ['a'] - >>> ''.split(' ') - [''] - ``` + ```py + >>> ' a '.split(' ') + ['', 'a', ''] + >>> ' a '.split() + ['a'] + >>> ''.split(' ') + [''] + ``` --- -### ◀ واردسازی‌های عمومی * +### ◀ واردسازی‌های عمومی \* + @@ -3078,38 +3152,38 @@ NameError: name '_another_weird_name_func' is not defined - اغلب توصیه می‌شود از واردسازی عمومی (wildcard imports) استفاده نکنید. اولین دلیل واضح آن این است که در این نوع واردسازی‌ها، اسامی که با زیرخط (`_`) شروع شوند، وارد نمی‌شوند. این مسئله ممکن است در زمان اجرا به خطا منجر شود. - اگر از ساختار `from ... import a, b, c` استفاده کنیم، خطای `NameError` فوق اتفاق نمی‌افتاد. - ```py - >>> from module import some_weird_name_func_, _another_weird_name_func - >>> _another_weird_name_func() - works! - ``` + ```py + >>> from module import some_weird_name_func_, _another_weird_name_func + >>> _another_weird_name_func() + works! + ``` - اگر واقعاً تمایل دارید از واردسازی عمومی استفاده کنید، لازم است فهرستی به نام `__all__` را در ماژول خود تعریف کنید که شامل نام اشیاء عمومی (public) قابل‌دسترس هنگام واردسازی عمومی است. - ```py - __all__ = ['_another_weird_name_func'] + ```py + __all__ = ['_another_weird_name_func'] - def some_weird_name_func_(): - print("works!") + def some_weird_name_func_(): + print("works!") - def _another_weird_name_func(): - print("works!") - ``` + def _another_weird_name_func(): + print("works!") + ``` - **خروجی** + **خروجی** - ```py - >>> _another_weird_name_func() - "works!" - >>> some_weird_name_func_() - Traceback (most recent call last): - File "", line 1, in - NameError: name 'some_weird_name_func_' is not defined - ``` + ```py + >>> _another_weird_name_func() + "works!" + >>> some_weird_name_func_() + Traceback (most recent call last): + File "", line 1, in + NameError: name 'some_weird_name_func_' is not defined + ``` --- -### ◀ همه چیز مرتب شده؟ * +### ◀ همه چیز مرتب شده؟ \* @@ -3151,7 +3225,9 @@ False --- ### ◀ زمان نیمه‌شب وجود ندارد؟ + + ```py from datetime import datetime @@ -3181,6 +3257,7 @@ if noon_time: پیش از پایتون 3.5، مقدار بولی برای شیء `datetime.time` اگر نشان‌دهندهٔ نیمه‌شب به وقت UTC بود، برابر با `False` در نظر گرفته می‌شد. این رفتار در استفاده از دستور `if obj:` برای بررسی تهی بودن شیء یا برابر بودن آن با مقدار "خالی"، ممکن است باعث بروز خطا شود. --- + --- ## بخش: گنجینه‌های پنهان! @@ -3188,7 +3265,9 @@ if noon_time: این بخش شامل چند مورد جالب و کمتر شناخته‌شده درباره‌ی پایتون است که بیشتر مبتدی‌هایی مثل من از آن بی‌خبرند (البته دیگر اینطور نیست). ### ◀ خب پایتون، می‌توانی کاری کنی پرواز کنم؟ + + خب، بفرمایید ```py @@ -3207,6 +3286,7 @@ Sshh... It's a super-secret. --- ### ◀ `goto`، ولی چرا؟ + ```py @@ -3238,7 +3318,9 @@ Freedom! --- ### ◀ خودتان را آماده کنید! + + اگر جزو افرادی هستید که دوست ندارند در پایتون برای مشخص کردن محدوده‌ها از فضای خالی (whitespace) استفاده کنند، می‌توانید با ایمپورت کردن ماژول زیر از آکولاد `{}` به سبک زبان C استفاده کنید: ```py @@ -3265,7 +3347,9 @@ SyntaxError: not a chance --- ### ◀ بیایید با «عمو زبان مهربان برای همیشه» آشنا شویم + + **خروجی (Python 3.x)** ```py @@ -3288,19 +3372,21 @@ True - نقل قولی از PEP-401: > با توجه به اینکه عملگر نابرابری `!=` در پایتون ۳.۰ یک اشتباه وحشتناک و انگشت‌سوز (!) بوده است، عمو زبان مهربان برای همیشه (FLUFL) عملگر الماسی‌شکل `<>` را مجدداً به‌عنوان تنها روش درست برای این منظور بازگردانده است. - + - البته «عمو بَری» چیزهای بیشتری برای گفتن در این PEP داشت؛ می‌توانید آن‌ها را [اینجا](https://www.python.org/dev/peps/pep-0401/) مطالعه کنید. - این قابلیت در محیط تعاملی به خوبی عمل می‌کند، اما در زمان اجرای کد از طریق فایل پایتون، با خطای `SyntaxError` روبرو خواهید شد (برای اطلاعات بیشتر به این [issue](https://github.com/satwikkansal/wtfpython/issues/94) مراجعه کنید). با این حال، می‌توانید کد خود را درون یک `eval` یا `compile` قرار دهید تا این قابلیت فعال شود. - ```py - from __future__ import barry_as_FLUFL - print(eval('"Ruby" <> "Python"')) - ``` + ```py + from __future__ import barry_as_FLUFL + print(eval('"Ruby" <> "Python"')) + ``` --- ### ◀ حتی پایتون هم می‌داند که عشق پیچیده است + + ```py import this ``` @@ -3309,7 +3395,7 @@ import this **خروجی:** -``` +```text The Zen of Python, by Tim Peters Beautiful is better than ugly. @@ -3358,7 +3444,9 @@ True --- ### ◀ بله، این واقعاً وجود دارد! + + **عبارت `else` برای حلقه‌ها.** یک مثال معمول آن می‌تواند چنین باشد: ```py @@ -3405,8 +3493,10 @@ Try block executed successfully... --- -### ◀ عملگر Ellipsis * +### ◀ عملگر Ellipsis \* + + ```py def some_func(): Ellipsis @@ -3431,12 +3521,13 @@ Ellipsis - در پایتون، `Ellipsis` یک شیء درونی (`built-in`) است که به صورت سراسری (`global`) در دسترس است و معادل `...` است. - ```py - >>> ... - Ellipsis - ``` + ```py + >>> ... + Ellipsis + ``` - عملگر `Ellipsis` می‌تواند برای چندین منظور استفاده شود: + - به عنوان یک نگه‌دارنده برای کدی که هنوز نوشته نشده است (مانند دستور `pass`) - در سینتکس برش (`slicing`) برای نمایش برش کامل در ابعاد باقی‌مانده @@ -3468,13 +3559,16 @@ Ellipsis ``` نکته: این روش برای آرایه‌هایی با هر تعداد بُعد کار می‌کند. حتی می‌توانید از برش (`slice`) در بُعد اول و آخر استفاده کرده و ابعاد میانی را نادیده بگیرید (به صورت `n_dimensional_array[first_dim_slice, ..., last_dim_slice]`). + - در [نوع‌دهی (`type hinting`)](https://docs.python.org/3/library/typing.html) برای اشاره به بخشی از نوع (مانند `Callable[..., int]` یا `Tuple[str, ...]`) استفاده می‌شود. - همچنین می‌توانید از `Ellipsis` به عنوان آرگومان پیش‌فرض تابع استفاده کنید (برای مواردی که می‌خواهید میان «آرگومانی ارسال نشده است» و «مقدار `None` ارسال شده است» تمایز قائل شوید). --- ### ◀ بی‌نهایت (`Inpinity`) + + این املای کلمه تعمداً به همین شکل نوشته شده است. لطفاً برای اصلاح آن درخواست (`patch`) ارسال نکنید. **خروجی (پایتون 3.x):** @@ -3495,7 +3589,9 @@ Ellipsis --- ### ◀ بیایید خرابکاری کنیم + + 1\. ```py @@ -3572,12 +3668,15 @@ AttributeError: 'A' object has no attribute '__variable' - همچنین، اگر نام تغییر یافته بیش از ۲۵۵ کاراکتر باشد، برش داده می‌شود. --- + --- ## بخش: ظاهرها فریبنده‌اند! ### ◀ خطوط را رد می‌کند؟ + + **خروجی:** ```py @@ -3648,7 +3747,9 @@ def energy_receive(): --- ### ◀ خب، یک جای کار مشکوک است... + + ```py def square(x): """ @@ -3677,21 +3778,24 @@ def square(x): - نحوۀ برخورد پایتون با تب‌ها به این صورت است: > ابتدا تب‌ها (از چپ به راست) با یک تا هشت فاصله جایگزین می‌شوند به‌طوری که تعداد کل کاراکترها تا انتهای آن جایگزینی، مضربی از هشت باشد <...> + - بنابراین «تب» در آخرین خط تابع `square` با هشت فاصله جایگزین شده و به همین دلیل داخل حلقه قرار می‌گیرد. - پایتون ۳ آنقدر هوشمند هست که چنین مواردی را به‌صورت خودکار با خطا اعلام کند. - **خروجی (Python 3.x):** + **خروجی (Python 3.x):** - ```py - TabError: inconsistent use of tabs and spaces in indentation - ``` + ```py + TabError: inconsistent use of tabs and spaces in indentation + ``` --- + --- ## بخش: متفرقه ### ◀ `+=` سریع‌تر است + ```py @@ -3710,7 +3814,9 @@ def square(x): --- ### ◀ بیایید یک رشته‌ی بزرگ بسازیم! + + ```py def add_string_with_plus(iters): s = "" @@ -3805,12 +3911,14 @@ timeit.timeit('add_string_with_plus(10000)', number=1000, globals=globals()) - وجود راه‌های متعدد برای قالب‌بندی و ایجاد رشته‌های بزرگ تا حدودی در تضاد با [ذِن پایتون](https://www.python.org/dev/peps/pep-0020/) است که می‌گوید: - > «باید یک راه — و ترجیحاً فقط یک راه — واضح برای انجام آن وجود داشته باشد.» + > «باید یک راه — و ترجیحاً فقط یک راه — واضح برای انجام آن وجود داشته باشد.» --- -### ◀ کُند کردن جستجوها در `dict` * +### ◀ کُند کردن جستجوها در `dict` \* + + ```py some_dict = {str(i): 1 for i in range(1_000_000)} another_dict = {str(i): 1 for i in range(1_000_000)} @@ -3844,8 +3952,10 @@ KeyError: 1 - اولین باری که یک دیکشنری (`dict`) با کلیدی غیر از `str` فراخوانی شود، این حالت تغییر می‌کند و جستجوهای بعدی از تابع عمومی استفاده خواهند کرد. - این فرایند برای آن نمونه‌ی خاص از دیکشنری غیرقابل بازگشت است و حتی لازم نیست کلید موردنظر در دیکشنری موجود باشد. به همین دلیل است که حتی تلاش ناموفق برای دسترسی به کلیدی ناموجود نیز باعث ایجاد همین تأثیر (کند شدن جستجو) می‌شود. -### ◀ حجیم کردن دیکشنری نمونه‌ها (`instance dicts`) * +### ◀ حجیم کردن دیکشنری نمونه‌ها (`instance dicts`) \* + + ```py import sys @@ -3907,13 +4017,16 @@ def dict_size(o): - همچنین اگر اندازه‌ی دیکشنری به‌علت اضافه‌شدن کلیدهای جدید تغییر کند (`resize` شود)، اشتراک‌گذاری کلیدها تنها زمانی ادامه می‌یابد که فقط یک دیکشنری در حال استفاده از آن‌ها باشد (این اجازه می‌دهد در متد `__init__` برای اولین نمونه‌ی ساخته‌شده، صفات متعددی تعریف کنید بدون آن‌که اشتراک‌گذاری کلیدها از بین برود). اما اگر چند نمونه همزمان وجود داشته باشند و تغییر اندازه‌ی دیکشنری رخ دهد، قابلیت اشتراک‌گذاری کلیدها برای نمونه‌های بعدی همان کلاس غیرفعال خواهد شد. زیرا CPython دیگر نمی‌تواند مطمئن باشد که آیا نمونه‌های بعدی دقیقاً از مجموعه‌ی یکسانی از صفات استفاده خواهند کرد یا خیر. - نکته‌ای کوچک برای کاهش مصرف حافظه‌ی برنامه: هرگز صفات نمونه‌ها را حذف نکنید و حتماً تمام صفات را در متد `__init__` تعریف و مقداردهی اولیه کنید! -### ◀ موارد جزئی * +### ◀ موارد جزئی \* + + - متد `join()` عملیاتی مربوط به رشته (`str`) است، نه لیست (`list`). (در نگاه اول کمی برخلاف انتظار است.) - **توضیح:** اگر `join()` به‌عنوان متدی روی رشته پیاده‌سازی شود، می‌تواند روی هر شیء قابل پیمایش (`iterable`) از جمله لیست، تاپل و هر نوع تکرارشونده‌ی دیگر کار کند. اگر به‌جای آن روی لیست تعریف می‌شد، باید به‌طور جداگانه برای هر نوع دیگری نیز پیاده‌سازی می‌شد. همچنین منطقی نیست که یک متد مختص رشته روی یک شیء عمومی مانند `list` پیاده شود. + **توضیح:** اگر `join()` به‌عنوان متدی روی رشته پیاده‌سازی شود، می‌تواند روی هر شیء قابل پیمایش (`iterable`) از جمله لیست، تاپل و هر نوع تکرارشونده‌ی دیگر کار کند. اگر به‌جای آن روی لیست تعریف می‌شد، باید به‌طور جداگانه برای هر نوع دیگری نیز پیاده‌سازی می‌شد. همچنین منطقی نیست که یک متد مختص رشته روی یک شیء عمومی مانند `list` پیاده شود. - تعدادی عبارت با ظاهری عجیب اما از نظر معنا صحیح: + - عبارت `[] = ()` از نظر معنایی صحیح است (باز کردن یا `unpack` کردن یک تاپل خالی درون یک لیست خالی). - عبارت `'a'[0][0][0][0][0]` نیز از نظر معنایی صحیح است، زیرا پایتون برخلاف زبان‌هایی که از C منشعب شده‌اند، نوع داده‌ای جداگانه‌ای برای کاراکتر ندارد. بنابراین انتخاب یک کاراکتر از یک رشته، منجر به بازگشت یک رشته‌ی تک‌کاراکتری می‌شود. - عبارات `3 --0-- 5 == 8` و `--5 == 5` هر دو از لحاظ معنایی درست بوده و مقدارشان برابر `True` است. @@ -3936,7 +4049,7 @@ def dict_size(o): - عبارت `++a` به‌شکل `+(+a)` تفسیر می‌شود که معادل `a` است. به‌همین ترتیب، خروجی عبارت `--a` نیز قابل توجیه است. - این [تاپیک در StackOverflow](https://stackoverflow.com/questions/3654830/why-are-there-no-and-operators-in-python) دلایل نبودن عملگرهای افزایش (`++`) و کاهش (`--`) در پایتون را بررسی می‌کند. -- احتمالاً با عملگر Walrus (گراز دریایی) در پایتون آشنا هستید؛ اما تا به حال در مورد *عملگر Space-invader (مهاجم فضایی)* شنیده‌اید؟ +- احتمالاً با عملگر Walrus (گراز دریایی) در پایتون آشنا هستید؛ اما تا به حال در مورد _عملگر Space-invader (مهاجم فضایی)_ شنیده‌اید؟ ```py >>> a = 42 @@ -3947,74 +4060,74 @@ def dict_size(o): از آن به‌عنوان جایگزینی برای عملگر افزایش (increment)، در ترکیب با یک عملگر دیگر استفاده می‌شود. - ```py - >>> a +=+ 1 - >>> a - >>> 44 - ``` +```py +>>> a +=+ 1 +>>> a +>>> 44 +``` - **💡 توضیح:** این شوخی از [توییت Raymond Hettinger](https://twitter.com/raymondh/status/1131103570856632321?lang=en) برگرفته شده است. عملگر «مهاجم فضایی» در واقع همان عبارت بدفرمت‌شده‌ی `a -= (-1)` است که معادل با `a = a - (- 1)` می‌باشد. حالت مشابهی برای عبارت `a += (+ 1)` نیز وجود دارد. +**💡 توضیح:** این شوخی از [توییت Raymond Hettinger](https://twitter.com/raymondh/status/1131103570856632321?lang=en) برگرفته شده است. عملگر «مهاجم فضایی» در واقع همان عبارت بدفرمت‌شده‌ی `a -= (-1)` است که معادل با `a = a - (- 1)` می‌باشد. حالت مشابهی برای عبارت `a += (+ 1)` نیز وجود دارد. - پایتون یک عملگر مستندنشده برای [استلزام معکوس (converse implication)](https://en.wikipedia.org/wiki/Converse_implication) دارد. - ```py - >>> False ** False == True - True - >>> False ** True == False - True - >>> True ** False == True - True - >>> True ** True == True - True - ``` + ```py + >>> False ** False == True + True + >>> False ** True == False + True + >>> True ** False == True + True + >>> True ** True == True + True + ``` - **💡 توضیح:** اگر مقادیر `False` و `True` را به‌ترتیب با اعداد ۰ و ۱ جایگزین کرده و محاسبات را انجام دهید، جدول درستی حاصل، معادل یک عملگر استلزام معکوس خواهد بود. ([منبع](https://github.com/cosmologicon/pywat/blob/master/explanation.md#the-undocumented-converse-implication-operator)) + **💡 توضیح:** اگر مقادیر `False` و `True` را به‌ترتیب با اعداد ۰ و ۱ جایگزین کرده و محاسبات را انجام دهید، جدول درستی حاصل، معادل یک عملگر استلزام معکوس خواهد بود. ([منبع](https://github.com/cosmologicon/pywat/blob/master/explanation.md#the-undocumented-converse-implication-operator)) - حالا که صحبت از عملگرها شد، عملگر `@` نیز برای ضرب ماتریسی در پایتون وجود دارد (نگران نباشید، این بار واقعی است). - ```py - >>> import numpy as np - >>> np.array([2, 2, 2]) @ np.array([7, 8, 8]) - 46 - ``` + ```py + >>> import numpy as np + >>> np.array([2, 2, 2]) @ np.array([7, 8, 8]) + 46 + ``` - **💡 توضیح:** عملگر `@` در پایتون ۳٫۵ با در نظر گرفتن نیازهای جامعه علمی اضافه شد. هر شی‌ای می‌تواند متد جادویی `__matmul__` را بازنویسی کند تا رفتار این عملگر را مشخص نماید. + **💡 توضیح:** عملگر `@` در پایتون ۳٫۵ با در نظر گرفتن نیازهای جامعه علمی اضافه شد. هر شی‌ای می‌تواند متد جادویی `__matmul__` را بازنویسی کند تا رفتار این عملگر را مشخص نماید. - از پایتون ۳٫۸ به بعد می‌توانید از نحو متداول f-string مانند `f'{some_var=}'` برای اشکال‌زدایی سریع استفاده کنید. مثال, - ```py - >>> some_string = "wtfpython" - >>> f'{some_string=}' - "some_string='wtfpython'" - ``` + ```py + >>> some_string = "wtfpython" + >>> f'{some_string=}' + "some_string='wtfpython'" + ``` - پایتون برای ذخیره‌سازی متغیرهای محلی در توابع از ۲ بایت استفاده می‌کند. از نظر تئوری، این به معنای امکان تعریف حداکثر ۶۵۵۳۶ متغیر در یک تابع است. با این حال، پایتون راهکار مفیدی ارائه می‌کند که می‌توان با استفاده از آن بیش از ۲^۱۶ نام متغیر را ذخیره کرد. کد زیر نشان می‌دهد وقتی بیش از ۶۵۵۳۶ متغیر محلی تعریف شود، در پشته (stack) چه اتفاقی رخ می‌دهد (هشدار: این کد تقریباً ۲^۱۸ خط متن چاپ می‌کند، بنابراین آماده باشید!): - ```py - import dis - exec(""" - def f(): - """ + """ - """.join(["X" + str(x) + "=" + str(x) for x in range(65539)])) + ```py + import dis + exec(""" + def f(): + """ + """ + """.join(["X" + str(x) + "=" + str(x) for x in range(65539)])) - f() + f() - print(dis.dis(f)) - ``` + print(dis.dis(f)) + ``` -- چندین رشته (Thread) در پایتون، کدِ *پایتونی* شما را به‌صورت همزمان اجرا نمی‌کنند (بله، درست شنیدید!). شاید به نظر برسد که ایجاد چندین رشته و اجرای همزمان آن‌ها منطقی است، اما به دلیل وجود [قفل مفسر سراسری (GIL)](https://wiki.python.org/moin/GlobalInterpreterLock) در پایتون، تمام کاری که انجام می‌دهید این است که رشته‌هایتان به‌نوبت روی یک هسته اجرا می‌شوند. رشته‌ها در پایتون برای وظایفی مناسب هستند که عملیات I/O دارند، اما برای رسیدن به موازی‌سازی واقعی در وظایف پردازشی سنگین (CPU-bound)، بهتر است از ماژول [multiprocessing](https://docs.python.org/3/library/multiprocessing.html) در پایتون استفاده کنید. +- چندین رشته (Thread) در پایتون، کدِ _پایتونی_ شما را به‌صورت همزمان اجرا نمی‌کنند (بله، درست شنیدید!). شاید به نظر برسد که ایجاد چندین رشته و اجرای همزمان آن‌ها منطقی است، اما به دلیل وجود [قفل مفسر سراسری (GIL)](https://wiki.python.org/moin/GlobalInterpreterLock) در پایتون، تمام کاری که انجام می‌دهید این است که رشته‌هایتان به‌نوبت روی یک هسته اجرا می‌شوند. رشته‌ها در پایتون برای وظایفی مناسب هستند که عملیات I/O دارند، اما برای رسیدن به موازی‌سازی واقعی در وظایف پردازشی سنگین (CPU-bound)، بهتر است از ماژول [multiprocessing](https://docs.python.org/3/library/multiprocessing.html) در پایتون استفاده کنید. - گاهی اوقات، متد `print` ممکن است مقادیر را فوراً چاپ نکند. برای مثال، - ```py - # File some_file.py - import time - - print("wtfpython", end="_") - time.sleep(3) - ``` + ```py + # File some_file.py + import time - این کد عبارت `wtfpython` را به دلیل آرگومان `end` پس از ۳ ثانیه چاپ می‌کند؛ چرا که بافر خروجی تنها پس از رسیدن به کاراکتر `\n` یا در زمان اتمام اجرای برنامه تخلیه می‌شود. برای تخلیه‌ی اجباری بافر می‌توانید از آرگومان `flush=True` استفاده کنید. + print("wtfpython", end="_") + time.sleep(3) + ``` + + این کد عبارت `wtfpython` را به دلیل آرگومان `end` پس از ۳ ثانیه چاپ می‌کند؛ چرا که بافر خروجی تنها پس از رسیدن به کاراکتر `\n` یا در زمان اتمام اجرای برنامه تخلیه می‌شود. برای تخلیه‌ی اجباری بافر می‌توانید از آرگومان `flush=True` استفاده کنید. - برش لیست‌ها (List slicing) با اندیس‌های خارج از محدوده، خطایی ایجاد نمی‌کند. @@ -4026,27 +4139,27 @@ def dict_size(o): - برش زدن (slicing) یک شئ قابل پیمایش (iterable) همیشه یک شئ جدید ایجاد نمی‌کند. به‌عنوان مثال، - ```py - >>> some_str = "wtfpython" - >>> some_list = ['w', 't', 'f', 'p', 'y', 't', 'h', 'o', 'n'] - >>> some_list is some_list[:] # انتظار می‌رود False باشد چون یک شیء جدید ایجاد شده است. - False - >>> some_str is some_str[:] # True چون رشته‌ها تغییرناپذیر هستند، بنابراین ساختن یک شیء جدید فایده‌ای ندارد. - True - ``` + ```py + >>> some_str = "wtfpython" + >>> some_list = ['w', 't', 'f', 'p', 'y', 't', 'h', 'o', 'n'] + >>> some_list is some_list[:] # انتظار می‌رود False باشد چون یک شیء جدید ایجاد شده است. + False + >>> some_str is some_str[:] # True چون رشته‌ها تغییرناپذیر هستند، بنابراین ساختن یک شیء جدید فایده‌ای ندارد. + True + ``` - در پایتون ۳، فراخوانی `int('١٢٣٤٥٦٧٨٩')` مقدار `123456789` را برمی‌گرداند. در پایتون، نویسه‌های ده‌دهی (Decimal characters) شامل تمام ارقامی هستند که می‌توانند برای تشکیل اعداد در مبنای ده استفاده شوند؛ به‌عنوان مثال نویسه‌ی U+0660 که همان رقم صفر عربی-هندی است. [اینجا](https://chris.improbable.org/2014/8/25/adventures-in-unicode-digits/) داستان جالبی درباره این رفتار پایتون آمده است. - از پایتون ۳ به بعد، می‌توانید برای افزایش خوانایی، اعداد را با استفاده از زیرخط (`_`) جدا کنید. - ```py - >>> six_million = 6_000_000 - >>> six_million - 6000000 - >>> hex_address = 0xF00D_CAFE - >>> hex_address - 4027435774 - ``` + ```py + >>> six_million = 6_000_000 + >>> six_million + 6000000 + >>> hex_address = 0xF00D_CAFE + >>> hex_address + 4027435774 + ``` - عبارت `'abc'.count('') == 4` مقدار `True` برمی‌گرداند. در اینجا یک پیاده‌سازی تقریبی از متد `count` آورده شده که این موضوع را شفاف‌تر می‌کند: @@ -4058,9 +4171,10 @@ def dict_size(o): return result ``` - این رفتار به این دلیل است که زیررشته‌ی خالی (`''`) با برش‌هایی (slices) به طول صفر در رشته‌ی اصلی مطابقت پیدا می‌کند. +این رفتار به این دلیل است که زیررشته‌ی خالی (`''`) با برش‌هایی (slices) به طول صفر در رشته‌ی اصلی مطابقت پیدا می‌کند. --- + --- # مشارکت @@ -4112,4 +4226,4 @@ def dict_size(o): من چند درخواست برای نسخه PDF (و epub) کتاب wtfpython دریافت کرده‌ام. برای دریافت این نسخه‌ها به محض آماده شدن، می‌توانید اطلاعات خود را [اینجا](https://form.jotform.com/221593245656057) وارد کنید. -**همین بود دوستان!** برای دریافت مطالب آینده مشابه این، می‌توانید ایمیل خود را [اینجا](https://form.jotform.com/221593598380062) اضافه کنید. +**همین بود دوستان!** برای دریافت مطالب آینده مشابه این، می‌توانید ایمیل خود را [اینجا](https://form.jotform.com/221593598380062) اضافه کنید.