diff --git a/README.md b/README.md index d6b6e17..e1114cc 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,4 @@ +

@@ -8,7 +9,7 @@

What the f*ck Python! 😱

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) @@ -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 new file mode 100644 index 0000000..cddeb0b --- /dev/null +++ b/translations/fa-farsi/README.md @@ -0,0 +1,4229 @@ + + + +

+ + + + Shows a wtfpython logo. + +

+

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) + +پایتون، یه زبان زیبا طراحی شده، سطح بالا و مبتنی بر مفسره که قابلیت‌های بسیاری برای راحتی ما برنامه‌نویس‌ها فراهم می‌کنه. +ولی گاهی اوقات قطعه‌کدهایی رو می‌بینیم که تو نگاه اول خروجی‌هاشون واضح نیست. + +این یه پروژه باحاله که سعی داریم توش توضیح بدیم که پشت پرده یه سری قطعه‌کدهای غیرشهودی و قابلیت‌های کمتر شناخته شده پایتون +چه خبره. + +درحالی که بعضی از مثال‌هایی که قراره تو این سند ببینید واقعا عجیب و غریب نیستند ولی بخش‌های جالبی از پایتون رو ظاهر می‌کنند که +ممکنه شما از وجودشون بی‌خبر باشید. به نظرم این شیوه جالبیه برای یادگیری جزئیات داخلی یه زبان برنامه نویسی و باور دارم که +برای شما هم جالب خواهد بود. + +اگه شما یه پایتون کار سابقه‌دار هستید، می‌تونید از این فرصت به عنوان یه چالش برای خودتون استفاده کنید تا بیشتر مثال‌ها رو +تو تلاش اول حدس بزنید. ممکنه شما بعضی از این مثال‌ها رو قبلا تجربه کرده باشید و من خاطراتشون رو در این سند براتون زنده +کرده باشم! :sweat_smile: + +پ.ن: اگه شما قبلا این سند رو خوندید، می‌تونید تغییرات جدید رو در بخش انتشار (فعلا در [اینجا](https://github.com/satwikkansal/wtfpython/releases/)) مطالعه کنید +(مثال‌هایی که کنارشون علامت ستاره دارند، در آخرین ویرایش اضافه شده‌اند). + +پس، بزن بریم... + +# فهرست مطالب + + + + + +- [فهرست مطالب](#فهرست-مطالب) +- [ساختار مثال‌ها](#ساختار-مثالها) +- [استفاده](#استفاده) +- [👀 مثال‌ها](#-مثالها) + - [بخش: ذهن خود را به چالش بکشید!](#بخش-ذهن-خود-را-به-چالش-بکشید) + - [◀ اول از همه! \*](#-اول-از-همه-) + - [💡 توضیح](#-توضیح) + - [◀ بعضی وقت‌ها رشته‌ها می‌توانند دردسرساز شوند](#-بعضی-وقتها-رشتهها-میتوانند-دردسرساز-شوند) + - [💡 توضیح:](#-توضیح-1) + - [◀ مراقب عملیات‌های زنجیره‌ای باشید](#-مراقب-عملیاتهای-زنجیرهای-باشید) + - [💡 توضیح:](#-توضیح-2) + - [◀ چطور از عملگر `is` استفاده نکنیم](#-چطور-از-عملگر-is-استفاده-نکنیم) + - [💡 توضیح:](#-توضیح-3) + - [◀ کلیدهای هش](#-کلیدهای-هش) + - [💡 توضیح](#-توضیح-4) + - [◀ در عمق وجود همه ما یکسان هستیم](#-در-عمق-وجود-همه-ما-یکسان-هستیم) + - [💡 توضیح:](#-توضیح-5) + - [◀ بی‌نظمی در خود نظم \*](#-بینظمی-در-خود-نظم-) + - [💡 توضیح:](#-توضیح-6) + - [💡 توضیح:](#-توضیح-7) + - [◀ برای چی؟](#-برای-چی) + - [💡 توضیح:](#-توضیح-8) + - [◀ اختلاف زمانی در محاسبه](#-اختلاف-زمانی-در-محاسبه) + - [💡 توضیح](#-توضیح-9) + - [◀ هر گردی، گردو نیست](#-هر-گردی-گردو-نیست) + - [💡 توضیح](#-توضیح-10) + - [◀ یک بازی دوز که توش X همون اول برنده میشه!](#-یک-بازی-دوز-که-توش-x-همون-اول-برنده-میشه) + - [💡 توضیح:](#-توضیح-11) + - [◀ متغیر شرودینگر \*](#-متغیر-شرودینگر-) + - [💡 توضیح:](#-توضیح-12) + - [◀ اول مرغ بوده یا تخم مرغ؟ \*](#-اول-مرغ-بوده-یا-تخم-مرغ-) + - [💡 توضیح](#-توضیح-13) + - [◀ روابط بین زیرمجموعه کلاس‌ها](#-روابط-بین-زیرمجموعه-کلاسها) + - [💡 توضیح:](#-توضیح-14) + - [◀ برابری و هویت متدها](#-برابری-و-هویت-متدها) + - [💡 توضیح](#-توضیح-15) + - [◀ آل-ترو-یشن \*](#-آل-ترو-یشن-) + - [💡 توضیحات:](#-توضیحات) + - [💡 توضیح:](#-توضیح-16) + - [◀ رشته‌ها و بک‌اسلش‌ها](#-رشتهها-و-بکاسلشها) + - [💡 توضیح:](#-توضیح-17) + - [◀ گره نیست، نَه!](#-گره-نیست-نَه) + - [💡 توضیح:](#-توضیح-18) + - [◀ رشته‌های نیمه سه‌نقل‌قولی](#-رشتههای-نیمه-سهنقلقولی) + - [💡 توضیح:](#-توضیح-19) + - [◀ مشکل بولین ها چیست؟](#-مشکل-بولین-ها-چیست) + - [💡 توضیح:](#-توضیح-20) + - [◀ متغیرهای کلاس و متغیرهای نمونه](#-متغیرهای-کلاس-و-متغیرهای-نمونه) + - [💡 توضیح:](#-توضیح-21) + - [◀ واگذار کردن None](#-واگذار-کردن-none) + - [💡 توضیح:](#-توضیح-22) + - [◀ بازگرداندن با استفاده از `yield from`!](#-بازگرداندن-با-استفاده-از-yield-from) + - [💡 توضیح:](#-توضیح-23) + - [◀ بازتاب‌ناپذیری \*](#-بازتابناپذیری-) + - [💡 توضیح:](#-توضیح-24) + - [◀ تغییر دادن اشیای تغییرناپذیر!](#-تغییر-دادن-اشیای-تغییرناپذیر) + - [💡 توضیح:](#-توضیح-25) + - [◀ متغیری که از اسکوپ بیرونی ناپدید می‌شود](#-متغیری-که-از-اسکوپ-بیرونی-ناپدید-میشود) + - [💡 توضیح:](#-توضیح-26) + - [◀ تبدیل اسرارآمیز نوع کلید](#-تبدیل-اسرارآمیز-نوع-کلید) + - [💡 توضیح:](#-توضیح-27) + - [◀ ببینیم می‌توانید این را حدس بزنید؟](#-ببینیم-میتوانید-این-را-حدس-بزنید) + - [💡 توضیح:](#-توضیح-28) + - [◀ از حد مجاز برای تبدیل رشته به عدد صحیح فراتر می‌رود](#-از-حد-مجاز-برای-تبدیل-رشته-به-عدد-صحیح-فراتر-میرود) + - [💡 توضیح:](#-توضیح-29) + - [بخش: شیب‌های لغزنده](#بخش-شیبهای-لغزنده) + - [◀ تغییر یک دیکشنری هنگام پیمایش روی آن](#-تغییر-یک-دیکشنری-هنگام-پیمایش-روی-آن) + - [💡 توضیح:](#-توضیح-30) + - [◀ عملیات سرسختانه‌ی `del`](#-عملیات-سرسختانهی-del) + - [💡 توضیح:](#-توضیح-31) + - [◀ متغیری که از حوزه خارج است](#-متغیری-که-از-حوزه-خارج-است) + - [💡 توضیح:](#-توضیح-32) + - [◀ حذف المان‌های لیست در حین پیمایش](#-حذف-المانهای-لیست-در-حین-پیمایش) + - [💡 توضیح:](#-توضیح-33) + - [◀ زیپِ دارای اتلاف برای پیمایشگرها \*](#-زیپِ-دارای-اتلاف-برای-پیمایشگرها-) + - [💡 توضیح:](#-توضیح-34) + - [◀ نشت کردن متغیرهای حلقه!](#-نشت-کردن-متغیرهای-حلقه) + - [💡 توضیح:](#-توضیح-35) + - [◀ مراقب آرگومان‌های تغییرپذیر پیش‌فرض باشید!](#-مراقب-آرگومانهای-تغییرپذیر-پیشفرض-باشید) + - [💡 توضیح:](#-توضیح-36) + - [◀ گرفتن استثناها (Exceptions)](#-گرفتن-استثناها-exceptions) + - [💡 توضیح](#-توضیح-37) + - [◀ عملوندهای یکسان، داستانی متفاوت!](#-عملوندهای-یکسان-داستانی-متفاوت) + - [💡 توضیح:](#-توضیح-38) + - [◀ تفکیک نام‌ها با نادیده گرفتن حوزه‌ی کلاس](#-تفکیک-نامها-با-نادیده-گرفتن-حوزهی-کلاس) + - [💡 توضیح](#-توضیح-39) + - [◀ گرد کردن به روش بانکدار \*](#-گرد-کردن-به-روش-بانکدار-) + - [💡 توضیح:](#-توضیح-40) + - [◀ سوزن‌هایی در انبار کاه \*](#-سوزنهایی-در-انبار-کاه-) + - [💡 توضیح:](#-توضیح-41) + - [◀ تقسیم‌ها \*](#-تقسیمها-) + - [💡 توضیح:](#-توضیح-42) + - [◀ واردسازی‌های عمومی \*](#-واردسازیهای-عمومی-) + - [💡 توضیح:](#-توضیح-43) + - [◀ همه چیز مرتب شده؟ \*](#-همه-چیز-مرتب-شده-) + - [💡 توضیح:](#-توضیح-44) + - [◀ زمان نیمه‌شب وجود ندارد؟](#-زمان-نیمهشب-وجود-ندارد) + - [💡 توضیح:](#-توضیح-45) + - [بخش: گنجینه‌های پنهان!](#بخش-گنجینههای-پنهان) + - [◀ خب پایتون، می‌توانی کاری کنی پرواز کنم؟](#-خب-پایتون-میتوانی-کاری-کنی-پرواز-کنم) + - [💡 توضیح:](#-توضیح-46) + - [◀ `goto`، ولی چرا؟](#-goto-ولی-چرا) + - [💡 توضیح:](#-توضیح-47) + - [◀ خودتان را آماده کنید!](#-خودتان-را-آماده-کنید) + - [💡 توضیح:](#-توضیح-48) + - [◀ بیایید با «عمو زبان مهربان برای همیشه» آشنا شویم](#-بیایید-با-عمو-زبان-مهربان-برای-همیشه-آشنا-شویم) + - [💡 توضیح:](#-توضیح-49) + - [◀ حتی پایتون هم می‌داند که عشق پیچیده است](#-حتی-پایتون-هم-میداند-که-عشق-پیچیده-است) + - [💡 توضیح:](#-توضیح-50) + - [◀ بله، این واقعاً وجود دارد!](#-بله-این-واقعاً-وجود-دارد) + - [💡 توضیح:](#-توضیح-51) + - [◀ عملگر Ellipsis \*](#-عملگر-ellipsis-) + - [💡توضیح](#توضیح) + - [◀ بی‌نهایت (`Inpinity`)](#-بینهایت-inpinity) + - [💡 توضیح:](#-توضیح-52) + - [◀ بیایید خرابکاری کنیم](#-بیایید-خرابکاری-کنیم) + - [💡 توضیح:](#-توضیح-53) + - [بخش: ظاهرها فریبنده‌اند!](#بخش-ظاهرها-فریبندهاند) + - [◀ خطوط را رد می‌کند؟](#-خطوط-را-رد-میکند) + - [💡 توضیح](#-توضیح-54) + - [◀ تله‌پورت کردن](#-تلهپورت-کردن) + - [💡 توضیح:](#-توضیح-55) + - [◀ خب، یک جای کار مشکوک است...](#-خب-یک-جای-کار-مشکوک-است) + - [💡 توضیح](#-توضیح-56) + - [بخش: متفرقه](#بخش-متفرقه) + - [◀ `+=` سریع‌تر است](#--سریعتر-است) + - [💡 توضیح:](#-توضیح-57) + - [◀ بیایید یک رشته‌ی بزرگ بسازیم!](#-بیایید-یک-رشتهی-بزرگ-بسازیم) + - [💡 توضیح](#-توضیح-58) + - [◀ کُند کردن جستجوها در `dict` \*](#-کُند-کردن-جستجوها-در-dict-) + - [💡 توضیح:](#-توضیح-59) + - [◀ حجیم کردن دیکشنری نمونه‌ها (`instance dicts`) \*](#-حجیم-کردن-دیکشنری-نمونهها-instance-dicts-) + - [💡 توضیح:](#-توضیح-60) + - [◀ موارد جزئی \*](#-موارد-جزئی-) +- [مشارکت](#مشارکت) +- [تقدیر و تشکر](#تقدیر-و-تشکر) - [چند لینک جالب!](#چند-لینک-جالب) +- [🎓 مجوز](#-مجوز) + - [دوستانتان را هم شگفت‌زده کنید!](#دوستانتان-را-هم-شگفتزده-کنید) + - [آیا به یک نسخه pdf نیاز دارید؟](#آیا-به-یک-نسخه-pdf-نیاز-دارید) + + + +# ساختار مثال‌ها + +همه مثال‌ها به صورت زیر ساخته می‌شوند: + +> ### ◀ یه اسم خوشگل +> +> ```py +> # راه اندازی کد +> # آماده سازی برای جادو... +> ``` +> +> **خروجی (نسخه(های) پایتون):** +> +> ```py +> >>> triggering_statement +> یه خروجی غیرمنتظره +> ``` +> +> (دلخواه): توضیح یک‌خطی خروجی غیرمنتظره +> +> #### 💡 توضیح: +> +> - توضیح کوتاه درمورد این‌که چی داره اتفاق میافته و چرا. +> +> ```py +> # راه اندازی کد +> # مثال‌های بیشتر برای شفاف سازی (در صورت نیاز) +> ``` +> +> **خروجی (نسخه(های) پایتون):** +> +> ```py +> >>> trigger # یک مثال که رونمایی از جادو رو راحت‌تر می‌کنه +> # یک خروجی توجیه شده و واضح +> ``` + +**توجه:** همه مثال‌ها در برنامه مفسر تعاملی پایتون نسخه +۳.۵.۲ آزمایش شده‌اند و باید در همه نسخه‌های پایتون کار +کنند مگراینکه به صورت جداگانه و به طور واضح نسخه مخصوص +پایتون قبل از خروجی ذکر شده باشد. + +# استفاده + +یه راه خوب برای بیشتر بهره بردن، به نظرم، اینه که مثال‌ها رو به ترتیب متوالی بخونید و برای هر مثال: + +- کد ابتدایی برای راه اندازی مثال رو با دقت بخونید. اگه شما یه پایتون کار سابقه‌دار باشید، با موفقیت بیشتر اوقات اتفاق بعدی رو پیش‌بینی می‌کنید. +- قطعه خروجی رو بخونید و + - بررسی کنید که آیا خروجی‌ها همونطور که انتظار دارید هستند. + - مطمئین بشید که دقیقا دلیل اینکه خروجی اون طوری هست رو می‌دونید. + - اگه نمی‌دونید (که کاملا عادیه و اصلا بد نیست)، یک نفس عمیق بکشید و توضیحات رو بخونید (و اگه نفهمیدید، داد بزنید! و [اینجا](https://github.com/emargi/wtfpython/issues/new) درموردش حرف بزنید). + - اگه می‌دونید، به افتخار خودتون یه دست محکم بزنید و برید سراغ مثال بعدی. + +--- + +# 👀 مثال‌ها + +## بخش: ذهن خود را به چالش بکشید! + +### ◀ اول از همه! \* + + + + +به دلایلی، عملگر "Walrus" (`:=`) که در نسخه ۳.۸ پایتون معرفی شد، خیلی محبوب شده. بیاید بررسیش کنیم. + +1\. + +```py +# Python version 3.8+ + +>>> a = "wtf_walrus" +>>> a +'wtf_walrus' + +>>> a := "wtf_walrus" +File "", line 1 + a := "wtf_walrus" + ^ +SyntaxError: invalid syntax + +>>> (a := "wtf_walrus") # ولی این کار می‌کنه +'wtf_walrus' +>>> a +'wtf_walrus' +``` + +2 \. + +```py +# Python version 3.8+ + +>>> a = 6, 9 +>>> a +(6, 9) + +>>> (a := 6, 9) +(6, 9) +>>> a +6 + +>>> a, b = 6, 9 # باز کردن معمولی +>>> a, b +(6, 9) +>>> (a, b = 16, 19) # آخ آخ + File "", line 1 + (a, b = 16, 19) + ^ +SyntaxError: invalid syntax + +>>> (a, b := 16, 19) # این یه تاپل ۳تایی چاپ می‌کنه رو صفحه +(6, 16, 19) + +>>> a # هنوز تغییر نکرده؟ +6 + +>>> b +16 +``` + +#### 💡 توضیح + +**مرور سریع بر عملگر Walrus** + +عملگر Walrus همونطور که اشاره شد، در نسخه ۳.۸ پایتون معرفی +شد. این عملگر می‌تونه تو موقعیت‌هایی کاربردی باشه که شما می‌خواید داخل یه عبارت، مقادیری رو به متغیرها اختصاص بدید. + +```py +def some_func(): + # فرض کنید اینجا یک سری محاسبه سنگین انجام میشه + # time.sleep(1000) + return 5 + +# پس به جای اینکه این کارو بکنید: +if some_func(): + print(some_func()) # که خیلی راه نادرستیه چون محاسبه دوبار انجام میشه + +# یا حتی این کارو کنید (که کار بدی هم نیست) +a = some_func() +if a: + print(a) + +# می‌تونید از این به بعد به طور مختصر بنویسید: +if a := some_func(): + print(a) + +``` + +**خروجی (+۳.۸):** + +```py +5 +5 +5 +``` + +این باعث میشه که یک خط کمتر کد بزنیم و از دوبار فراخوندن `some_func` جلوگیری کرد. + +- "عبارت اختصاص‌دادن مقدار" بدون پرانتز (نحوه استفاده عملگر Walrus)، در سطح بالا محدود است، `SyntaxError` در عبارت `a := "wtf_walrus"` در قطعه‌کد اول به همین دلیل است. قرار دادن آن داخل پرانتز، همانطور که می‌خواستیم کار کرد و مقدار را به `a` اختصاص داد. + +- به طور معمول، قرار دادن عبارتی که دارای `=` است داخل پرانتز مجاز نیست. به همین دلیل ‍عبارت `(a, b = 6, 9)` به ما خطای سینتکس داد. + +- قائده استفاده از عملگر Walrus به صورت `NAME:= expr` است، به طوری که `NAME` یک شناسه صحیح و `expr` یک عبارت صحیح است. به همین دلیل باز و بسته کردن با تکرار (iterable) پشتیبانی نمی‌شوند. پس، + + - عبارت `(a := 6, 9)` معادل عبارت `((a := 6), 9)` و در نهایت `(a, 9)` است. (که مقدار `a` عدد 6 است) + + ```py + >>> (a := 6, 9) == ((a := 6), 9) + True + >>> x = (a := 696, 9) + >>> x + (696, 9) + >>> x[0] is a # هر دو به یک مکان در حافظه دستگاه اشاره می‌کنند + True + ``` + + - به طور مشابه، عبارت `(a, b := 16, 19)` معادل عبارت `(a, (b := 16), 19)` است که چیزی جز یک تاپل ۳تایی نیست. + +--- + +### ◀ بعضی وقت‌ها رشته‌ها می‌توانند دردسرساز شوند + + + +1\. + +```py +>>> a = "some_string" +>>> id(a) +140420665652016 +>>> id("some" + "_" + "string") # دقت کنید که هردو شناسه یکسانند. +140420665652016 +``` + +2\. + +```py +>>> a = "wtf" +>>> b = "wtf" +>>> a is b +True + +>>> a = "wtf!" +>>> b = "wtf!" +>>> a is b +False + +``` + +3\. + +```py +>>> a, b = "wtf!", "wtf!" +>>> a is b # همه‌ی نسخه‌ها به جز 3.7.x +True + +>>> a = "wtf!"; b = "wtf!" +>>> a is b # ممکن است True یا False باشد بسته به جایی که آن را اجرا می‌کنید (python shell / ipython / به‌صورت اسکریپت) +False +``` + +```py +# این بار در فایل some_file.py +a = "wtf!" +b = "wtf!" +print(a is b) + +# موقع اجرای ماژول، True را چاپ می‌کند! +``` + +4\. + +**خروجی (< Python3.7 )** + +```py +>>> 'a' * 20 is 'aaaaaaaaaaaaaaaaaaaa' +True +>>> 'a' * 21 is 'aaaaaaaaaaaaaaaaaaaaa' +False +``` + +منطقیه، نه؟ + +#### 💡 توضیح: + +- در قطعه‌کد اول و دوم، رفتار کد به دلیل یک بهینه سازی در CPython است (به نام داوطلب سازی رشته‌ها) که باعث می‌شود از برخی مقادیر غیرقابل تغییر، به جای مقداردهی مجدد، دوباره استفاده شود. +- بیشتر متغیرهایی که به‌این صورت جایگزین می‌شوند، در حافظه دستگاه به مقدار داوطلب خود اشاره می‌کنند (تا از حافظه کمتری استفاده شود) +- در قطعه‌کدهای بالا، رشته‌ها به‌صورت غیرمستقیم داوطلب می‌شوند. تصمیم اینکه رشته‌ها چه زمانی به صورت غیرمستقیم داوطلب شوند به نحوه پیاده‌سازی و مقداردهی آن‌ها بستگی دارد. برخی قوانین وجود دارند تا بتوانیم داوطلب شدن یا نشدن یک رشته را حدس بزنیم: + - همه رشته‌ها با طول صفر یا یک داوطلب می‌شوند. + - رشته‌ها در زمان کامپایل داوطلب می‌شوند (`'wtf'` داوطلب می‌شود اما `''.join(['w', 't', 'f'])` داوطلب نمی‌شود) + - رشته‌هایی که از حروف ASCII ، اعداد صحیح و آندرلاین تشکیل نشده‌باشند داوطلب نمی‌شود. به همین دلیل `'wtf!'` به خاطر وجود `'!'` داوطلب نشد. پیاده‌سازی این قانون در CPython در [اینجا](https://github.com/python/cpython/blob/3.6/Objects/codeobject.c#L19) قرار دارد. + +

+ + + + 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) این طور تعریف میشه: + + ```bash + for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite] + ``` + + به طوری که `exprlist` یک هدف برای مقداردهیه. این یعنی، معادل عبارت `{exprlist} = {next_value}` **برای هر شیء داخل `testlist` اجرا می‌شود**. + یک مثال جالب برای نشون دادن این تعریف: + + ```py + for i in range(4): + print(i) + i = 10 + ``` + + **خروجی:** + + ```bash + 0 + 1 + 2 + 3 + ``` + + آیا انتظار داشتید که حلقه فقط یک بار اجرا بشه؟ + + **💡 توضیح:** + + - عبارت مقداردهی `i = 10` به خاطر نحوه کار کردن حلقه‌ها، هیچوقت باعث تغییر در تکرار حلقه نمیشه. قبل از شروع هر تکرار، مقدار بعدی که توسط شیء قابل تکرار (که در اینجا `range(4)` است) ارائه میشه، از بسته خارج میشه و به متغیرهای لیست هدف (که در اینجا `i` است) مقداردهی میشه. + +- تابع `enumerate(some_string)`، یک متغیر `i` (که یک شمارنده افزایشی است) و یک حرف از حروف رشته `some_string` رو در هر تکرار برمیگردونه. و بعدش برای کلید `i` (تازه مقداردهی‌شده) در دیکشنری `some_dict`، مقدار اون حرف رو تنظیم می‌کنه. بازشده این حلقه می‌تونه مانند مثال زیر ساده بشه: + + ```py + >>> i, some_dict[i] = (0, 'w') + >>> i, some_dict[i] = (1, 't') + >>> i, some_dict[i] = (2, 'f') + >>> some_dict + ``` + +--- + +### ◀ اختلاف زمانی در محاسبه + + + +1\. + +```py +array = [1, 8, 15] +# یک عبارت تولیدکننده عادی +gen = (x for x in array if array.count(x) > 0) +array = [2, 8, 22] +``` + +**خروجی:** + +```py +>>> print(list(gen)) # پس بقیه مقدارها کجا رفتن؟ +[8] +``` + +2\. + +```py +array_1 = [1,2,3,4] +gen_1 = (x for x in array_1) +array_1 = [1,2,3,4,5] + +array_2 = [1,2,3,4] +gen_2 = (x for x in array_2) +array_2[:] = [1,2,3,4,5] +``` + +**خروجی:** + +```py +>>> print(list(gen_1)) +[1, 2, 3, 4] + +>>> print(list(gen_2)) +[1, 2, 3, 4, 5] +``` + +3\. + +```py +array_3 = [1, 2, 3] +array_4 = [10, 20, 30] +gen = (i + j for i in array_3 for j in array_4) + +array_3 = [4, 5, 6] +array_4 = [400, 500, 600] +``` + +**خروجی:** + +```py +>>> print(list(gen)) +[401, 501, 601, 402, 502, 602, 403, 503, 603] +``` + +#### 💡 توضیح + +- در یک عبارت [تولیدکننده](https://wiki.python.org/moin/Generators)، عبارت بند `in` در هنگام تعریف محاسبه میشه ولی عبارت شرطی در زمان اجرا محاسبه میشه. +- پس قبل از زمان اجرا، `array` دوباره با لیست `[2, 8, 22]` مقداردهی میشه و از آن‌جایی که در مقدار جدید `array`، بین `1`، `8` و `15`، فقط تعداد `8` بزرگتر از `0` است، تولیدکننده فقط مقدار `8` رو برمیگردونه +- تفاوت در مقدار `gen_1` و `gen_2` در بخش دوم به خاطر نحوه مقداردهی دوباره `array_1` و `array_2` است. +- در مورد اول، متغیر `array_1` به شیء جدید `[1,2,3,4,5]` وصله و از اون جایی که عبارت بند `in` در هنگام تعریف محاسبه میشه، `array_1` داخل تولیدکننده هنوز به شیء قدیمی `[1,2,3,4]` (که هنوز حذف نشده) +- در مورد دوم، مقداردهی برشی به `array_2` باعث به‌روز شدن شیء قدیمی این متغیر از `[1,2,3,4]` به `[1,2,3,4,5]` میشه و هر دو متغیر `gen_2` و `array_2` به یک شیء اشاره میکنند که حالا به‌روز شده. +- خیلی‌خب، حالا طبق منطقی که تا الان گفتیم، نباید مقدار `list(gen)` در قطعه‌کد سوم، `[11, 21, 31, 12, 22, 32, 13, 23, 33]` باشه؟ (چون `array_3` و `array_4` قراره درست مثل `array_1` رفتار کنن). دلیل این که چرا (فقط) مقادیر `array_4` به‌روز شدن، توی [PEP-289](https://www.python.org/dev/peps/pep-0289/#the-details) توضیح داده شده. + + > فقط بیرونی‌ترین عبارت حلقه `for` بلافاصله محاسبه میشه و باقی عبارت‌ها به تعویق انداخته میشن تا زمانی که تولیدکننده اجرا بشه. + +--- + +### ◀ هر گردی، گردو نیست + + + +```py +>>> 'something' is not None +True +>>> 'something' is (not None) +False +``` + +#### 💡 توضیح + +- عملگر `is not` یک عملگر باینری واحده و رفتارش متفاوت تر از استفاده `is` و `not` به صورت جداگانه‌ست. +- عملگر `is not` مقدار `False` رو برمیگردونه اگر متغیرها در هردو سمت این عملگر به شیء یکسانی اشاره کنند و درغیر این صورت، مقدار `True` برمیگردونه +- در مثال بالا، عبارت `(not None)` برابره با مقدار `True` از اونجایی که مقدار `None` در زمینه boolean به `False` تبدیل میشه. پس کل عبارت معادل عبارت `'something' is True` میشه. + +--- + +### ◀ یک بازی دوز که توش X همون اول برنده میشه! + + + +```py + +# بیاید یک سطر تشکیل بدیم + +row = [""] * 3 #row i['', '', ''] + +# حالا بیاید تخته بازی رو ایجاد کنیم + +board = [row] * 3 + +``` + +**خروجی:** + +```py +>>> board +[['', '', ''], ['', '', ''], ['', '', '']] +>>> board[0] +['', '', ''] +>>> board[0][0] +'' +>>> board[0][0] = "X" +>>> board +[['X', '', ''], ['X', '', ''], ['X', '', '']] +``` + +ما که سه‌تا `"X"` نذاشتیم. گذاشتیم مگه؟ + +#### 💡 توضیح: + +وقتی متغیر `row` رو تشکیل میدیم، تصویر زیر نشون میده که چه اتفاقی در حافظه دستگاه میافته. + +

+ + + + 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()) # به فراخوانی تابع دقت کنید. + +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` رو برمیگردونند. + +مثال دوم: + +```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/) پیدا میشه. + +--- + +### ◀ برابری و هویت متدها + + + +مثال اول + +```py +class SomeClass: + def method(self): + pass + + @classmethod + def classm(cls): + pass + + @staticmethod + def staticm(): + pass +``` + +**خروجی:** + +```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 +``` + +با دوبار دسترسی به `classm`، یک شیء برابر دریافت می‌کنیم، اما _همان_ شیء نیست؟ بیایید ببینیم +چه اتفاقی برای نمونه‌های `SomeClass` می‌افتد: + +مثال دوم + +```py +o1 = SomeClass() +o2 = SomeClass() +``` + +**خروجی:** + +```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 +``` + +دسترسی به `classm` یا `method` دو بار، اشیایی برابر اما نه _یکسان_ را برای همان نمونه از `SomeClass` ایجاد می‌کند. + +#### 💡 توضیح + +- تابع‌ها [وصاف](https://docs.python.org/3/howto/descriptor.html) هستند. هر زمان که تابعی به عنوان یک ویژگی فراخوانی شود، وصف فعال می‌شود و یک شیء متد ایجاد می‌کند که تابع را به شیء صاحب آن ویژگی "متصل" می‌کند. اگر این متد فراخوانی شود، تابع را با ارسال ضمنی شیء متصل‌شده به عنوان اولین آرگومان صدا می‌زند (به این ترتیب است که `self` را به عنوان اولین آرگومان دریافت می‌کنیم، با وجود اینکه آن را به‌طور صریح ارسال نکرده‌ایم). + +```py +>>> o1.method +> +``` + +- دسترسی به ویژگی چندین بار، هر بار یک شیء متد جدید ایجاد می‌کند! بنابراین عبارت `o1.method is o1.method` هرگز درست (truthy) نیست. با این حال، دسترسی به تابع‌ها به عنوان ویژگی‌های کلاس (و نه نمونه) متد ایجاد نمی‌کند؛ بنابراین عبارت `SomeClass.method is SomeClass.method` درست است. + +```py +>>> SomeClass.method + +``` + +- `classmethod` توابع را به متدهای کلاس تبدیل می‌کند. متدهای کلاس وصاف‌هایی هستند که هنگام دسترسی، یک شیء متد ایجاد می‌کنند که به _کلاس_ (نوع) شیء متصل می‌شود، نه خود شیء. + +```py +>>> o1.classm +> +``` + +- برخلاف توابع، `classmethod`‌ها هنگام دسترسی به عنوان ویژگی‌های کلاس نیز یک شیء متد ایجاد می‌کنند (که در این حالت به خود کلاس متصل می‌شوند، نه نوع آن). بنابراین عبارت `SomeClass.classm is SomeClass.classm` نادرست (falsy) است. + +```py +>>> SomeClass.classm +> +``` + +- یک شیء متد زمانی برابر در نظر گرفته می‌شود که هم تابع‌ها برابر باشند و هم شیءهای متصل‌شده یکسان باشند. بنابراین عبارت `o1.method == o1.method` درست (truthy) است، هرچند که آن‌ها در حافظه شیء یکسانی نیستند. +- `staticmethod` توابع را به یک وصف "بدون عملیات" (no-op) تبدیل می‌کند که تابع را به همان صورت بازمی‌گرداند. هیچ شیء متدی ایجاد نمی‌شود، بنابراین مقایسه با `is` نیز درست (truthy) است. + +```py +>>> o1.staticm + +>>> SomeClass.staticm + +``` + +- ایجاد شیءهای "متد" جدید در هر بار فراخوانی متدهای نمونه و نیاز به اصلاح آرگومان‌ها برای درج `self`، عملکرد را به شدت تحت تأثیر قرار می‌داد. + CPython 3.7 [این مشکل را حل کرد](https://bugs.python.org/issue26110) با معرفی opcodeهای جدیدی که فراخوانی متدها را بدون ایجاد شیء متد موقتی مدیریت می‌کنند. این به شرطی است که تابع دسترسی‌یافته واقعاً فراخوانی شود، بنابراین قطعه‌کدهای اینجا تحت تأثیر قرار نمی‌گیرند و همچنان متد ایجاد می‌کنند :) + +### ◀ آل-ترو-یشن \* + + + +```py +>>> all([True, True, True]) +True +>>> all([True, True, False]) +False + +>>> all([]) +True +>>> all([[]]) +False +>>> all([[[]]]) +True +``` + +چرا این تغییر درست-نادرسته؟ + +#### 💡 توضیحات: + +- پیاده‌سازی تابع `all` معادل است با + +- ```py + def all(iterable): + for element in iterable: + if not element: + return False + return True + ``` + +- `all([])` مقدار `True` را برمی‌گرداند چون iterable خالی است. +- `all([[]])` مقدار `False` را برمی‌گرداند چون آرایه‌ی داده‌شده یک عنصر دارد، یعنی `[]`، و در پایتون، لیست خالی مقدار falsy دارد. +- `all([[[]]])` و نسخه‌های بازگشتی بالاتر همیشه `True` هستند. دلیلش این است که عنصر واحد آرایه‌ی داده‌شده (`[[...]]`) دیگر خالی نیست، و لیست‌هایی که دارای مقدار باشند، truthy در نظر گرفته می‌شوند. + +--- + +### ◀ کاما‌ی شگفت‌انگیز + + + +**خروجی (< 3.6):** + +```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 +``` + +#### 💡 توضیح: + +- کامای انتهایی همیشه در لیست پارامترهای رسمی یک تابع در پایتون قانونی نیست. +- در پایتون، لیست آرگومان‌ها تا حدی با کاماهای ابتدایی و تا حدی با کاماهای انتهایی تعریف می‌شود. این تضاد باعث ایجاد موقعیت‌هایی می‌شود که در آن یک کاما در وسط گیر می‌افتد و هیچ قانونی آن را نمی‌پذیرد. +- **نکته:** مشکل کامای انتهایی در [پایتون ۳.۶ رفع شده است](https://bugs.python.org/issue9232). توضیحات در [این پست](https://bugs.python.org/issue9232#msg248399) به‌طور خلاصه کاربردهای مختلف کاماهای انتهایی در پایتون را بررسی می‌کند. + +--- + +### ◀ رشته‌ها و بک‌اسلش‌ها + + + +**خروجی:** + +```py +>>> print("\"") +" + +>>> print(r"\"") +\" + +>>> print(r"\") +File "", line 1 + print(r"\") + ^ +SyntaxError: EOL while scanning string literal + +>>> r'\'' == "\\'" +True +``` + +#### 💡 توضیح: + +- در یک رشته‌ی معمولی در پایتون، بک‌اسلش برای فرار دادن (escape) نویسه‌هایی استفاده می‌شود که ممکن است معنای خاصی داشته باشند (مانند تک‌نقل‌قول، دوتا‌نقل‌قول، و خودِ بک‌اسلش). + + ```py + >>> "wt\"f" + 'wt"f' + ``` + +- در یک رشته‌ی خام (raw string literal) که با پیشوند `r` مشخص می‌شود، بک‌اسلش‌ها خودشان به همان شکل منتقل می‌شوند، به‌همراه رفتار فرار دادن نویسه‌ی بعدی. + + ```py + >>> r'wt\"f' == 'wt\\"f' + True + >>> print(repr(r'wt\"f')) + 'wt\\"f' + + >>> print("\n") + + >>> print(r"\\n") + '\\n' + ``` + +- در یک رشته‌ی خام (raw string) که با پیشوند `r` مشخص می‌شود، بک‌اسلش‌ها خودشان به همان صورت منتقل می‌شوند، همراه با رفتاری که کاراکتر بعدی را فرار می‌دهد (escape می‌کند). + +--- + +### ◀ گره نیست، نَه! + + + +```py +x = True +y = False +``` + +**خروجی:** + +```py +>>> not x == y +True +>>> x == not y + File "", line 1 + x == not y + ^ +SyntaxError: invalid syntax +``` + +#### 💡 توضیح: + +- تقدم عملگرها بر نحوه‌ی ارزیابی یک عبارت تأثیر می‌گذارد، و در پایتون، عملگر `==` تقدم بالاتری نسبت به عملگر `not` دارد. +- بنابراین عبارت `not x == y` معادل `not (x == y)` است که خودش معادل `not (True == False)` بوده و در نهایت به `True` ارزیابی می‌شود. +- اما `x == not y` یک `SyntaxError` ایجاد می‌کند، چون می‌توان آن را به صورت `(x == not) y` تفسیر کرد، نه آن‌طور که در نگاه اول انتظار می‌رود یعنی `x == (not y)`. +- تجزیه‌گر (parser) انتظار دارد که توکن `not` بخشی از عملگر `not in` باشد (چون هر دو عملگر `==` و `not in` تقدم یکسانی دارند)، اما پس از اینکه توکن `in` بعد از `not` پیدا نمی‌شود، خطای `SyntaxError` صادر می‌شود. + +--- + +### ◀ رشته‌های نیمه سه‌نقل‌قولی + + + +**خروجی:** + +```py +>>> print('wtfpython''') +wtfpython +>>> print("wtfpython""") +wtfpython +>>> # کد های زیر خطای سینکس دارند. +>>> # print('''wtfpython') +>>> # print("""wtfpython") + File "", line 3 + print("""wtfpython") + ^ +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""" + wtf + ``` + +- `'''` و `"""` نیز جداکننده‌های رشته‌ای در پایتون هستند که باعث ایجاد SyntaxError می‌شوند، چون مفسر پایتون هنگام اسکن رشته‌ای که با سه‌نقل‌قول آغاز شده، انتظار یک سه‌نقل‌قول پایانی به‌عنوان جداکننده را دارد. + +--- + +### ◀ مشکل بولین ها چیست؟ + + + +1\. + +‫ یک مثال ساده برای شمردن تعداد مقادیر بولی # اعداد صحیح در یک iterable با انواع داده‌ی مخلوط. + +```py + +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 +``` + +**خروجی:** + +```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!") +``` + +**خروجی (< 3.x):** + +```py +>>> tell_truth() +I have lost faith in truth! +``` + +#### 💡 توضیح: + +- در پایتون، `bool` زیرکلاسی از `int` است + + ```py + >>> issubclass(bool, int) + True + >>> issubclass(int, bool) + False + ``` + +- و بنابراین، `True` و `False` نمونه‌هایی از `int` هستند + + ```py + >>> isinstance(True, int) + True + >>> isinstance(False, int) + True + ``` + +- مقدار عددی `True` برابر با `1` و مقدار عددی `False` برابر با `0` است. + + ```py + >>> int(True) + 1 + >>> int(False) + 0 + ``` + +- این پاسخ در StackOverflow را ببینید: [answer](https://stackoverflow.com/a/8169049/4354153) برای توضیح منطقی پشت این موضوع. + +- در ابتدا، پایتون نوع `bool` نداشت (کاربران از 0 برای false و مقادیر غیر صفر مثل 1 برای true استفاده می‌کردند). `True`، `False` و نوع `bool` در نسخه‌های 2.x اضافه شدند، اما برای سازگاری با نسخه‌های قبلی، `True` و `False` نمی‌توانستند به عنوان ثابت تعریف شوند. آن‌ها فقط متغیرهای توکار (built-in) بودند و امکان تغییر مقدارشان وجود داشت. + +- پایتون ۳ با نسخه‌های قبلی ناسازگار بود، این مشکل سرانجام رفع شد، و بنابراین قطعه‌کد آخر در نسخه‌های Python 3.x کار نخواهد کرد! + +--- + +### ◀ متغیرهای کلاس و متغیرهای نمونه + + + +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 تغییر کرد, اما B.x تغییر نکرد. +(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] +``` + +**خروجی:** + +```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 +``` + +#### 💡 توضیح: + +- متغیرهای کلاس و متغیرهای نمونه‌های کلاس درونی به‌صورت دیکشنری‌هایی از شیء کلاس مدیریت می‌شوند. اگر نام متغیری در دیکشنری کلاس جاری پیدا نشود، کلاس‌های والد برای آن جست‌وجو می‌شوند. +- عملگر `+=` شیء قابل‌تغییر (mutable) را به‌صورت درجا (in-place) تغییر می‌دهد بدون اینکه شیء جدیدی ایجاد کند. بنابراین، تغییر ویژگی یک نمونه بر نمونه‌های دیگر و همچنین ویژگی کلاس تأثیر می‌گذارد. + +--- + +### ◀ واگذار کردن None + + + +```py +some_iterable = ('a', 'b') + +def some_func(val): + return "something" +``` + +**خروجی (<= 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'] +``` + +#### 💡 توضیح: + +- این یک باگ در نحوه‌ی مدیریت `yield` توسط CPython در ژنراتورها و درک لیستی (comprehensions) است. +- منبع و توضیحات را می‌توانید اینجا ببینید: https://stackoverflow.com/questions/32139885/yield-in-list-comprehensions-and-generator-expressions +- گزارش باگ مرتبط: https://bugs.python.org/issue10544 +- از نسخه‌ی ۳.۸ به بعد، پایتون دیگر اجازه‌ی استفاده از `yield` در داخل درک لیستی را نمی‌دهد و خطای `SyntaxError` ایجاد خواهد کرد. + +--- + +### ◀ بازگرداندن با استفاده از `yield from`! + + + +1\. + +```py +def some_func(x): + if x == 3: + return ["wtf"] + else: + yield from range(x) +``` + +**خروجی (> 3.3):** + +```py +>>> list(some_func(3)) +[] +``` + +چی شد که `"wtf"` ناپدید شد؟ آیا به خاطر اثر خاصی از `yield from` است؟ بیایید این موضوع را بررسی کنیم، + +2\. + +```py +def some_func(x): + if x == 3: + return ["wtf"] + else: + for i in range(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 expr` در یک ژنراتور باعث می‌شود که هنگام خروج از ژنراتور، `StopIteration(expr)` ایجاد شود." + +- در حالت `some_func(3)`، استثنای `StopIteration` در ابتدای اجرا به دلیل وجود دستور `return` رخ می‌دهد. این استثنا به‌طور خودکار درون پوشش `list(...)` و حلقه `for` گرفته می‌شود. بنابراین، دو قطعه‌کد بالا منجر به یک لیست خالی می‌شوند. + +- برای اینکه مقدار `["wtf"]` را از ژنراتور `some_func` بگیریم، باید استثنای `StopIteration` را خودمان مدیریت کنیم، + + ```py + try: + next(some_func(3)) + except StopIteration as e: + some_string = e.value + ``` + + ```py + >>> some_string + ["wtf"] + ``` + +--- + +### ◀ بازتاب‌ناپذیری \* + + + +1\. + +```py +a = float('inf') +b = float('nan') +c = float('-iNf') # این رشته‌ها نسبت به حروف بزرگ و کوچک حساس نیستند +d = float('nan') +``` + +**خروجی:** + +```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 # اما nan!=nan +False +>>> 50 / a +0.0 +>>> a / a +nan +>>> 23 + b +nan +``` + +2\. + +```py +>>> x = float('nan') +>>> y = x / x +>>> y is y # برابری هویتی برقرار است +True +>>> y == y #برابری در مورد y برقرار نیست +False +>>> [y] == [y] # اما برابری برای لیستی که شامل y است برقرار می‌شود +True +``` + +#### 💡 توضیح: + +- در اینجا، `'inf'` و `'nan'` رشته‌هایی خاص هستند (نسبت به حروف بزرگ و کوچک حساس نیستند) که وقتی به‌طور صریح به نوع `float` تبدیل شوند، به ترتیب برای نمایش "بی‌نهایت" ریاضی و "عدد نیست" استفاده می‌شوند. + +- از آنجا که طبق استاندارد IEEE، `NaN != NaN`، پایبندی به این قانون فرض بازتاب‌پذیری (reflexivity) یک عنصر در مجموعه‌ها را در پایتون نقض می‌کند؛ یعنی اگر `x` عضوی از مجموعه‌ای مثل `list` باشد، پیاده‌سازی‌هایی مانند مقایسه، بر اساس این فرض هستند که `x == x`. به دلیل همین فرض، ابتدا هویت (identity) دو عنصر مقایسه می‌شود (چون سریع‌تر است) و فقط زمانی مقادیر مقایسه می‌شوند که هویت‌ها متفاوت باشند. قطعه‌کد زیر موضوع را روشن‌تر می‌کند، + + ```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) + ``` + + از آنجا که هویت‌های `x` و `y` متفاوت هستند، مقادیر آن‌ها در نظر گرفته می‌شوند که آن‌ها نیز متفاوت‌اند؛ بنابراین مقایسه این بار `False` را برمی‌گرداند. + +- خواندنی جالب: [بازتاب‌پذیری و دیگر ارکان تمدن](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 +>>> another_tuple[2].append(1000) #This throws no error +>>> another_tuple +([1, 2], [3, 4], [5, 6, 1000]) +>>> another_tuple[2] += [99, 999] +TypeError: 'tuple' object does not support item assignment +>>> another_tuple +([1, 2], [3, 4], [5, 6, 1000, 99, 999]) +``` + +اما من فکر می‌کردم تاپل‌ها تغییرناپذیر هستند... + +#### 💡 توضیح: + +- نقل‌قول از https://docs.python.org/3/reference/datamodel.html + + > دنباله‌های تغییرناپذیر + + ```text + شیئی از نوع دنباله‌ی تغییرناپذیر، پس از ایجاد دیگر قابل تغییر نیست. (اگر شیء شامل ارجاع‌هایی به اشیای دیگر باشد، این اشیای دیگر ممکن است قابل تغییر باشند و تغییر کنند؛ اما مجموعه‌ی اشیایی که مستقیماً توسط یک شیء تغییرناپذیر ارجاع داده می‌شوند، نمی‌تواند تغییر کند.) + ``` + +- عملگر `+=` لیست را به‌صورت درجا (in-place) تغییر می‌دهد. تخصیص به یک عضو کار نمی‌کند، اما زمانی که استثنا ایجاد می‌شود، عضو موردنظر پیش از آن به‌صورت درجا تغییر کرده است. +- همچنین توضیحی در [پرسش‌های متداول رسمی پایتون](https://docs.python.org/3/faq/programming.html#why-does-a-tuple-i-item-raise-an-exception-when-the-addition-works) وجود دارد. + +--- + +### ◀ متغیری که از اسکوپ بیرونی ناپدید می‌شود + + + +```py +e = 7 +try: + raise Exception() +except Exception as e: + pass +``` + +**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) + +هنگامی که یک استثنا (Exception) با استفاده از کلمه‌ی کلیدی `as` به متغیری تخصیص داده شود، این متغیر در انتهای بلاکِ `except` پاک می‌شود. این رفتار مشابه کد زیر است: + +```py +except E as N: + foo +``` + +به این شکل ترجمه شده باشد: + +```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) + + 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):** + + ```py + >>> e + Exception() + >>> print e + # چیزی چاپ نمی شود. + ``` + +--- + +### ◀ تبدیل اسرارآمیز نوع کلید + + + +```py +class SomeClass(str): + pass + +some_dict = {'s': 42} +``` + +**خروجی:** + +```py +>>> type(list(some_dict.keys())[0]) +str +>>> s = SomeClass('s') +>>> some_dict[s] = 40 +>>> some_dict # دو عدد کلید-مقدار توقع می رود. +{'s': 40} +>>> type(list(some_dict.keys())[0]) +str +``` + +#### 💡 توضیح: + +- هر دو شیء `s` و رشته‌ی `"s"` به دلیل ارث‌بری `SomeClass` از متد `__hash__` کلاس `str`، هش یکسانی دارند. +- عبارت `SomeClass("s") == "s"` به دلیل ارث‌بری `SomeClass` از متد `__eq__` کلاس `str` برابر با `True` ارزیابی می‌شود. +- از آنجا که این دو شیء هش یکسان و برابری دارند، به عنوان یک کلید مشترک در دیکشنری در نظر گرفته می‌شوند. +- برای رسیدن به رفتار دلخواه، می‌توانیم متد `__eq__` را در کلاس `SomeClass` بازتعریف کنیم. + + ```py + class SomeClass(str): + def __eq__(self, other): + return ( + type(self) is SomeClass + and type(other) is SomeClass + and super().__eq__(other) + ) + + # هنگامی که متد __eq__ را به‌طور دلخواه تعریف می‌کنیم، پایتون دیگر متد __hash__ را به صورت خودکار به ارث نمی‌برد، + # بنابراین باید متد __hash__ را نیز مجدداً تعریف کنیم. + __hash__ = str.__hash__ + + some_dict = {'s':42} + ``` + + **خروجی:** + + ```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) + ``` + +--- + +### ◀ ببینیم می‌توانید این را حدس بزنید؟ + + + +```py +a, b = a[b] = {}, 5 +``` + +**خروجی:** + +```py +>>> a +{5: ({...}, 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` است). + +- پس از ارزیابی عبارت، نتیجه از **چپ به راست** به اهداف انتساب داده می‌شود. در این مثال ابتدا تاپل `({}, 5)` به `a, b` باز می‌شود، بنابراین `a = {}` و `b = 5` خواهیم داشت. + +- حالا `a` یک شیء قابل تغییر (mutable) است (`{}`). + +- هدف انتساب بعدی `a[b]` است (شاید انتظار داشته باشید که اینجا خطا بگیریم زیرا پیش از این هیچ مقداری برای `a` و `b` مشخص نشده است؛ اما به یاد داشته باشید که در گام قبل به `a` مقدار `{}` و به `b` مقدار `5` دادیم). + +- اکنون، کلید `5` در دیکشنری به تاپل `({}, 5)` مقداردهی می‌شود و یک مرجع دوری (Circular Reference) ایجاد می‌کند (علامت `{...}` در خروجی به همان شیئی اشاره دارد که قبلاً توسط `a` به آن ارجاع داده شده است). یک مثال ساده‌تر از مرجع دوری می‌تواند به این صورت باشد: + + ```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 + ``` + + در مثال ما نیز شرایط مشابه است (`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) + +>>> # Python 3.10.8 +>>> int("2" * 5432) +``` + +**خروجی:** + +```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. +``` + +#### 💡 توضیح: + +فراخوانی تابع `int()` در نسخه‌ی Python 3.10.6 به‌خوبی کار می‌کند اما در نسخه‌ی Python 3.10.8 منجر به خطای `ValueError` می‌شود. توجه کنید که پایتون همچنان قادر به کار با اعداد صحیح بزرگ است. این خطا تنها هنگام تبدیل اعداد صحیح به رشته یا برعکس رخ می‌دهد. + +خوشبختانه می‌توانید در صورت انتظار عبور از این حد مجاز، مقدار آن را افزایش دهید. برای انجام این کار می‌توانید از یکی از روش‌های زیر استفاده کنید: + +- استفاده از فلگ خط فرمان `-X int_max_str_digits` +- تابع `set_int_max_str_digits()` از ماژول `sys` +- متغیر محیطی `PYTHONINTMAXSTRDIGITS` + +برای جزئیات بیشتر درباره‌ی تغییر مقدار پیش‌فرض این حد مجاز، [مستندات رسمی پایتون](https://docs.python.org/3/library/stdtypes.html#int-max-str-digits) را مشاهده کنید. + +--- + +## بخش: شیب‌های لغزنده + +### ◀ تغییر یک دیکشنری هنگام پیمایش روی آن + + + +```py +x = {0: None} + +for i in x: + del x[i] + x[i+1] = None + print(i) +``` + +**خروجی (پایتون 2.7تا پایتون 3.5):** + +```text +0 +1 +2 +3 +4 +5 +6 +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` را دریافت خواهید کرد. + +--- + +### ◀ عملیات سرسختانه‌ی `del` + + + + +```py +class SomeClass: + def __del__(self): + print("Deleted!") +``` + +**خروجی:** +1\. + +```py +>>> x = SomeClass() +>>> y = x +>>> del x # باید این عبارت را چاپ کند "Deleted!" +>>> del y +Deleted! +``` + +«خُب، بالاخره حذف شد.» احتمالاً حدس زده‌اید چه چیزی جلوی فراخوانی `__del__` را در اولین تلاشی که برای حذف `x` داشتیم، گرفته بود. بیایید مثال را پیچیده‌تر کنیم. + +2\. + +```py +>>> x = SomeClass() +>>> y = x +>>> del x +>>> y # بررسی وجود y +<__main__.SomeClass instance at 0x7f98a1a67fc8> +>>> del y # مثل قبل، باید این عبارت را چاپ کند "Deleted!" +>>> globals() # اوه، چاپ نکرد. بیایید مقادیر گلوبال را بررسی کنیم. +Deleted! +{'__builtins__': , 'SomeClass': , '__package__': None, '__name__': '__main__', '__doc__': None} +``` + +«باشه، حالا حذف شد» :confused: + +#### 💡 توضیح: + +- عبارت `del x` مستقیماً باعث فراخوانی `x.__del__()` نمی‌شود. +- وقتی به دستور `del x` می‌رسیم، پایتون نام `x` را از حوزه‌ی فعلی حذف کرده و شمارنده‌ی مراجع شیٔ‌ای که `x` به آن اشاره می‌کرد را یک واحد کاهش می‌دهد. فقط وقتی شمارنده‌ی مراجع شیٔ به صفر برسد، تابع `__del__()` فراخوانی می‌شود. +- در خروجی دوم، متد `__del__()` فراخوانی نشد چون دستور قبلی (`>>> y`) در مفسر تعاملی یک ارجاع دیگر به شیٔ ایجاد کرده بود (به صورت خاص، متغیر جادویی `_` به مقدار آخرین عبارت غیر `None` در REPL اشاره می‌کند). بنابراین مانع از رسیدن شمارنده‌ی مراجع به صفر در هنگام اجرای `del y` شد. +- فراخوانی `globals` (یا هر چیزی که نتیجه‌اش `None` نباشد) باعث می‌شود که `_` به نتیجه‌ی جدید اشاره کند و ارجاع قبلی از بین برود. حالا شمارنده‌ی مراجع به صفر می‌رسد و عبارت «Deleted!» (حذف شد!) نمایش داده می‌شود. + +--- + +### ◀ متغیری که از حوزه خارج است + + + +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() +``` + +**خروجی:** + +```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 +``` + +#### 💡 توضیح: + +- وقتی در محدوده (Scope) یک تابع به متغیری مقداردهی می‌کنید، آن متغیر در همان حوزه محلی تعریف می‌شود. بنابراین `a` در تابع `another_func` تبدیل به متغیر محلی می‌شود، اما پیش‌تر در همان حوزه مقداردهی نشده است، و این باعث خطا می‌شود. +- برای تغییر متغیر سراسری `a` در تابع `another_func`، باید از کلیدواژه‌ی `global` استفاده کنیم. + + ```py + def another_func() + global a + a += 1 + return a + ``` + + **خروجی:** + + ```py + >>> another_func() + 2 + ``` + +- در تابع `another_closure_func`، متغیر `a` در حوزه‌ی `another_inner_func` محلی می‌شود ولی پیش‌تر در آن حوزه مقداردهی نشده است. به همین دلیل خطا می‌دهد. +- برای تغییر متغیر حوزه‌ی بیرونی `a` در `another_inner_func`، باید از کلیدواژه‌ی `nonlocal` استفاده کنیم. دستور `nonlocal` به مفسر می‌گوید که متغیر را در نزدیک‌ترین حوزه‌ی بیرونی (به‌جز حوزه‌ی global) جستجو کند. + + ```py + def another_func(): + a = 1 + def another_inner_func(): + nonlocal a + a += 1 + return a + return another_inner_func() + ``` + + **خروجی:** + + ```py + >>> another_func() + 2 + ``` + +- کلیدواژه‌های `global` و `nonlocal` به مفسر پایتون می‌گویند که متغیر جدیدی را تعریف نکند و به جای آن در حوزه‌های بیرونی (سراسری یا میانجی) آن را بیابد. +- برای مطالعه‌ی بیشتر در مورد نحوه‌ی کار فضای نام‌ها و مکانیزم تعیین حوزه‌ها در پایتون، می‌توانید این [مقاله کوتاه ولی عالی](https://sebastianraschka.com/Articles/2014_python_scope_and_namespaces.html) را بخوانید. + +--- + +### ◀ حذف المان‌های لیست در حین پیمایش + + + +```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) +``` + +**خروجی:** + +```py +>>> list_1 +[1, 2, 3, 4] +>>> list_2 +[2, 4] +>>> list_3 +[] +>>> list_4 +[2, 4] +``` + +می‌توانید حدس بزنید چرا خروجی `[2, 4]` است؟ + +#### 💡 توضیح: + +- هیچ‌وقت ایده‌ی خوبی نیست که شیئی را که روی آن پیمایش می‌کنید تغییر دهید. روش درست این است که روی یک کپی از آن شیء پیمایش کنید؛ در این‌جا `list_3[:]` دقیقاً همین کار را می‌کند. + + ```py + >>> some_list = [1, 2, 3, 4] + >>> id(some_list) + 139798789457608 + >>> id(some_list[:]) # دقت کنید که پایتون برای اسلایس کردن، یک شی جدید میسازد + 139798779601192 + ``` + +**تفاوت بین `del`، `remove` و `pop`:** + +- اینجا، `del var_name` فقط اتصال `var_name` را از فضای نام محلی یا سراسری حذف می‌کند (به همین دلیل است که `list_1` تحت تأثیر قرار نمی‌گیرد). +- متد `remove` اولین مقدار مطابق را حذف می‌کند، نه یک اندیس خاص را؛ اگر مقدار مورد نظر پیدا نشود، خطای `ValueError` ایجاد می‌شود. +- متد `pop` عنصری را در یک اندیس مشخص حذف کرده و آن را برمی‌گرداند؛ اگر اندیس نامعتبری مشخص شود، خطای `IndexError` ایجاد می‌شود. + +**چرا خروجی `[2, 4]` است؟** + +- پیمایش لیست به صورت اندیس به اندیس انجام می‌شود، و هنگامی که عدد `1` را از `list_2` یا `list_4` حذف می‌کنیم، محتوای لیست به `[2, 3, 4]` تغییر می‌کند. در این حالت عناصر باقی‌مانده به سمت چپ جابه‌جا شده و جایگاهشان تغییر می‌کند؛ یعنی عدد `2` در اندیس 0 و عدد `3` در اندیس 1 قرار می‌گیرد. از آنجا که در مرحله بعدی حلقه به سراغ اندیس 1 می‌رود (که اکنون مقدار آن `3` است)، عدد `2` به طور کامل نادیده گرفته می‌شود. این اتفاق مشابه برای هر عنصر یک‌درمیان در طول پیمایش لیست رخ خواهد داد. + +- برای توضیح بیشتر این مثال، این [تاپیک StackOverflow](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 +>>> numbers = list(range(7)) +>>> numbers +[0, 1, 2, 3, 4, 5, 6] +>>> first_three, remaining = numbers[:3], numbers[3:] +>>> first_three, remaining +([0, 1, 2], [3, 4, 5, 6]) +>>> numbers_iter = iter(numbers) +>>> list(zip(numbers_iter, first_three)) +[(0, 0), (1, 1), (2, 2)] +# تاحالا که خوب بوده، حالا روی باقی مانده های زیپ رو امتحان می کنیم. +>>> list(zip(numbers_iter, remaining)) +[(4, 3), (5, 4), (6, 5)] +``` + +عنصر `3` از لیست `numbers` چه شد؟ + +#### 💡 توضیح: + +- بر اساس [مستندات](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) + ``` + +- بنابراین این تابع تعداد دلخواهی از اشیای قابل پیمایش (_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` باید پیمایشگری باشد که کمترین تعداد عنصر را دارد. + +--- + +### ◀ نشت کردن متغیرهای حلقه! + + + +1\. + +```py +for x in range(7): + if x == 6: + print(x, ': for x inside loop') +print(x, ': x in global') +``` + +**خروجی:** + +```py +6 : for x inside loop +6 : x in global +``` + +اما متغیر `x` هرگز خارج از محدوده (scope) حلقه `for` تعریف نشده بود... + +2\. + +```py +# این دفعه، مقدار ایکس را در ابتدا مقداردهی اولیه میکنیم. +x = -1 +for x in range(7): + if x == 6: + print(x, ': for x inside loop') +print(x, ': x in global') +``` + +**خروجی:** + +```py +6 : for x inside loop +6 : x in global +``` + +3\. + +**خروجی (Python 2.x):** + +```py +>>> x = 1 +>>> print([x for x in range(5)]) +[0, 1, 2, 3, 4] +>>> print(x) +4 +``` + +**خروجی (Python 3.x):** + +```py +>>> x = 1 +>>> print([x for x in range(5)]) +[0, 1, 2, 3, 4] +>>> print(x) +1 +``` + +#### 💡 توضیح: + +- در پایتون، حلقه‌های `for` از حوزه (_scope_) فعلی که در آن قرار دارند استفاده می‌کنند و متغیرهای تعریف‌شده در حلقه حتی بعد از اتمام حلقه نیز باقی می‌مانند. این قاعده حتی در مواردی که متغیر حلقه پیش‌تر در فضای نام سراسری (_global namespace_) تعریف شده باشد نیز صدق می‌کند؛ در چنین حالتی، متغیر موجود مجدداً به مقدار جدید متصل می‌شود. + +- تفاوت‌های موجود در خروجی مفسرهای Python 2.x و Python 3.x در مثال مربوط به «لیست‌های ادراکی» (_list comprehension_) به دلیل تغییراتی است که در مستند [«تغییرات جدید در Python 3.0»](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()` هستند و در نتیجه، متغیرهای کنترل حلقه دیگر به فضای نام بیرونی نشت نمی‌کنند.» + +--- + +### ◀ مراقب آرگومان‌های تغییرپذیر پیش‌فرض باشید! + + + +```py +def some_func(default_arg=[]): + default_arg.append("some_string") + return default_arg +``` + +**خروجی:** + +```py +>>> some_func() +['some_string'] +>>> some_func() +['some_string', 'some_string'] +>>> some_func([]) +['some_string'] +>>> some_func() +['some_string', 'some_string', 'some_string'] +``` + +#### 💡 توضیح: + +- آرگومان‌های تغییرپذیر پیش‌فرض در توابع پایتون، هر بار که تابع فراخوانی می‌شود مقداردهی نمی‌شوند؛ بلکه مقداردهی آنها تنها یک بار در زمان تعریف تابع انجام می‌شود و مقدار اختصاص‌یافته به آن‌ها به عنوان مقدار پیش‌فرض برای فراخوانی‌های بعدی استفاده خواهد شد. هنگامی که به صراحت مقدار `[]` را به عنوان آرگومان به `some_func` ارسال کردیم، مقدار پیش‌فرض برای متغیر `default_arg` مورد استفاده قرار نگرفت، بنابراین تابع همان‌طور که انتظار داشتیم عمل کرد. + + ```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'],) + ``` + +- یک روش رایج برای جلوگیری از باگ‌هایی که به دلیل آرگومان‌های تغییرپذیر رخ می‌دهند، این است که مقدار پیش‌فرض را `None` قرار داده و سپس درون تابع بررسی کنیم که آیا مقداری به آن آرگومان ارسال شده است یا خیر. مثال: + + ```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: + # این باید یک `IndexError` ایجاد کند + print(some_list[4]) +except IndexError, ValueError: + print("Caught!") + +try: + # این باید یک `ValueError` ایجاد کند + some_list.remove(4) +except IndexError, ValueError: + print("Caught again!") +``` + +**خروجی (Python 2.x):** + +```py +Caught! + +ValueError: list.remove(x): x not in list +``` + +**خروجی (Python 3.x):** + +```py + File "", line 3 + except IndexError, ValueError: + ^ +SyntaxError: invalid syntax +``` + +#### 💡 توضیح + +- برای افزودن چندین استثنا به عبارت `except`، باید آن‌ها را به صورت یک تاپل پرانتزدار به عنوان آرگومان اول وارد کنید. آرگومان دوم یک نام اختیاری است که در صورت ارائه، نمونهٔ Exception ایجادشده را به آن متصل می‌کند. برای مثال: + + ```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) + ``` + + **خروجی (Python 2.x):** + + ```text + Caught again! + list.remove(x): x not in list + ``` + + **خروجی (Python 3.x):** + + ```py + File "", line 4 + except (IndexError, ValueError), e: + ^ + IndentationError: unindent does not match any outer indentation level + ``` + +- جدا کردن استثنا از متغیر با استفاده از ویرگول منسوخ شده و در پایتون 3 کار نمی‌کند؛ روش صحیح استفاده از `as` است. برای مثال: + + ```py + some_list = [1, 2, 3] + try: + some_list.remove(4) + + except (IndexError, ValueError) as e: + print("Caught again!") + print(e) + ``` + + **خروجی:** + + ```text + Caught again! + list.remove(x): x not in list + ``` + +--- + +### ◀ عملوندهای یکسان، داستانی متفاوت! + + + +1\. + +```py +a = [1, 2, 3, 4] +b = a +a = a + [5, 6, 7, 8] +``` + +**خروجی:** + +```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] +``` + +**خروجی:** + +```py +>>> a +[1, 2, 3, 4, 5, 6, 7, 8] +>>> b +[1, 2, 3, 4, 5, 6, 7, 8] +``` + +#### 💡 توضیح: + +- عملگر `a += b` همیشه همانند `a = a + b` رفتار نمی‌کند. کلاس‌ها _ممکن است_ عملگرهای _`op=`_ را به گونه‌ای متفاوت پیاده‌سازی کنند، و لیست‌ها نیز چنین می‌کنند. + +- عبارت `a = a + [5,6,7,8]` یک لیست جدید ایجاد می‌کند و مرجع `a` را به این لیست جدید اختصاص می‌دهد، بدون آنکه `b` را تغییر دهد. + +- عبارت `a += [5,6,7,8]` در واقع به تابعی معادل «extend» ترجمه می‌شود که روی لیست اصلی عمل می‌کند؛ بنابراین `a` و `b` همچنان به همان لیست اشاره می‌کنند که به‌صورت درجا (in-place) تغییر کرده است. + +--- + +### ◀ تفکیک نام‌ها با نادیده گرفتن حوزه‌ی کلاس + + + +1\. + +```py +x = 5 +class SomeClass: + x = 17 + y = (x for i in range(10)) +``` + +**خروجی:** + +```py +>>> list(SomeClass.y)[0] +5 +``` + +2\. + +```py +x = 5 +class SomeClass: + x = 17 + y = [x for i in range(10)] +``` + +**خروجی (Python 2.x):** + +```py +>>> SomeClass.y[0] +17 +``` + +**خروجی (Python 3.x):** + +```py +>>> SomeClass.y[0] +5 +``` + +#### 💡 توضیح + +- حوزه‌هایی که درون تعریف کلاس تو در تو هستند، نام‌های تعریف‌شده در سطح کلاس را نادیده می‌گیرند. +- عبارت‌های جنراتور (generator expressions) حوزه‌ی مختص به خود دارند. +- از پایتون نسخه‌ی ۳ به بعد، لیست‌های فشرده (list comprehensions) نیز حوزه‌ی مختص به خود دارند. + +--- + +### ◀ گرد کردن به روش بانکدار \* + +بیایید یک تابع ساده برای به‌دست‌آوردن عنصر میانی یک لیست پیاده‌سازی کنیم: + +```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]) # خوب به نظر می رسد. +1 +>>> get_middle([1,2,3]) # خوب به نظر می رسد. +2 +>>> get_middle([1,2,3,4,5]) # چی? +2 +>>> len([1,2,3,4,5]) / 2 # خوبه +2.5 +>>> round(len([1,2,3,4,5]) / 2) # چرا? +2 +``` + +به نظر می‌رسد که پایتون عدد ۲٫۵ را به ۲ گرد کرده است. + +#### 💡 توضیح: + +- این یک خطای مربوط به دقت اعداد اعشاری نیست؛ بلکه این رفتار عمدی است. از پایتون نسخه 3.0 به بعد، تابع `round()` از [گرد کردن بانکی](https://en.wikipedia.org/wiki/Rounding#Rounding_half_to_even) استفاده می‌کند که در آن کسرهای `.5` به نزدیک‌ترین عدد **زوج** گرد می‌شوند: + +```py +>>> round(0.5) +0 +>>> round(1.5) +2 +>>> round(2.5) +2 +>>> import numpy # numpy هم همینکار را می کند. +>>> numpy.round(0.5) +0.0 +>>> numpy.round(1.5) +2.0 +>>> numpy.round(2.5) +2.0 +``` + +- این روشِ پیشنهادی برای گرد کردن کسرهای `.5` مطابق با استاندارد [IEEE 754](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\. + +```py +x, y = (0, 1) if True else None, None +``` + +**خروجی:** + +```py +>>> x, y # چیزی که توقع داریم. (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) +``` + +**خروجی:** + +```py +one +two +o +n +e +tuple() +``` + +3\. + +```python +ten_words_list = [ + "some", + "very", + "big", + "list", + "that" + "consists", + "of", + "exactly", + "ten", + "words" +] +``` + +**خروجی** + +```py +>>> len(ten_words_list) +9 +``` + +4\. عدم تأکید کافی + +```py +a = "python" +b = "javascript" +``` + +**خروجی:** + +```py +# دستور assert همراه با پیام خطای assertion +>>> assert(a == b, "Both languages are different") +# هیچ AssertionError ای رخ نمی‌دهد +``` + +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}) +``` + +**خروجی:** + +```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 +``` + +**خروجی:** + +```py +>>> some_recursive_func([5, 0]) +[0, 0] +>>> similar_recursive_func(5) +4 +``` + +#### 💡 توضیح: + +- برای مورد ۱، عبارت صحیح برای رفتار مورد انتظار این است: + `x, y = (0, 1) if True else (None, None)` + +- برای مورد ۲، عبارت صحیح برای رفتار مورد انتظار این است: + اینجا، `t = ('one',)` یا `t = 'one',` (ویرگول از قلم افتاده است). در غیر این صورت مفسر `t` را به عنوان یک `str` در نظر گرفته و به صورت کاراکتر به کاراکتر روی آن پیمایش می‌کند. + +- علامت `()` یک توکن خاص است و نشان‌دهنده‌ی یک `tuple` خالی است. + +- در مورد ۳، همان‌طور که احتمالاً متوجه شدید، بعد از عنصر پنجم (`"that"`) یک ویرگول از قلم افتاده است. بنابراین با الحاق ضمنی رشته‌ها، + + ```py + >>> ten_words_list + ['some', 'very', 'big', 'list', 'thatconsists', 'of', 'exactly', 'ten', 'words'] + ``` + +- در قطعه‌ی چهارم هیچ `AssertionError`ای رخ نداد؛ زیرا به جای ارزیابی عبارت تکی `a == b`، کل یک تاپل ارزیابی شده است. قطعه‌ی کد زیر این موضوع را روشن‌تر می‌کند: + + ```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 + ``` + +- در قطعه‌ی پنجم، بیشتر متدهایی که اشیای ترتیبی (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`) باعث تغییر مقدار اصلی آن نخواهد شد. + +- آگاهی از این نکات ظریف در بلندمدت می‌تواند ساعت‌ها از زمان شما برای رفع اشکال را صرفه‌جویی کند. + +--- + +### ◀ تقسیم‌ها \* + + + +```py +>>> 'a'.split() +['a'] + +# معادل است با +>>> 'a'.split(' ') +['a'] + +# اما +>>> len(''.split()) +0 + +# معادل نیست با +>>> len(''.split(' ')) +1 +``` + +#### 💡 توضیح: + +- در نگاه اول ممکن است به نظر برسد جداکننده‌ی پیش‌فرض متد `split` یک فاصله‌ی تکی (`' '`) است؛ اما مطابق با [مستندات رسمی](https://docs.python.org/3/library/stdtypes.html#str.split): + > اگر `sep` مشخص نشده یا برابر با `None` باشد، یک الگوریتم متفاوت برای جدا کردن اعمال می‌شود: رشته‌هایی از فاصله‌های متوالی به عنوان یک جداکننده‌ی واحد در نظر گرفته شده و در نتیجه، هیچ رشته‌ی خالی‌ای در ابتدا یا انتهای لیست خروجی قرار نمی‌گیرد، حتی اگر رشته‌ی اولیه دارای فاصله‌های اضافی در ابتدا یا انتها باشد. به همین دلیل، تقسیم یک رشته‌ی خالی یا رشته‌ای که فقط شامل فضای خالی است با جداکننده‌ی `None` باعث بازگشت یک لیست خالی `[]` می‌شود. + > اگر `sep` مشخص شود، جداکننده‌های متوالی در کنار هم قرار نمی‌گیرند و هر جداکننده، یک رشته‌ی خالی جدید ایجاد می‌کند. (مثلاً `'1,,2'.split(',')` مقدار `['1', '', '2']` را برمی‌گرداند.) تقسیم یک رشته‌ی خالی با یک جداکننده‌ی مشخص‌شده نیز باعث بازگشت `['']` می‌شود. +- توجه به اینکه چگونه فضای خالی در ابتدا و انتهای رشته در قطعه‌ی کد زیر مدیریت شده است، این مفهوم را روشن‌تر می‌کند: + + ```py + >>> ' a '.split(' ') + ['', 'a', ''] + >>> ' a '.split() + ['a'] + >>> ''.split(' ') + [''] + ``` + +--- + +### ◀ واردسازی‌های عمومی \* + + + + +```py +# File: module.py + +def some_weird_name_func_(): + print("works!") + +def _another_weird_name_func(): + print("works!") + +``` + +**خروجی** + +```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 +``` + +#### 💡 توضیح: + +- اغلب توصیه می‌شود از واردسازی عمومی (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'] + + def some_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 +>>> x = 7, 8, 9 +>>> sorted(x) == x +False +>>> sorted(x) == sorted(x) +True + +>>> y = reversed(x) +>>> sorted(y) == sorted(y) +False +``` + +#### 💡 توضیح: + +- متد `sorted` همیشه یک لیست (`list`) برمی‌گرداند، و در پایتون مقایسه‌ی لیست‌ها و تاپل‌ها (`tuple`) همیشه مقدار `False` را برمی‌گرداند. + +- ```py + >>> [] == tuple() + False + >>> x = 7, 8, 9 + >>> type(x), type(sorted(x)) + (tuple, list) + ``` + +- برخلاف متد `sorted`، متد `reversed` یک تکرارکننده (iterator) برمی‌گرداند. چرا؟ زیرا مرتب‌سازی نیاز به تغییر درجا (in-place) یا استفاده از ظرف جانبی (مانند یک لیست اضافی) دارد، در حالی که معکوس کردن می‌تواند به‌سادگی با پیمایش از اندیس آخر به اول انجام شود. + +- بنابراین در مقایسه‌ی `sorted(y) == sorted(y)`، فراخوانی اولِ `sorted()` تمام عناصرِ تکرارکننده‌ی `y` را مصرف می‌کند، و فراخوانی بعدی یک لیست خالی برمی‌گرداند. + + ```py + >>> x = 7, 8, 9 + >>> y = reversed(x) + >>> sorted(y), sorted(y) + ([7, 8, 9], []) + ``` + +--- + +### ◀ زمان نیمه‌شب وجود ندارد؟ + + + +```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) +``` + +**خروجی (< 3.5):** + +```py +('Time at noon is', datetime.time(12, 0)) +``` + +زمان نیمه‌شب چاپ نمی‌شود. + +#### 💡 توضیح: + +پیش از پایتون 3.5، مقدار بولی برای شیء `datetime.time` اگر نشان‌دهندهٔ نیمه‌شب به وقت UTC بود، برابر با `False` در نظر گرفته می‌شد. این رفتار در استفاده از دستور `if obj:` برای بررسی تهی بودن شیء یا برابر بودن آن با مقدار "خالی"، ممکن است باعث بروز خطا شود. + +--- + +--- + +## بخش: گنجینه‌های پنهان! + +این بخش شامل چند مورد جالب و کمتر شناخته‌شده درباره‌ی پایتون است که بیشتر مبتدی‌هایی مثل من از آن بی‌خبرند (البته دیگر اینطور نیست). + +### ◀ خب پایتون، می‌توانی کاری کنی پرواز کنم؟ + + + +خب، بفرمایید + +```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/) را پیاده‌سازی کرده است. + +--- + +### ◀ `goto`، ولی چرا؟ + + + +```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 # خروج از یک حلقه‌ی تودرتوی عمیق +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` در پایتون را مطالعه کنید. + +--- + +### ◀ خودتان را آماده کنید! + + + +اگر جزو افرادی هستید که دوست ندارند در پایتون برای مشخص کردن محدوده‌ها از فضای خالی (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) ایجاد می‌شود؟ + +#### 💡 توضیح: + +- ماژول `__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" # شکی در این نیست. + File "some_file.py", line 1 + "Ruby" != "Python" + ^ +SyntaxError: invalid syntax + +>>> "Ruby" <> "Python" +True +``` + +حالا می‌رسیم به اصل ماجرا. + +#### 💡 توضیح: + +- این مورد مربوط به [PEP-401](https://www.python.org/dev/peps/pep-0401/) است که در تاریخ ۱ آوریل ۲۰۰۹ منتشر شد (اکنون می‌دانید این یعنی چه!). +- نقل قولی از 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 +import this +``` + +صبر کن، **این** چیه؟ `this` عشقه :heart: + +**خروجی:** + +```text +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! +``` + +این ذنِ پایتون است! + +```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 # عشق پیجیده است +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` را مشاهده کنید.) + +--- + +### ◀ بله، این واقعاً وجود دارد! + + + +**عبارت `else` برای حلقه‌ها.** یک مثال معمول آن می‌تواند چنین باشد: + +```py + def does_exists_num(l, to_find): + for num in l: + if num == to_find: + print("Exists!") + break + else: + print("Does not exist") +``` + +**خروجی:** + +```py +>>> some_list = [1, 2, 3, 4, 5] +>>> does_exists_num(some_list, 4) +Exists! +>>> does_exists_num(some_list, -1) +Does not exist +``` + +**عبارت `else` در مدیریت استثناها.** مثالی از آن: + +```py +try: + pass +except: + print("Exception occurred!!!") +else: + print("Try block executed successfully...") +``` + +**خروجی:** + +```py +Try block executed successfully... +``` + +#### 💡 توضیح: + +- عبارت `else` بعد از حلقه‌ها تنها زمانی اجرا می‌شود که در هیچ‌کدام از تکرارها (`iterations`) از دستور `break` استفاده نشده باشد. می‌توانید آن را به عنوان یک شرط «بدون شکست» (nobreak) در نظر بگیرید. +- عبارت `else` پس از بلاک `try` به عنوان «عبارت تکمیل» (`completion clause`) نیز شناخته می‌شود؛ چراکه رسیدن به عبارت `else` در ساختار `try` به این معنی است که بلاک `try` بدون رخ دادن استثنا با موفقیت تکمیل شده است. + +--- + +### ◀ عملگر Ellipsis \* + + + +```py +def some_func(): + Ellipsis +``` + +**خروجی** + +```py +>>> some_func() +# بدون خروجی و بدون خطا + +>>> SomeRandomString +Traceback (most recent call last): + File "", line 1, in +NameError: name 'SomeRandomString' is not defined + +>>> Ellipsis +Ellipsis +``` + +#### 💡توضیح + +- در پایتون، `Ellipsis` یک شیء درونی (`built-in`) است که به صورت سراسری (`global`) در دسترس است و معادل `...` است. + + ```py + >>> ... + Ellipsis + ``` + +- عملگر `Ellipsis` می‌تواند برای چندین منظور استفاده شود: + + - به عنوان یک نگه‌دارنده برای کدی که هنوز نوشته نشده است (مانند دستور `pass`) + - در سینتکس برش (`slicing`) برای نمایش برش کامل در ابعاد باقی‌مانده + + ```py + >>> import numpy as np + >>> three_dimensional_array = np.arange(8).reshape(2, 2, 2) + array([ + [ + [0, 1], + [2, 3] + ], + + [ + [4, 5], + [6, 7] + ] + ]) + ``` + + بنابراین، آرایه‌ی `three_dimensional_array` ما، آرایه‌ای از آرایه‌ها از آرایه‌ها است. فرض کنیم می‌خواهیم عنصر دوم (اندیس `1`) از تمامی آرایه‌های درونی را چاپ کنیم؛ در این حالت می‌توانیم از `Ellipsis` برای عبور از تمامی ابعاد قبلی استفاده کنیم: + + ```py + >>> three_dimensional_array[:,:,1] + array([[1, 3], + [5, 7]]) + >>> three_dimensional_array[..., 1] # با استفاده از Ellipsis. + array([[1, 3], + [5, 7]]) + ``` + + نکته: این روش برای آرایه‌هایی با هر تعداد بُعد کار می‌کند. حتی می‌توانید از برش (`slice`) در بُعد اول و آخر استفاده کرده و ابعاد میانی را نادیده بگیرید (به صورت `n_dimensional_array[first_dim_slice, ..., last_dim_slice]`). + + - در [نوع‌دهی (`type hinting`)](https://docs.python.org/3/library/typing.html) برای اشاره به بخشی از نوع (مانند `Callable[..., int]` یا `Tuple[str, ...]`) استفاده می‌شود. + - همچنین می‌توانید از `Ellipsis` به عنوان آرگومان پیش‌فرض تابع استفاده کنید (برای مواردی که می‌خواهید میان «آرگومانی ارسال نشده است» و «مقدار `None` ارسال شده است» تمایز قائل شوید). + +--- + +### ◀ بی‌نهایت (`Inpinity`) + + + +این املای کلمه تعمداً به همین شکل نوشته شده است. لطفاً برای اصلاح آن درخواست (`patch`) ارسال نکنید. + +**خروجی (پایتون 3.x):** + +```py +>>> infinity = float('infinity') +>>> hash(infinity) +314159 +>>> hash(float('-inf')) +-314159 +``` + +#### 💡 توضیح: + +- هش (`hash`) مقدار بی‌نهایت برابر با 10⁵ × π است. +- نکته جالب اینکه در پایتون ۳ هشِ مقدار `float('-inf')` برابر با «-10⁵ × π» است، در حالی که در پایتون ۲ برابر با «-10⁵ × e» است. + +--- + +### ◀ بیایید خرابکاری کنیم + + + +1\. + +```py +class Yo(object): + def __init__(self): + self.__honey = True + self.bro = True +``` + +**خروجی:** + +```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): + # این بار بیایید چیزی متقارن را امتحان کنیم + self.__honey__ = True + self.bro = True +``` + +**خروجی:** + +```py +>>> Yo().bro +True + +>>> Yo()._Yo__honey__ +Traceback (most recent call last): + File "", line 1, in +AttributeError: 'Yo' object has no attribute '_Yo__honey__' +``` + +چرا کد `Yo()._Yo__honey` کار کرد؟ + +3\. + +```py +_A__variable = "Some value" + +class A(object): + def some_func(self): + return __variable # هنوز در هیچ جا مقداردهی اولیه نشده است +``` + +**خروجی:** + +```py +>>> A().__variable +Traceback (most recent call last): + File "", line 1, in +AttributeError: 'A' object has no attribute '__variable' + +>>> A().some_func() +'Some value' +``` + +#### 💡 توضیح: + +- [تغییر نام](https://en.wikipedia.org/wiki/Name_mangling) برای جلوگیری از برخورد نام‌ها بین فضاهای نام مختلف استفاده می‌شود. +- در پایتون، مفسر نام‌های اعضای کلاس که با `__` (دو آندرلاین که به عنوان "دندر" شناخته می‌شود) شروع می‌شوند و بیش از یک آندرلاین انتهایی ندارند را با اضافه کردن `_NameOfTheClass` در ابتدای آنها تغییر می‌دهد. +- بنابراین، برای دسترسی به ویژگی `__honey` در اولین قطعه کد، مجبور بودیم `_Yo` را به ابتدای آن اضافه کنیم، که از بروز تعارض با ویژگی با همان نام تعریف‌شده در هر کلاس دیگری جلوگیری می‌کند. +- اما چرا در دومین قطعه کد کار نکرد؟ زیرا تغییر نام، نام‌هایی که با دو آندرلاین خاتمه می‌یابند را شامل نمی‌شود. +- قطعه سوم نیز نتیجه تغییر نام بود. نام `__variable` در عبارت `return __variable` به `_A__variable` تغییر یافت، که همچنین همان نام متغیری است که در محدوده بیرونی تعریف کرده بودیم. +- همچنین، اگر نام تغییر یافته بیش از ۲۵۵ کاراکتر باشد، برش داده می‌شود. + +--- + +--- + +## بخش: ظاهرها فریبنده‌اند! + +### ◀ خطوط را رد می‌کند؟ + + + +**خروجی:** + +```py +>>> value = 11 +>>> valuе = 32 +>>> value +11 +``` + +چی? + +**نکته:** ساده‌ترین روش برای بازتولید این رفتار، کپی کردن دستورات از کد بالا و جایگذاری (paste) آن‌ها در فایل یا محیط تعاملی (shell) خودتان است. + +#### 💡 توضیح + +برخی از حروف غیرغربی کاملاً مشابه حروف الفبای انگلیسی به نظر می‌رسند، اما مفسر پایتون آن‌ها را متفاوت در نظر می‌گیرد. + +```py +>>> ord('е') # حرف سیریلیک «е» (Ye) +1077 +>>> ord('e') # حرف لاتین «e»، که در انگلیسی استفاده می‌شود و با صفحه‌کلید استاندارد تایپ می‌گردد +101 +>>> 'е' == 'e' +False + +>>> value = 42 # حرف لاتین e +>>> valuе = 23 # حرف سیریلیک «е»؛ مفسر پایتون نسخه ۲ در اینجا خطای `SyntaxError` ایجاد می‌کند +>>> value +42 +``` + +تابع داخلی `ord()`، [کدپوینت](https://fa.wikipedia.org/wiki/کدپوینت) یونیکد مربوط به یک نویسه را برمی‌گرداند. موقعیت‌های کدی متفاوت برای حرف سیریلیک «е» و حرف لاتین «e»، علت رفتار مثال بالا را توجیه می‌کنند. + +--- + +### ◀ تله‌پورت کردن + + + +```py +# `pip install numpy` first. +import numpy as np + +def energy_send(x): + # مقداردهی اولیه یک آرایه numpy + np.array([float(x)]) + +def energy_receive(): + # بازگرداندن یک آرایه‌ی خالی numpy + return np.empty((), dtype=np.float).tolist() +``` + +**خروجی:** + +```py +>>> energy_send(123.456) +>>> energy_receive() +123.456 +``` + +جایزه نوبل کجاست؟ + +#### 💡 توضیح: + +- توجه کنید که آرایه‌ی numpy ایجادشده در تابع `energy_send` برگردانده نشده است، بنابراین فضای حافظه‌ی آن آزاد شده و مجدداً قابل استفاده است. +- تابع `numpy.empty()` نزدیک‌ترین فضای حافظه‌ی آزاد را بدون مقداردهی مجدد برمی‌گرداند. این فضای حافظه معمولاً همان فضایی است که به‌تازگی آزاد شده است (البته معمولاً این اتفاق می‌افتد و نه همیشه). + +--- + +### ◀ خب، یک جای کار مشکوک است... + + + +```py +def square(x): + """ + یک تابع ساده برای محاسبه‌ی مربع یک عدد با استفاده از جمع. + """ + sum_so_far = 0 + for counter in range(x): + sum_so_far = sum_so_far + x + return sum_so_far +``` + +**خروجی (پایتون 2.X):** + +```py +>>> square(10) +10 +``` + +آیا این نباید ۱۰۰ باشد؟ + +**نکته:** اگر نمی‌توانید این مشکل را بازتولید کنید، سعی کنید فایل [mixed_tabs_and_spaces.py](/mixed_tabs_and_spaces.py) را از طریق شِل اجرا کنید. + +#### 💡 توضیح + +- **تب‌ها و فاصله‌ها (space) را با هم ترکیب نکنید!** کاراکتری که دقیقاً قبل از دستور return آمده یک «تب» است، در حالی که در بقیۀ مثال، کد با مضربی از «۴ فاصله» تورفتگی دارد. +- نحوۀ برخورد پایتون با تب‌ها به این صورت است: + + > ابتدا تب‌ها (از چپ به راست) با یک تا هشت فاصله جایگزین می‌شوند به‌طوری که تعداد کل کاراکترها تا انتهای آن جایگزینی، مضربی از هشت باشد <...> + +- بنابراین «تب» در آخرین خط تابع `square` با هشت فاصله جایگزین شده و به همین دلیل داخل حلقه قرار می‌گیرد. +- پایتون ۳ آنقدر هوشمند هست که چنین مواردی را به‌صورت خودکار با خطا اعلام کند. + + **خروجی (Python 3.x):** + + ```py + TabError: inconsistent use of tabs and spaces in indentation + ``` + +--- + +--- + +## بخش: متفرقه + +### ◀ `+=` سریع‌تر است + + + +```py +# استفاده از "+"، سه رشته: +>>> timeit.timeit("s1 = s1 + s2 + s3", setup="s1 = ' ' * 100000; s2 = ' ' * 100000; s3 = ' ' * 100000", number=100) +0.25748300552368164 +# استفاده از "+="، سه رشته: +>>> timeit.timeit("s1 += s2 + s3", setup="s1 = ' ' * 100000; s2 = ' ' * 100000; s3 = ' ' * 100000", number=100) +0.012188911437988281 +``` + +#### 💡 توضیح: + +- استفاده از `+=` برای اتصال بیش از دو رشته سریع‌تر از `+` است، زیرا هنگام محاسبه رشته‌ی نهایی، رشته‌ی اول (به‌عنوان مثال `s1` در عبارت `s1 += s2 + s3`) از بین نمی‌رود. + +--- + +### ◀ بیایید یک رشته‌ی بزرگ بسازیم! + + + +```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 +``` + +**خروجی:** + +اجرا شده در پوسته‌ی ipython با استفاده از `%timeit` برای خوانایی بهتر نتایج. +همچنین می‌توانید از ماژول `timeit` در پوسته یا اسکریپت عادی پایتون استفاده کنید؛ نمونه‌ی استفاده در زیر آمده است: +timeit.timeit('add_string_with_plus(10000)', number=1000, globals=globals()) + +```py + +>>> 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) +``` + +بیایید تعداد تکرارها را ۱۰ برابر افزایش دهیم. + +```py +>>> NUM_ITERS = 10000 +>>> %timeit -n1000 add_string_with_plus(NUM_ITERS) # افزایش خطی در زمان اجرا +1.26 ms ± 76.8 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) +>>> %timeit -n1000 add_bytes_with_plus(NUM_ITERS) # افزایش درجه دو (افزایش مربعی) +6.82 ms ± 134 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) +>>> %timeit -n1000 add_string_with_format(NUM_ITERS) # افزایش خطی +645 µs ± 24.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) +>>> %timeit -n1000 add_string_with_join(NUM_ITERS) # افزایش خطی +1.17 ms ± 7.25 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) +>>> l = ["xyz"]*NUM_ITERS +>>> %timeit -n1000 convert_list_to_string(l, NUM_ITERS) # افزایش خطی +86.3 µs ± 2 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) +``` + +#### 💡 توضیح + +توضیحات + +- برای اطلاعات بیشتر درباره‌ی [timeit](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 = "" + for i in range(iters): + s = s + "x" + "y" + "z" + assert len(s) == 3*iters + + >>> %timeit -n100 add_string_with_plus(1000) + 388 µs ± 22.4 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) + >>> %timeit -n100 add_string_with_plus(10000) # افزایش درجه دو در زمان اجرا + 9 ms ± 298 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) + ``` + +- وجود راه‌های متعدد برای قالب‌بندی و ایجاد رشته‌های بزرگ تا حدودی در تضاد با [ذِن پایتون](https://www.python.org/dev/peps/pep-0020/) است که می‌گوید: + + > «باید یک راه — و ترجیحاً فقط یک راه — واضح برای انجام آن وجود داشته باشد.» + +--- + +### ◀ کُند کردن جستجوها در `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) +>>> some_dict[1] = 1 +>>> %timeit some_dict['5'] +37.2 ns ± 0.265 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each) + +>>> %timeit another_dict['5'] +28.5 ns ± 0.142 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each) +>>> another_dict[1] # تلاش برای دسترسی به کلیدی که وجود ندارد +Traceback (most recent call last): + File "", 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) +``` + +چرا جستجوهای یکسان کندتر می‌شوند؟ + +#### 💡 توضیح: + +- در CPython یک تابع عمومی برای جستجوی کلید در دیکشنری‌ها وجود دارد که از تمام انواع کلیدها (`str`، `int` و هر شیء دیگر) پشتیبانی می‌کند؛ اما برای حالت متداولی که تمام کلیدها از نوع `str` هستند، یک تابع بهینه‌شده‌ی اختصاصی نیز وجود دارد. +- تابع اختصاصی (که در کد منبع CPython با نام [`lookdict_unicode`](https://github.com/python/cpython/blob/522691c46e2ae51faaad5bbbce7d959dd61770df/Objects/dictobject.c#L841) شناخته می‌شود) فرض می‌کند که تمام کلیدهای موجود در دیکشنری (از جمله کلیدی که در حال جستجوی آن هستید) رشته (`str`) هستند و برای مقایسه‌ی کلیدها، به‌جای فراخوانی متد `__eq__`، از مقایسه‌ی سریع‌تر و ساده‌تر رشته‌ای استفاده می‌کند. +- اولین باری که یک دیکشنری (`dict`) با کلیدی غیر از `str` فراخوانی شود، این حالت تغییر می‌کند و جستجوهای بعدی از تابع عمومی استفاده خواهند کرد. +- این فرایند برای آن نمونه‌ی خاص از دیکشنری غیرقابل بازگشت است و حتی لازم نیست کلید موردنظر در دیکشنری موجود باشد. به همین دلیل است که حتی تلاش ناموفق برای دسترسی به کلیدی ناموجود نیز باعث ایجاد همین تأثیر (کند شدن جستجو) می‌شود. + +### ◀ حجیم کردن دیکشنری نمونه‌ها (`instance dicts`) \* + + + +```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__) + +``` + +**خروجی:** (پایتون ۳.۸؛ سایر نسخه‌های پایتون ۳ ممکن است کمی متفاوت باشند) + +```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 +``` + +بیایید دوباره امتحان کنیم... در یک مفسر (interpreter) جدید: + +```py +>>> o1 = SomeClass() +>>> o2 = SomeClass() +>>> dict_size(o1) +104 # همان‌طور که انتظار می‌رفت +>>> o1.some_attr5 = 5 +>>> o1.some_attr6 = 6 +>>> dict_size(o1) +360 +>>> dict_size(o2) +272 +>>> o3 = SomeClass() +>>> dict_size(o3) +232 +``` + +چه چیزی باعث حجیم‌شدن این دیکشنری‌ها می‌شود؟ و چرا اشیاء تازه ساخته‌شده نیز حجیم هستند؟ + +#### 💡 توضیح: + +- در CPython، امکان استفاده‌ی مجدد از یک شیء «کلیدها» (`keys`) در چندین دیکشنری وجود دارد. این ویژگی در [PEP 412](https://www.python.org/dev/peps/pep-0412/) معرفی شد تا مصرف حافظه کاهش یابد، به‌ویژه برای دیکشنری‌هایی که به نمونه‌ها (instances) تعلق دارند و معمولاً کلیدها (نام صفات نمونه‌ها) بین آن‌ها مشترک است. +- این بهینه‌سازی برای دیکشنری‌های نمونه‌ها کاملاً شفاف و خودکار است؛ اما اگر بعضی فرضیات نقض شوند، غیرفعال می‌شود. +- دیکشنری‌هایی که کلیدهایشان به اشتراک گذاشته شده باشد، از حذف کلید پشتیبانی نمی‌کنند؛ بنابراین اگر صفتی از یک نمونه حذف شود، دیکشنریِ آن نمونه «غیر مشترک» (`unshared`) شده و این قابلیت اشتراک‌گذاری کلیدها برای تمام نمونه‌هایی که در آینده از آن کلاس ساخته می‌شوند، غیرفعال می‌گردد. +- همچنین اگر اندازه‌ی دیکشنری به‌علت اضافه‌شدن کلیدهای جدید تغییر کند (`resize` شود)، اشتراک‌گذاری کلیدها تنها زمانی ادامه می‌یابد که فقط یک دیکشنری در حال استفاده از آن‌ها باشد (این اجازه می‌دهد در متد `__init__` برای اولین نمونه‌ی ساخته‌شده، صفات متعددی تعریف کنید بدون آن‌که اشتراک‌گذاری کلیدها از بین برود). اما اگر چند نمونه همزمان وجود داشته باشند و تغییر اندازه‌ی دیکشنری رخ دهد، قابلیت اشتراک‌گذاری کلیدها برای نمونه‌های بعدی همان کلاس غیرفعال خواهد شد. زیرا CPython دیگر نمی‌تواند مطمئن باشد که آیا نمونه‌های بعدی دقیقاً از مجموعه‌ی یکسانی از صفات استفاده خواهند کرد یا خیر. +- نکته‌ای کوچک برای کاهش مصرف حافظه‌ی برنامه: هرگز صفات نمونه‌ها را حذف نکنید و حتماً تمام صفات را در متد `__init__` تعریف و مقداردهی اولیه کنید! + +### ◀ موارد جزئی \* + + + +- متد `join()` عملیاتی مربوط به رشته (`str`) است، نه لیست (`list`). (در نگاه اول کمی برخلاف انتظار است.) + + **توضیح:** اگر `join()` به‌عنوان متدی روی رشته پیاده‌سازی شود، می‌تواند روی هر شیء قابل پیمایش (`iterable`) از جمله لیست، تاپل و هر نوع تکرارشونده‌ی دیگر کار کند. اگر به‌جای آن روی لیست تعریف می‌شد، باید به‌طور جداگانه برای هر نوع دیگری نیز پیاده‌سازی می‌شد. همچنین منطقی نیست که یک متد مختص رشته روی یک شیء عمومی مانند `list` پیاده شود. + +- تعدادی عبارت با ظاهری عجیب اما از نظر معنا صحیح: + + - عبارت `[] = ()` از نظر معنایی صحیح است (باز کردن یا `unpack` کردن یک تاپل خالی درون یک لیست خالی). + - عبارت `'a'[0][0][0][0][0]` نیز از نظر معنایی صحیح است، زیرا پایتون برخلاف زبان‌هایی که از C منشعب شده‌اند، نوع داده‌ای جداگانه‌ای برای کاراکتر ندارد. بنابراین انتخاب یک کاراکتر از یک رشته، منجر به بازگشت یک رشته‌ی تک‌کاراکتری می‌شود. + - عبارات `3 --0-- 5 == 8` و `--5 == 5` هر دو از لحاظ معنایی درست بوده و مقدارشان برابر `True` است. + +- با فرض اینکه `a` یک عدد باشد، عبارات `++a` و `--a` هر دو در پایتون معتبر هستند؛ اما رفتاری مشابه با عبارات مشابه در زبان‌هایی مانند C، ++C یا جاوا ندارند. + + ```py + >>> a = 5 + >>> a + 5 + >>> ++a + 5 + >>> --a + 5 + ``` + + 💡 **توضیح:** + +- در گرامر پایتون عملگری به‌نام `++` وجود ندارد. در واقع `++` دو عملگر `+` جداگانه است. +- عبارت `++a` به‌شکل `+(+a)` تفسیر می‌شود که معادل `a` است. به‌همین ترتیب، خروجی عبارت `--a` نیز قابل توجیه است. +- این [تاپیک در StackOverflow](https://stackoverflow.com/questions/3654830/why-are-there-no-and-operators-in-python) دلایل نبودن عملگرهای افزایش (`++`) و کاهش (`--`) در پایتون را بررسی می‌کند. + +- احتمالاً با عملگر Walrus (گراز دریایی) در پایتون آشنا هستید؛ اما تا به حال در مورد _عملگر Space-invader (مهاجم فضایی)_ شنیده‌اید؟ + + ```py + >>> a = 42 + >>> a -=- 1 + >>> 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) دارد. + + ```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)) + +- حالا که صحبت از عملگرها شد، عملگر `@` نیز برای ضرب ماتریسی در پایتون وجود دارد (نگران نباشید، این بار واقعی است). + + ```py + >>> import numpy as np + >>> np.array([2, 2, 2]) @ np.array([7, 8, 8]) + 46 + ``` + + **💡 توضیح:** عملگر `@` در پایتون ۳٫۵ با در نظر گرفتن نیازهای جامعه علمی اضافه شد. هر شی‌ای می‌تواند متد جادویی `__matmul__` را بازنویسی کند تا رفتار این عملگر را مشخص نماید. + +- از پایتون ۳٫۸ به بعد می‌توانید از نحو متداول f-string مانند `f'{some_var=}'` برای اشکال‌زدایی سریع استفاده کنید. مثال, + + ```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)])) + + 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) در پایتون استفاده کنید. + +- گاهی اوقات، متد `print` ممکن است مقادیر را فوراً چاپ نکند. برای مثال، + + ```py + # File some_file.py + import time + + print("wtfpython", end="_") + time.sleep(3) + ``` + + این کد عبارت `wtfpython` را به دلیل آرگومان `end` پس از ۳ ثانیه چاپ می‌کند؛ چرا که بافر خروجی تنها پس از رسیدن به کاراکتر `\n` یا در زمان اتمام اجرای برنامه تخلیه می‌شود. برای تخلیه‌ی اجباری بافر می‌توانید از آرگومان `flush=True` استفاده کنید. + +- برش لیست‌ها (List slicing) با اندیس‌های خارج از محدوده، خطایی ایجاد نمی‌کند. + + ```py + >>> some_list = [1, 2, 3, 4, 5] + >>> some_list[111:] + [] + ``` + +- برش زدن (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 + ``` + +- در پایتون ۳، فراخوانی `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 + ``` + +- عبارت `'abc'.count('') == 4` مقدار `True` برمی‌گرداند. در اینجا یک پیاده‌سازی تقریبی از متد `count` آورده شده که این موضوع را شفاف‌تر می‌کند: + + ```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 + ``` + +این رفتار به این دلیل است که زیررشته‌ی خالی (`''`) با برش‌هایی (slices) به طول صفر در رشته‌ی اصلی مطابقت پیدا می‌کند. + +--- + +--- + +# مشارکت + +چند روشی که می‌توانید در wtfpython مشارکت داشته باشید: + +- پیشنهاد مثال‌های جدید +- کمک به ترجمه (به [مشکلات برچسب ترجمه](https://github.com/satwikkansal/wtfpython/issues?q=is%3Aissue+is%3Aopen+label%3Atranslation) مراجعه کنید) +- اصلاحات جزئی مثل اشاره به تکه‌کدهای قدیمی، اشتباهات تایپی، خطاهای قالب‌بندی و غیره. +- شناسایی نواقص (مانند توضیحات ناکافی، مثال‌های تکراری و ...) +- هر پیشنهاد خلاقانه‌ای برای مفیدتر و جذاب‌تر شدن این پروژه + +برای اطلاعات بیشتر [CONTRIBUTING.md](/CONTRIBUTING.md) را مشاهده کنید. برای بحث درباره موارد مختلف می‌توانید یک [مشکل جدید](https://github.com/satwikkansal/wtfpython/issues/new) ایجاد کنید. + +نکته: لطفاً برای درخواست بک‌لینک (backlink) تماس نگیرید. هیچ لینکی اضافه نمی‌شود مگر اینکه ارتباط بسیار زیادی با پروژه داشته باشد. + +# تقدیر و تشکر + +ایده و طراحی این مجموعه ابتدا از پروژه عالی [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/). + +# 🎓 مجوز + +[![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 + +## دوستانتان را هم شگفت‌زده کنید! + +اگر از 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!) + +## آیا به یک نسخه pdf نیاز دارید؟ + +من چند درخواست برای نسخه PDF (و epub) کتاب wtfpython دریافت کرده‌ام. برای دریافت این نسخه‌ها به محض آماده شدن، می‌توانید اطلاعات خود را [اینجا](https://form.jotform.com/221593245656057) وارد کنید. + +**همین بود دوستان!** برای دریافت مطالب آینده مشابه این، می‌توانید ایمیل خود را [اینجا](https://form.jotform.com/221593598380062) اضافه کنید.