From b61a2e1dfbd1c4c6c26cf9dfad1b27d7c0ebc730 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Sat, 10 Nov 2018 17:38:25 +0800 Subject: [PATCH 01/53] Init --- .gitignore | 1 + README.md | 2391 +++++++++++++++++ images/logo.png | Bin 0 -> 8317 bytes images/string-intern/string_intern.png | Bin 0 -> 9731 bytes images/tic-tac-toe.png | Bin 0 -> 7515 bytes .../tic-tac-toe/after_board_initialized.png | Bin 0 -> 162385 bytes images/tic-tac-toe/after_row_initialized.png | Bin 0 -> 51686 bytes 7 files changed, 2392 insertions(+) create mode 100644 .gitignore create mode 100644 README.md create mode 100644 images/logo.png create mode 100644 images/string-intern/string_intern.png create mode 100644 images/tic-tac-toe.png create mode 100644 images/tic-tac-toe/after_board_initialized.png create mode 100644 images/tic-tac-toe/after_row_initialized.png diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..e43b0f9 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +.DS_Store diff --git a/README.md b/README.md new file mode 100644 index 0000000..5c63c54 --- /dev/null +++ b/README.md @@ -0,0 +1,2391 @@ +

+

What the f*ck Python! 🐍

+

An interesting collection of surprising snippets and lesser-known Python features.

+ +[![WTFPL 2.0][license-image]][license-url] [![Commit id][commit-image]][commit-url] + + +Python, being a beautifully designed high-level and interpreter-based programming language, provides us with many features for the programmer's comfort. But sometimes, the outcomes of a Python snippet may not seem obvious to a regular user at first sight. + +Here is a fun project to collect such tricky & counter-intuitive examples and lesser-known features in Python, attempting to discuss what exactly is happening under the hood! + +While some of the examples you see below may not be WTFs in the truest sense, but they'll reveal some of the interesting parts of Python that you might be unaware of. I find it a nice way to learn the internals of a programming language, and I think you'll find them interesting as well! + +If you're an experienced Python programmer, you can take it as a challenge to get most of them right in first attempt. You may be already familiar with some of these examples, and I might be able to revive sweet old memories of yours being bitten by these gotchas :sweat_smile: + +If you're a returning reader, you can learn about the new modifications [here](https://github.com/satwikkansal/wtfpython/releases/). + +So, here we go... + +# Table of Contents + + +- [Table of Contents](#table-of-contents) +- [Structure of the Examples](#structure-of-the-examples) +- [Usage](#usage) +- [👀 Examples](#👀-examples) + - [Section: Strain your brain!](#section-strain-your-brain) + - [> Strings can be tricky sometimes *](#-strings-can-be-tricky-sometimes-) + - [> Time for some hash brownies!](#-time-for-some-hash-brownies) + - [> Return return everywhere!](#-return-return-everywhere) + - [> Deep down, we're all the same. *](#-deep-down-were-all-the-same-) + - [> For what?](#-for-what) + - [> Evaluation time discrepancy](#-evaluation-time-discrepancy) + - [> `is` is not what it is!](#-is-is-not-what-it-is) + - [> A tic-tac-toe where X wins in the first attempt!](#-a-tic-tac-toe-where-x-wins-in-the-first-attempt) + - [> The sticky output function](#-the-sticky-output-function) + - [> `is not ...` is not `is (not ...)`](#-is-not--is-not-is-not-) + - [> The surprising comma](#-the-surprising-comma) + - [> Backslashes at the end of string](#-backslashes-at-the-end-of-string) + - [> not knot!](#-not-knot) + - [> Half triple-quoted strings](#-half-triple-quoted-strings) + - [> Midnight time doesn't exist?](#-midnight-time-doesnt-exist) + - [> What's wrong with booleans?](#-whats-wrong-with-booleans) + - [> Class attributes and instance attributes](#-class-attributes-and-instance-attributes) + - [> yielding None](#-yielding-none) + - [> Mutating the immutable!](#-mutating-the-immutable) + - [> The disappearing variable from outer scope](#-the-disappearing-variable-from-outer-scope) + - [> When True is actually False](#-when-true-is-actually-false) + - [> From filled to None in one instruction...](#-from-filled-to-none-in-one-instruction) + - [> Subclass relationships *](#-subclass-relationships-) + - [> The mysterious key type conversion *](#-the-mysterious-key-type-conversion-) + - [> Let's see if you can guess this?](#-lets-see-if-you-can-guess-this) + - [Section: Appearances are deceptive!](#section-appearances-are-deceptive) + - [> Skipping lines?](#-skipping-lines) + - [> Teleportation *](#-teleportation-) + - [> Well, something is fishy...](#-well-something-is-fishy) + - [Section: Watch out for the landmines!](#section-watch-out-for-the-landmines) + - [> Modifying a dictionary while iterating over it](#-modifying-a-dictionary-while-iterating-over-it) + - [> Stubborn `del` operator *](#-stubborn-del-operator-) + - [> Deleting a list item while iterating](#-deleting-a-list-item-while-iterating) + - [> 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) + - [> The out of scope variable](#-the-out-of-scope-variable) + - [> Be careful with chained operations](#-be-careful-with-chained-operations) + - [> Name resolution ignoring class scope](#-name-resolution-ignoring-class-scope) + - [> Needle in a Haystack](#-needle-in-a-haystack) + - [Section: The Hidden treasures!](#section-the-hidden-treasures) + - [> Okay Python, Can you make me fly? *](#-okay-python-can-you-make-me-fly-) + - [> `goto`, but why? *](#-goto-but-why-) + - [> Brace yourself! *](#-brace-yourself-) + - [> 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) + - [> Inpinity *](#-inpinity-) + - [> Mangling time! *](#-mangling-time-) + - [Section: Miscellaneous](#section-miscellaneous) + - [> `+=` is faster](#--is-faster) + - [> Let's make a giant string!](#-lets-make-a-giant-string) + - [> Explicit typecast of strings](#-explicit-typecast-of-strings) + - [> Minor Ones](#-minor-ones) +- [Contributing](#contributing) +- [Acknowledgements](#acknowledgements) +- [🎓 License](#🎓-license) + - [Help](#help) + - [Want to surprise your geeky pythonist friends?](#want-to-surprise-your-geeky-pythonist-friends) + - [Need a pdf version?](#need-a-pdf-version) + - [Follow Commit](#follow-commit) + + + +# Structure of the Examples + +All the examples are structured like below: + +> ### > Some fancy Title * +> The asterisk at the end of the title indicates the example was not present in the first release and has been recently added. +> +> ```py +> # Setting up the code. +> # Preparation for the magic... +> ``` +> +> **Output (Python version):** +> ```py +> >>> triggering_statement +> Probably unexpected output +> ``` +> (Optional): One line describing the unexpected output. +> +> +> #### 💡 Explanation: +> +> * Brief explanation of what's happening and why is it happening. +> ```py +> Setting up examples for clarification (if necessary) +> ``` +> **Output:** +> ```py +> >>> trigger # some example that makes it easy to unveil the magic +> # some justified output +> ``` + +**Note:** All the examples are tested on Python 3.5.2 interactive interpreter, and they should work for all the Python versions unless explicitly specified in the description. + +# Usage + +A nice way to get the most out of these examples, in my opinion, will be just to read the examples chronologically, and for every example: +- Carefully read the initial code for setting up the example. If you're an experienced Python programmer, most of the times you will successfully anticipate what's going to happen next. +- Read the output snippets and, + + Check if the outputs are the same as you'd expect. + + Make sure if you know the exact reason behind the output being the way it is. + - If no, take a deep breath, and read the explanation (and if you still don't understand, shout out! and create an issue [here](https://github.com/satwikkansal/wtfPython)). + - If yes, give a gentle pat on your back, and you may skip to the next example. + +PS: You can also read WTFpython at the command line. There's a pypi package and an npm package (supports colored formatting) for the same. + +To install the npm package [`wtfpython`](https://www.npmjs.com/package/wtfpython) +```sh +$ npm install -g wtfpython +``` + +Alternatively, to install the pypi package [`wtfpython`](https://pypi.python.org/pypi/wtfpython) +```sh +$ pip install wtfpython -U +``` + +Now, just run `wtfpython` at the command line which will open this collection in your selected `$PAGER`. + +--- + +# 👀 Examples + + +## Section: Strain your brain! + +### > Strings can be tricky sometimes * + +1\. +```py +>>> a = "some_string" +>>> id(a) +140420665652016 +>>> id("some" + "_" + "string") # Notice that both the ids are same. +140420665652016 +``` + +2\. +```py +>>> a = "wtf" +>>> b = "wtf" +>>> a is b +True + +>>> a = "wtf!" +>>> b = "wtf!" +>>> a is b +False + +>>> a, b = "wtf!", "wtf!" +>>> a is b +True +``` + +3\. +```py +>>> 'a' * 20 is 'aaaaaaaaaaaaaaaaaaaa' +True +>>> 'a' * 21 is 'aaaaaaaaaaaaaaaaaaaaa' +False +``` + +Makes sense, right? + +#### 💡 Explanation: ++ Such behavior is due to 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 point to the same string object in memory (thereby saving memory). ++ In the snippets above, strings are implicitly interned. The decision of when to implicitly intern a string is implementation dependent. There are some facts that can be used to guess if a string will be interned or not: + * All length 0 and length 1 strings are interned. + * Strings are interned at compile time (`'wtf'` will be interned but `''.join(['w', 't', 'f']` will not be interned) + * Strings that are not composed of ASCII letters, digits or underscores, are not interned. This explains why `'wtf!'` was not interned due to `!`. Cpython implementation of this rule can be found [here](https://github.com/python/cpython/blob/3.6/Objects/codeobject.c#L19) + ++ 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 compiler optimization and specifically applies to the interactive environment. ++ Constant folding is a technique for [peephole optimization](https://en.wikipedia.org/wiki/Peephole_optimization) in Python. This means the expression `'a'*20` is replaced by `'aaaaaaaaaaaaaaaaaaaa'` during compilation to reduce few clock cycles during runtime. Constant folding only occurs for strings having length less than 20. (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. + + +--- + +### > Time for some hash brownies! + +1\. +```py +some_dict = {} +some_dict[5.5] = "Ruby" +some_dict[5.0] = "JavaScript" +some_dict[5] = "Python" +``` + +**Output:** +```py +>>> some_dict[5.5] +"Ruby" +>>> some_dict[5.0] +"Python" +>>> some_dict[5] +"Python" +``` + +"Python" destroyed the existence of "JavaScript"? + +#### 💡 Explanation + +* Python dictionaries check for equality and compare the hash value to determine if two keys are the same. +* Immutable objects with same value always have the same hash in Python. + ```py + >>> 5 == 5.0 + True + >>> hash(5) == hash(5.0) + True + ``` + **Note:** Objects with different values may also have same hash (known as hash collision). +* When the statement `some_dict[5] = "Python"` is executed, the existing value "JavaScript" is overwritten with "Python" because Python recognizes `5` and `5.0` as the same keys of the dictionary `some_dict`. +* This StackOverflow [answer](https://stackoverflow.com/a/32211042/4354153) explains beautifully the rationale behind it. + +--- + +### > Return return everywhere! + +```py +def some_func(): + try: + return 'from_try' + finally: + return 'from_finally' +``` + +**Output:** +```py +>>> some_func() +'from_finally' +``` + +#### 💡 Explanation: + +- When a `return`, `break` or `continue` statement is executed in the `try` suite of a "try…finally" statement, the `finally` clause is also executed ‘on the way out. +- The return value of a function is determined by the last `return` statement executed. Since the `finally` clause always executes, a `return` statement executed in the `finally` clause will always be the last one executed. + +--- + +### > Deep down, we're all the same. * + +```py +class WTF: + pass +``` + +**Output:** +```py +>>> WTF() == WTF() # two different instances can't be equal +False +>>> WTF() is WTF() # identities are also different +False +>>> hash(WTF()) == hash(WTF()) # hashes _should_ be different as well +True +>>> id(WTF()) == id(WTF()) +True +``` + +#### 💡 Explanation: + +* When `id` was called, Python created a `WTF` class object and passed it to the `id` function. The `id` function takes its `id` (its memory location), and throws away the object. The object is destroyed. +* When we do this twice in succession, Python allocates the same memory location to this second object as well. Since (in CPython) `id` uses the memory location as the object id, the id of the two objects is the same. +* So, object's id is unique only for the lifetime of the object. After the object is destroyed, or before it is created, something else can have the same id. +* But why did the `is` operator evaluated to `False`? Let's see with this snippet. + ```py + class WTF(object): + def __init__(self): print("I") + def __del__(self): print("D") + ``` + + **Output:** + ```py + >>> WTF() is WTF() + I + I + D + D + False + >>> id(WTF()) == id(WTF()) + I + D + I + D + True + ``` + As you may observe, the order in which the objects are destroyed is what made all the difference here. + +--- + +### > For what? + +```py +some_string = "wtf" +some_dict = {} +for i, some_dict[i] in enumerate(some_string): + pass +``` + +**Output:** +```py +>>> some_dict # An indexed dict is created. +{0: 'w', 1: 't', 2: 'f'} +``` + +#### 💡 Explanation: + +* A `for` statement is defined in the [Python grammar](https://docs.python.org/3/reference/grammar.html) as: + ``` + for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite] + ``` + Where `exprlist` is the assignment target. This means that the equivalent of `{exprlist} = {next_value}` is **executed for each item** in the iterable. + An interesting example that illustrates this: + ```py + for i in range(4): + print(i) + i = 10 + ``` + + **Output:** + ``` + 0 + 1 + 2 + 3 + ``` + + Did you expect the loop to run just once? + + **💡 Explanation:** + + - The assignment statement `i = 10` never affects the iterations of the loop because of the way for loops work in Python. Before the beginning of every iteration, the next item provided by the iterator (`range(4)` this case) is unpacked and assigned the target list variables (`i` in this case). + +* The `enumerate(some_string)` function yields a new value `i` (A counter going up) and a character from the `some_string` in each iteration. It then sets the (just assigned) `i` key of the dictionary `some_dict` to that character. The unrolling of the loop can be simplified as: + ```py + >>> i, some_dict[i] = (0, 'w') + >>> i, some_dict[i] = (1, 't') + >>> i, some_dict[i] = (2, 'f') + >>> some_dict + ``` + +--- + +### > Evaluation time discrepancy + +1\. +```py +array = [1, 8, 15] +g = (x for x in array if array.count(x) > 0) +array = [2, 8, 22] +``` + +**Output:** +```py +>>> print(list(g)) +[8] +``` + +2\. + +```py +array_1 = [1,2,3,4] +g1 = (x for x in array_1) +array_1 = [1,2,3,4,5] + +array_2 = [1,2,3,4] +g2 = (x for x in array_2) +array_2[:] = [1,2,3,4,5] +``` + +**Output:** +```py +>>> print(list(g1)) +[1,2,3,4] + +>>> print(list(g2)) +[1,2,3,4,5] +``` + +#### 💡 Explanation + +- In a [generator](https://wiki.python.org/moin/Generators) expression, the `in` clause is evaluated at declaration time, but the conditional clause is evaluated at runtime. +- So before runtime, `array` is re-assigned to the list `[2, 8, 22]`, and since out of `1`, `8` and `15`, only the count of `8` is greater than `0`, the generator only yields `8`. +- The differences in the output of `g1` and `g2` in the second part is due the way variables `array_1` and `array_2` are re-assigned values. +- In the first case, `array_1` is binded 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]`). + +--- + +### > `is` is not what it is! + +The following is a very famous example present all over the internet. + +```py +>>> a = 256 +>>> b = 256 +>>> a is b +True + +>>> a = 257 +>>> b = 257 +>>> a is b +False + +>>> a = 257; b = 257 +>>> a is b +True +``` + +#### 💡 Explanation: + +**The difference between `is` and `==`** + +* `is` operator checks if both the operands refer to the same object (i.e., it checks if the identity of the operands matches or not). +* `==` operator compares the values of both the operands and checks if they are the same. +* So `is` is for reference equality and `==` is for value equality. An example to clear things up, + ```py + >>> [] == [] + True + >>> [] is [] # These are two empty lists at two different memory locations. + False + ``` + +**`256` is an existing object but `257` isn't** + +When you start up python the numbers from `-5` to `256` will be allocated. These numbers are used a lot, so it makes sense just to have them ready. + +Quoting from https://docs.python.org/3/c-api/long.html +> The current implementation keeps an array of integer objects for all integers between -5 and 256, when you create an int in that range you just get back a reference to the existing object. So it should be possible to change the value of 1. I suspect the behavior of Python, in this case, is undefined. :-) + +```py +>>> id(256) +10922528 +>>> a = 256 +>>> b = 256 +>>> id(a) +10922528 +>>> id(b) +10922528 +>>> id(257) +140084850247312 +>>> x = 257 +>>> y = 257 +>>> id(x) +140084850247440 +>>> id(y) +140084850247344 +``` + +Here the interpreter isn't smart enough while executing `y = 257` to recognize that we've already created an integer of the value `257,` and so it goes on to create another object in the memory. + +**Both `a` and `b` refer to the same object when initialized with same value in the same line.** + +```py +>>> a, b = 257, 257 +>>> id(a) +140640774013296 +>>> id(b) +140640774013296 +>>> a = 257 +>>> b = 257 +>>> id(a) +140640774013392 +>>> id(b) +140640774013488 +``` + +* When a and b are set to `257` in the same line, the Python interpreter creates a new object, then references the second variable at the same time. If you do it on separate lines, it doesn't "know" that there's already `257` as an object. +* It's a compiler optimization and specifically applies to the interactive environment. When you enter two lines in a live interpreter, they're compiled separately, therefore optimized separately. If you were to try this example in a `.py` file, you would not see the same behavior, because the file is compiled all at once. + +--- + +### > A tic-tac-toe where X wins in the first attempt! + +```py +# Let's initialize a row +row = [""]*3 #row i['', '', ''] +# Let's make a board +board = [row]*3 +``` + +**Output:** +```py +>>> board +[['', '', ''], ['', '', ''], ['', '', '']] +>>> board[0] +['', '', ''] +>>> board[0][0] +'' +>>> board[0][0] = "X" +>>> board +[['X', '', ''], ['X', '', ''], ['X', '', '']] +``` + +We didn't assign 3 "X"s or did we? + +#### 💡 Explanation: + +When we initialize `row` variable, this visualization explains what happens in the memory + +![image](/images/tic-tac-toe/after_row_initialized.png) + +And when the `board` is initialized by multiplying the `row`, this is what happens inside the memory (each of the elements `board[0]`, `board[1]` and `board[2]` is a reference to the same list referred by `row`) + +![image](/images/tic-tac-toe/after_board_initialized.png) + +We can avoid this scenario here by not using `row` variable to generate `board`. (Asked in [this](https://github.com/satwikkansal/wtfpython/issues/68) issue). + +```py +>>> board = [['']*3 for _ in range(3)] +>>> board[0][0] = "X" +>>> board +[['X', '', ''], ['', '', ''], ['', '', '']] +``` + +--- + +### > The sticky output function + +```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] +``` + +**Output:** +```py +>>> results +[0, 1, 2, 3, 4, 5, 6] +>>> funcs_results +[6, 6, 6, 6, 6, 6, 6] +``` +Even when the values of `x` were different in every iteration prior to appending `some_func` to `funcs`, all the functions return 6. + +//OR + +```py +>>> powers_of_x = [lambda x: x**i for i in range(10)] +>>> [f(2) for f in powers_of_x] +[512, 512, 512, 512, 512, 512, 512, 512, 512, 512] +``` + +#### 💡 Explanation + +- When defining a function inside a loop that uses the loop variable in its body, the loop function's closure is bound to the variable, not its value. So all of the functions use the latest value assigned to the variable for computation. + +- To get the desired behavior you can pass in the loop variable as a named variable to the function. **Why this works?** Because this will define the variable again within the function's scope. + + ```py + funcs = [] + for x in range(7): + def some_func(x=x): + return x + funcs.append(some_func) + ``` + + **Output:** + ```py + >>> funcs_results = [func() for func in funcs] + >>> funcs_results + [0, 1, 2, 3, 4, 5, 6] + ``` + +--- + +### > `is not ...` is not `is (not ...)` + +```py +>>> 'something' is not None +True +>>> 'something' is (not None) +False +``` + +#### 💡 Explanation + +- `is not` is a single binary operator, and has behavior different than using `is` and `not` separated. +- `is not` evaluates to `False` if the variables on either side of the operator point to the same object and `True` otherwise. + +--- + +### > The surprising comma + +**Output:** +```py +>>> def f(x, y,): +... print(x, y) +... +>>> def g(x=4, y=5,): +... print(x, y) +... +>>> def h(x, **kwargs,): + File "", line 1 + def h(x, **kwargs,): + ^ +SyntaxError: invalid syntax +>>> def h(*args,): + File "", line 1 + def h(*args,): + ^ +SyntaxError: invalid syntax +``` + +#### 💡 Explanation: + +- Trailing comma is not always legal in formal parameters list of a Python function. +- In Python, the argument list is defined partially with leading commas and partially with trailing commas. This conflict causes situations where a comma is trapped in the middle, and no rule accepts it. +- **Note:** The trailing comma problem is [fixed in Python 3.6](https://bugs.python.org/issue9232). The remarks in [this](https://bugs.python.org/issue9232#msg248399) post discuss in brief different usages of trailing commas in Python. + +--- + +### > Backslashes at the end of string + +**Output:** +``` +>>> print("\\ C:\\") +\ C:\ +>>> print(r"\ C:") +\ C: +>>> print(r"\ C:\") + + File "", line 1 + print(r"\ C:\") + ^ +SyntaxError: EOL while scanning string literal +``` + +#### 💡 Explanation + +- In a raw string literal, as indicated by the prefix `r`, the backslash doesn't have the special meaning. + ```py + >>> print(repr(r"wt\"f")) + 'wt\\"f' + ``` +- What the interpreter actually does, though, is simply change the behavior of backslashes, so they pass themselves and the following character through. That's why backslashes don't work at the end of a raw string. + +--- + +### > not knot! + +```py +x = True +y = False +``` + +**Output:** +```py +>>> not x == y +True +>>> x == not y + File "", line 1 + x == not y + ^ +SyntaxError: invalid syntax +``` + +#### 💡 Explanation: + +* Operator precedence affects how an expression is evaluated, and `==` operator has higher precedence than `not` operator in Python. +* So `not x == y` is equivalent to `not (x == y)` which is equivalent to `not (True == False)` finally evaluating to `True`. +* But `x == not y` raises a `SyntaxError` because it can be thought of being equivalent to `(x == not) y` and not `x == (not y)` which you might have expected at first sight. +* The parser expected the `not` token to be a part of the `not in` operator (because both `==` and `not in` operators have the same precedence), but after not being able to find an `in` token following the `not` token, it raises a `SyntaxError`. + +--- + +### > Half triple-quoted strings + +**Output:** +```py +>>> print('wtfpython''') +wtfpython +>>> print("wtfpython""") +wtfpython +>>> # The following statements raise `SyntaxError` +>>> # print('''wtfpython') +>>> # print("""wtfpython") +``` + +#### 💡 Explanation: ++ Python supports implicit [string literal concatenation](https://docs.python.org/2/reference/lexical_analysis.html#string-literal-concatenation), Example, + ``` + >>> print("wtf" "python") + wtfpython + >>> print("wtf" "") # or "wtf""" + wtf + ``` ++ `'''` and `"""` are also string delimiters in Python which causes a SyntaxError because the Python interpreter was expecting a terminating triple quote as delimiter while scanning the currently encountered triple quoted string literal. + +--- + +### > Midnight time doesn't exist? + +```py +from datetime import datetime + +midnight = datetime(2018, 1, 1, 0, 0) +midnight_time = midnight.time() + +noon = datetime(2018, 1, 1, 12, 0) +noon_time = noon.time() + +if midnight_time: + print("Time at midnight is", midnight_time) + +if noon_time: + print("Time at noon is", noon_time) +``` + +**Output:** +```sh +('Time at noon is', datetime.time(12, 0)) +``` +The midnight time is not printed. + +#### 💡 Explanation: + +Before Python 3.5, the boolean value for `datetime.time` object was considered to be `False` if it represented midnight in UTC. It is error-prone when using the `if obj:` syntax to check if the `obj` is null or some equivalent of "empty." + +--- + +### > What's wrong with booleans? + +1\. +```py +# A simple example to count the number of boolean and +# integers in an iterable of mixed data types. +mixed_list = [False, 1.0, "some_string", 3, True, [], False] +integers_found_so_far = 0 +booleans_found_so_far = 0 + +for item in mixed_list: + if isinstance(item, int): + integers_found_so_far += 1 + elif isinstance(item, bool): + booleans_found_so_far += 1 +``` + +**Output:** +```py +>>> booleans_found_so_far +0 +>>> integers_found_so_far +4 +``` + +2\. +```py +another_dict = {} +another_dict[True] = "JavaScript" +another_dict[1] = "Ruby" +another_dict[1.0] = "Python" +``` + +**Output:** +```py +>>> another_dict[True] +"Python" +``` + +3\. +```py +>>> some_bool = True +>>> "wtf"*some_bool +'wtf' +>>> some_bool = False +>>> "wtf"*some_bool +'' +``` + +#### 💡 Explanation: + +* Booleans are a subclass of `int` + ```py + >>> isinstance(True, int) + True + >>> isinstance(False, int) + True + ``` + +* The integer value of `True` is `1` and that of `False` is `0`. + ```py + >>> True == 1 == 1.0 and False == 0 == 0.0 + True + ``` + +* See this StackOverflow [answer](https://stackoverflow.com/a/8169049/4354153) for the rationale behind it. + +--- + +### > Class attributes and instance attributes + +1\. +```py +class A: + x = 1 + +class B(A): + pass + +class C(A): + pass +``` + +**Ouptut:** +```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 +(3, 2, 3) +>>> a = A() +>>> a.x, A.x +(3, 3) +>>> a.x += 1 +>>> a.x, A.x +(4, 3) +``` + +2\. +```py +class SomeClass: + some_var = 15 + some_list = [5] + another_list = [5] + def __init__(self, x): + self.some_var = x + 1 + self.some_list = self.some_list + [x] + self.another_list += [x] +``` + +**Output:** + +```py +>>> some_obj = SomeClass(420) +>>> some_obj.some_list +[5, 420] +>>> some_obj.another_list +[5, 420] +>>> another_obj = SomeClass(111) +>>> another_obj.some_list +[5, 111] +>>> another_obj.another_list +[5, 420, 111] +>>> another_obj.another_list is SomeClass.another_list +True +>>> another_obj.another_list is some_obj.another_list +True +``` + +#### 💡 Explanation: + +* Class variables and variables in class instances are internally handled as dictionaries of a class object. If a variable name is not found in the dictionary of the current class, the parent classes are searched for it. +* The `+=` operator modifies the mutable object in-place without creating a new object. So changing the attribute of one instance affects the other instances and the class attribute as well. + +--- + +### > yielding None + +```py +some_iterable = ('a', 'b') + +def some_func(val): + return "something" +``` + +**Output:** +```py +>>> [x for x in some_iterable] +['a', 'b'] +>>> [(yield x) for x in some_iterable] + at 0x7f70b0a4ad58> +>>> list([(yield x) for x in some_iterable]) +['a', 'b'] +>>> list((yield x) for x in some_iterable) +['a', None, 'b', None] +>>> list(some_func((yield x)) for x in some_iterable) +['a', 'something', 'b', 'something'] +``` + +#### 💡 Explanation: +- Source and explanation can be found here: https://stackoverflow.com/questions/32139885/yield-in-list-comprehensions-and-generator-expressions +- Related bug report: http://bugs.python.org/issue10544 + +--- + +### > Mutating the immutable! + +```py +some_tuple = ("A", "tuple", "with", "values") +another_tuple = ([1, 2], [3, 4], [5, 6]) +``` + +**Output:** +```py +>>> some_tuple[2] = "change this" +TypeError: 'tuple' object does not support item assignment +>>> another_tuple[2].append(1000) #This throws no error +>>> another_tuple +([1, 2], [3, 4], [5, 6, 1000]) +>>> another_tuple[2] += [99, 999] +TypeError: 'tuple' object does not support item assignment +>>> another_tuple +([1, 2], [3, 4], [5, 6, 1000, 99, 999]) +``` + +But I thought tuples were immutable... + +#### 💡 Explanation: + +* Quoting from https://docs.python.org/2/reference/datamodel.html + + > Immutable sequences + An object of an immutable sequence type cannot change once it is created. (If the object contains references to other objects, these other objects may be mutable and may be modified; however, the collection of objects directly referenced by an immutable object cannot change.) + +* `+=` operator changes the list in-place. The item assignment doesn't work, but when the exception occurs, the item has already been changed in place. + +--- + +### > The disappearing variable from outer scope + +```py +e = 7 +try: + raise Exception() +except Exception as e: + pass +``` + +**Output (Python 2.x):** +```py +>>> print(e) +# prints nothing +``` + +**Output (Python 3.x):** +```py +>>> print(e) +NameError: name 'e' is not defined +``` + +#### 💡 Explanation: + +* Source: https://docs.python.org/3/reference/compound_stmts.html#except + + When an exception has been assigned using `as` target, it is cleared at the end of the except clause. This is as if + + ```py + except E as N: + foo + ``` + + was translated into + + ```py + except E as N: + try: + foo + finally: + del N + ``` + + This means the exception must be assigned to a different name to be able to refer to it after the except clause. Exceptions are cleared because, with the traceback attached to them, they form a reference cycle with the stack frame, keeping all locals in that frame alive until the next garbage collection occurs. + +* The clauses are not scoped in Python. Everything in the example is present in the same scope, and the variable `e` got removed due to the execution of the `except` clause. The same is not the case with functions which have their separate inner-scopes. The example below illustrates this: + + ```py + def f(x): + del(x) + print(x) + + x = 5 + y = [5, 4, 3] + ``` + + **Output:** + ```py + >>>f(x) + UnboundLocalError: local variable 'x' referenced before assignment + >>>f(y) + UnboundLocalError: local variable 'x' referenced before assignment + >>> x + 5 + >>> y + [5, 4, 3] + ``` + +* In Python 2.x the variable name `e` gets assigned to `Exception()` instance, so when you try to print, it prints nothing. + + **Output (Python 2.x):** + ```py + >>> e + Exception() + >>> print e + # Nothing is printed! + ``` + +--- + +### > When True is actually False + +```py +True = False +if True == False: + print("I've lost faith in truth!") +``` + +**Output:** +``` +I've lost faith in truth! +``` + +#### 💡 Explanation: + +- Initially, Python used to have no `bool` type (people used 0 for false and non-zero value like 1 for true). Then they added `True`, `False`, and a `bool` type, but, for backward compatibility, they couldn't make `True` and `False` constants- they just were built-in variables. +- Python 3 was backward-incompatible, so it was now finally possible to fix that, and so this example won't work with Python 3.x! + +--- + +### > From filled to None in one instruction... + +```py +some_list = [1, 2, 3] +some_dict = { + "key_1": 1, + "key_2": 2, + "key_3": 3 +} + +some_list = some_list.append(4) +some_dict = some_dict.update({"key_4": 4}) +``` + +**Output:** +```py +>>> print(some_list) +None +>>> print(some_dict) +None +``` + +#### 💡 Explanation + +Most methods that modify the items of sequence/mapping objects like `list.append`, `dict.update`, `list.sort`, etc. modify the objects in-place and return `None`. The rationale behind this is to improve performance by avoiding making a copy of the object if the operation can be done in-place (Referred from [here](http://docs.python.org/2/faq/design.html#why-doesn-t-list-sort-return-the-sorted-list)) + +--- + +### > Subclass relationships * + +**Output:** +```py +>>> from collections import Hashable +>>> issubclass(list, object) +True +>>> issubclass(object, Hashable) +True +>>> issubclass(list, Hashable) +False +``` + +The Subclass relationships were expected to be transitive, right? (i.e., if `A` is a subclass of `B`, and `B` is a subclass of `C`, the `A` _should_ a subclass of `C`) + +#### 💡 Explanation: + +* Subclass relationships are not necessarily transitive in Python. Anyone is allowed to define their own, arbitrary `__subclasscheck__` in a metaclass. +* When `issubclass(cls, Hashable)` is called, it simply looks for non-Falsey "`__hash__`" method in `cls` or anything it inherits from. +* Since `object` is hashable, but `list` is non-hashable, it breaks the transitivity relation. +* More detailed explanation can be found [here](https://www.naftaliharris.com/blog/python-subclass-intransitivity/). + +--- + +### > The mysterious key type conversion * + +```py +class SomeClass(str): + pass + +some_dict = {'s':42} +``` + +**Output:** +```py +>>> type(list(some_dict.keys())[0]) +str +>>> s = SomeClass('s') +>>> some_dict[s] = 40 +>>> some_dict # expected: Two different keys-value pairs +{'s': 40} +>>> type(list(some_dict.keys())[0]) +str +``` + +#### 💡 Explanation: + +* Both the object `s` and the string `"s"` hash to the same value because `SomeClass` inherits the `__hash__` method of `str` class. +* `SomeClass("s") == "s"` evaluates to `True` because `SomeClass` also inherits `__eq__` method from `str` class. +* Since both the objects hash to the same value and are equal, they are represented by the same key in the dictionary. +* For the desired behavior, we can redefine the `__eq__` method in `SomeClass` + ```py + class SomeClass(str): + def __eq__(self, other): + return ( + type(self) is SomeClass + and type(other) is SomeClass + and super().__eq__(other) + ) + + # When we define a custom __eq__, Python stops automatically inheriting the + # __hash__ method, so we need to define it as well + __hash__ = str.__hash__ + + some_dict = {'s':42} + ``` + + **Output:** + ```py + >>> s = SomeClass('s') + >>> some_dict[s] = 40 + >>> some_dict + {'s': 40, 's': 42} + >>> keys = list(some_dict.keys()) + >>> type(keys[0]), type(keys[1]) + (__main__.SomeClass, str) + ``` + +--- + +### > Let's see if you can guess this? + +```py +a, b = a[b] = {}, 5 +``` + +**Output:** +```py +>>> a +{5: ({...}, 5)} +``` + +#### 💡 Explanation: + +* According to [Python language reference](https://docs.python.org/2/reference/simple_stmts.html#assignment-statements), assignment statements have the form + ``` + (target_list "=")+ (expression_list | yield_expression) + ``` + and + > An assignment statement evaluates the expression list (remember that this can be a single expression or a comma-separated list, the latter yielding a tuple) and assigns the single resulting object to each of the target lists, from left to right. + +* The `+` in `(target_list "=")+` means there can be **one or more** target lists. In this case, target lists are `a, b` and `a[b]` (note the expression list is exactly one, which in our case is `{}, 5`). + +* After the expression list is evaluated, it's value is unpacked to the target lists from **left to right**. So, in our case, first the `{}, 5` tuple is unpacked to `a, b` and we now have `a = {}` and `b = 5`. + +* `a` is now assigned to `{}` which is a mutable object. + +* The second target list is `a[b]` (you may expect this to throw an error because both `a` and `b` have not been defined in the statements before. But remember, we just assigned `a` to `{}` and `b` to `5`). + +* Now, we are setting the key `5` in the dictionary to the tuple `({}, 5)` creating a circular reference (the `{...}` in the output refers to the same object that `a` is already referencing). Another simpler example of circular reference could be + ```py + >>> some_list = some_list[0] = [0] + >>> some_list + [[...]] + >>> some_list[0] + [[...]] + >>> some_list is some_list[0] + True + >>> some_list[0][0][0][0][0][0] == some_list + True + ``` + Similar is the case in our example (`a[b][0]` is the same object as `a`) + +* So to sum it up, you can break the example down to + ```py + a, b = {}, 5 + a[b] = a, b + ``` + And the circular reference can be justified by the fact that `a[b][0]` is the same object as `a` + ```py + >>> a[b][0] is a + True + ``` + +--- + +--- + +## Section: Appearances are deceptive! + +### > Skipping lines? + +**Output:** +```py +>>> value = 11 +>>> valuе = 32 +>>> value +11 +``` + +Wut? + +**Note:** The easiest way to reproduce this is to simply copy the statements from the above snippet and paste them into your file/shell. + +#### 💡 Explanation + +Some non-Western characters look identical to letters in the English alphabet but are considered distinct by the interpreter. + +```py +>>> ord('е') # cyrillic 'e' (Ye) +1077 +>>> ord('e') # latin 'e', as used in English and typed using standard keyboard +101 +>>> 'е' == 'e' +False + +>>> value = 42 # latin e +>>> valuе = 23 # cyrillic 'e', Python 2.x interpreter would raise a `SyntaxError` here +>>> value +42 +``` + +The built-in `ord()` function returns a character's Unicode [code point](https://en.wikipedia.org/wiki/Code_point), and different code positions of Cyrillic 'e' and Latin 'e' justify the behavior of the above example. + +--- + +### > Teleportation * + +```py +import numpy as np + +def energy_send(x): + # Initializing a numpy array + np.array([float(x)]) + +def energy_receive(): + # Return an empty numpy array + return np.empty((), dtype=np.float).tolist() +``` + +**Output:** +```py +>>> energy_send(123.456) +>>> energy_receive() +123.456 +``` + +Where's the Nobel Prize? + +#### 💡 Explanation: + +* Notice that the numpy array created in the `energy_send` function is not returned, so that memory space is free to reallocate. +* `numpy.empty()` returns the next free memory slot without reinitializing it. This memory spot just happens to be the same one that was just freed (usually, but not always). + +--- + +### > Well, something is fishy... + +```py +def square(x): + """ + A simple function to calculate the square of a number by addition. + """ + sum_so_far = 0 + for counter in range(x): + sum_so_far = sum_so_far + x + return sum_so_far +``` + +**Output (Python 2.x):** + +```py +>>> square(10) +10 +``` + +Shouldn't that be 100? + +**Note:** If you're not able to reproduce this, try running the file [mixed_tabs_and_spaces.py](/mixed_tabs_and_spaces.py) via the shell. + +#### 💡 Explanation + +* **Don't mix tabs and spaces!** The character just preceding return is a "tab", and the code is indented by multiple of "4 spaces" elsewhere in the example. +* This is how Python handles tabs: + > First, tabs are replaced (from left to right) by one to eight spaces such that the total number of characters up to and including the replacement is a multiple of eight <...> +* So the "tab" at the last line of `square` function is replaced with eight spaces, and it gets into the loop. +* Python 3 is kind enough to throw an error for such cases automatically. + + **Output (Python 3.x):** + ```py + TabError: inconsistent use of tabs and spaces in indentation + ``` + +--- + +--- + +## Section: Watch out for the landmines! + + +### > Modifying a dictionary while iterating over it + +```py +x = {0: None} + +for i in x: + del x[i] + x[i+1] = None + print(i) +``` + +**Output (Python 2.7- Python 3.5):** + +``` +0 +1 +2 +3 +4 +5 +6 +7 +``` + +Yes, it runs for exactly **eight** times and stops. + +#### 💡 Explanation: + +* Iteration over a dictionary that you edit at the same time is not supported. +* It runs eight times because that's the point at which the dictionary resizes to hold more keys (we have eight deletion entries, so a resize is needed). This is actually an implementation detail. +* How deleted keys are handled and when the resize occurs might be different for different Python implementations. +* For more information, you may refer to this StackOverflow [thread](https://stackoverflow.com/questions/44763802/bug-in-python-dict) explaining a similar example in detail. + +--- + +### > Stubborn `del` operator * + +```py +class SomeClass: + def __del__(self): + print("Deleted!") +``` + +**Output:** +1\. +```py +>>> x = SomeClass() +>>> y = x +>>> del x # this should print "Deleted!" +>>> del y +Deleted! +``` + +Phew, deleted at last. You might have guessed what saved from `__del__` being called in our first attempt to delete `x`. Let's add more twist to the example. + +2\. +```py +>>> x = SomeClass() +>>> y = x +>>> del x +>>> y # check if y exists +<__main__.SomeClass instance at 0x7f98a1a67fc8> +>>> del y # Like previously, this should print "Deleted!" +>>> globals() # oh, it didn't. Let's check all our global variables and confirm +Deleted! +{'__builtins__': , 'SomeClass': , '__package__': None, '__name__': '__main__', '__doc__': None} +``` + +Okay, now it's deleted :confused: + +#### 💡 Explanation: ++ `del x` doesn’t directly call `x.__del__()`. ++ Whenever `del x` is encountered, Python decrements the reference count for `x` by one, and `x.__del__()` when x’s reference count reaches zero. ++ In the second output snippet, `y.__del__()` was not called because the previous statement (`>>> y`) in the interactive interpreter created another reference to the same object, thus preventing the reference count to reach zero when `del y` was encountered. ++ Calling `globals` caused the existing reference to be destroyed and hence we can see "Deleted!" being printed (finally!). + +--- + +### > Deleting a list item while iterating + +```py +list_1 = [1, 2, 3, 4] +list_2 = [1, 2, 3, 4] +list_3 = [1, 2, 3, 4] +list_4 = [1, 2, 3, 4] + +for idx, item in enumerate(list_1): + del item + +for idx, item in enumerate(list_2): + list_2.remove(item) + +for idx, item in enumerate(list_3[:]): + list_3.remove(item) + +for idx, item in enumerate(list_4): + list_4.pop(idx) +``` + +**Output:** +```py +>>> list_1 +[1, 2, 3, 4] +>>> list_2 +[2, 4] +>>> list_3 +[] +>>> list_4 +[2, 4] +``` + +Can you guess why the output is `[2, 4]`? + +#### 💡 Explanation: + +* It's never a good idea to change the object you're iterating over. The correct way to do so is to iterate over a copy of the object instead, and `list_3[:]` does just that. + + ```py + >>> some_list = [1, 2, 3, 4] + >>> id(some_list) + 139798789457608 + >>> id(some_list[:]) # Notice that python creates new object for sliced list. + 139798779601192 + ``` + +**Difference between `del`, `remove`, and `pop`:** +* `del var_name` just removes the binding of the `var_name` from the local or global namespace (That's why the `list_1` is unaffected). +* `remove` removes the first matching value, not a specific index, raises `ValueError` if the value is not found. +* `pop` removes the element at a specific index and returns it, raises `IndexError` if an invalid index is specified. + +**Why the output is `[2, 4]`?** +- The list iteration is done index by index, and when we remove `1` from `list_2` or `list_4`, the contents of the lists are now `[2, 3, 4]`. The remaining elements are shifted down, i.e., `2` is at index 0, and `3` is at index 1. Since the next iteration is going to look at index 1 (which is the `3`), the `2` gets skipped entirely. A similar thing will happen with every alternate element in the list sequence. + +* Refer to this StackOverflow [thread](https://stackoverflow.com/questions/45946228/what-happens-when-you-try-to-delete-a-list-element-while-iterating-over-it) explaining the example +* See also this nice StackOverflow [thread](https://stackoverflow.com/questions/45877614/how-to-change-all-the-dictionary-keys-in-a-for-loop-with-d-items) for a similar example related to dictionaries in Python. + +--- + +### > Loop variables leaking out! + +1\. +```py +for x in range(7): + if x == 6: + print(x, ': for x inside loop') +print(x, ': x in global') +``` + +**Output:** +```py +6 : for x inside loop +6 : x in global +``` + +But `x` was never defined outside the scope of for loop... + +2\. +```py +# This time let's initialize x first +x = -1 +for x in range(7): + if x == 6: + print(x, ': for x inside loop') +print(x, ': x in global') +``` + +**Output:** +```py +6 : for x inside loop +6 : x in global +``` + +3\. +``` +x = 1 +print([x for x in range(5)]) +print(x, ': x in global') +``` + +**Output (on Python 2.x):** +``` +[0, 1, 2, 3, 4] +(4, ': x in global') +``` + +**Output (on Python 3.x):** +``` +[0, 1, 2, 3, 4] +1 : x in global +``` + +#### 💡 Explanation: + +- In Python, for-loops use the scope they exist in and leave their defined loop-variable behind. This also applies if we explicitly defined the for-loop variable in the global namespace before. In this case, it will rebind the existing variable. + +- The differences in the output of Python 2.x and Python 3.x interpreters for list comprehension example can be explained by following change documented in [What’s New In Python 3.0](https://docs.python.org/3/whatsnew/3.0.html) documentation: + + > "List comprehensions no longer support the syntactic form `[... for var in item1, item2, ...]`. Use `[... for var in (item1, item2, ...)]` instead. Also, note that list comprehensions have different semantics: they are closer to syntactic sugar for a generator expression inside a `list()` constructor, and in particular the loop control variables are no longer leaked into the surrounding scope." + +--- + +### > Beware of default mutable arguments! + +```py +def some_func(default_arg=[]): + default_arg.append("some_string") + return default_arg +``` + +**Output:** +```py +>>> some_func() +['some_string'] +>>> some_func() +['some_string', 'some_string'] +>>> some_func([]) +['some_string'] +>>> some_func() +['some_string', 'some_string', 'some_string'] +``` + +#### 💡 Explanation: + +- The default mutable arguments of functions in Python aren't really initialized every time you call the function. Instead, the recently assigned value to them is used as the default value. When we explicitly passed `[]` to `some_func` as the argument, the default value of the `default_arg` variable was not used, so the function returned as expected. + + ```py + def some_func(default_arg=[]): + default_arg.append("some_string") + return default_arg + ``` + + **Output:** + ```py + >>> some_func.__defaults__ #This will show the default argument values for the function + ([],) + >>> some_func() + >>> some_func.__defaults__ + (['some_string'],) + >>> some_func() + >>> some_func.__defaults__ + (['some_string', 'some_string'],) + >>> some_func([]) + >>> some_func.__defaults__ + (['some_string', 'some_string'],) + ``` + +- A common practice to avoid bugs due to mutable arguments is to assign `None` as the default value and later check if any value is passed to the function corresponding to that argument. Example: + + ```py + def some_func(default_arg=None): + if not default_arg: + default_arg = [] + default_arg.append("some_string") + return default_arg + ``` + +--- + +### > Catching the Exceptions + +```py +some_list = [1, 2, 3] +try: + # This should raise an ``IndexError`` + print(some_list[4]) +except IndexError, ValueError: + print("Caught!") + +try: + # This should raise a ``ValueError`` + some_list.remove(4) +except IndexError, ValueError: + print("Caught again!") +``` + +**Output (Python 2.x):** +```py +Caught! + +ValueError: list.remove(x): x not in list +``` + +**Output (Python 3.x):** +```py + File "", line 3 + except IndexError, ValueError: + ^ +SyntaxError: invalid syntax +``` + +#### 💡 Explanation + +* To add multiple Exceptions to the except clause, you need to pass them as parenthesized tuple as the first argument. The second argument is an optional name, which when supplied will bind the Exception instance that has been raised. Example, + ```py + some_list = [1, 2, 3] + try: + # This should raise a ``ValueError`` + some_list.remove(4) + except (IndexError, ValueError), e: + print("Caught again!") + print(e) + ``` + **Output (Python 2.x):** + ``` + Caught again! + list.remove(x): x not in list + ``` + **Output (Python 3.x):** + ```py + File "", line 4 + except (IndexError, ValueError), e: + ^ + IndentationError: unindent does not match any outer indentation level + ``` + +* Separating the exception from the variable with a comma is deprecated and does not work in Python 3; the correct way is to use `as`. Example, + ```py + some_list = [1, 2, 3] + try: + some_list.remove(4) + + except (IndexError, ValueError) as e: + print("Caught again!") + print(e) + ``` + **Output:** + ``` + Caught again! + list.remove(x): x not in list + ``` + +--- + +### > Same operands, different story! + +1\. +```py +a = [1, 2, 3, 4] +b = a +a = a + [5, 6, 7, 8] +``` + +**Output:** +```py +>>> a +[1, 2, 3, 4, 5, 6, 7, 8] +>>> b +[1, 2, 3, 4] +``` + +2\. +```py +a = [1, 2, 3, 4] +b = a +a += [5, 6, 7, 8] +``` + +**Output:** +```py +>>> a +[1, 2, 3, 4, 5, 6, 7, 8] +>>> b +[1, 2, 3, 4, 5, 6, 7, 8] +``` + +#### 💡 Explanation: + +* `a += b` doesn't always behave the same way as `a = a + b`. Classes *may* implement the *`op=`* operators differently, and lists do this. + +* The expression `a = a + [5,6,7,8]` generates a new list and sets `a`'s reference to that new list, leaving `b` unchanged. + +* The expression `a += [5,6,7,8]` is actually mapped to an "extend" function that operates on the list such that `a` and `b` still point to the same list that has been modified in-place. + +--- + +### > The out of scope variable + +```py +a = 1 +def some_func(): + return a + +def another_func(): + a += 1 + return a +``` + +**Output:** +```py +>>> some_func() +1 +>>> another_func() +UnboundLocalError: local variable 'a' referenced before assignment +``` + +#### 💡 Explanation: +* When you make an assignment to a variable in scope, it becomes local to that scope. So `a` becomes local to the scope of `another_func`, but it has not been initialized previously in the same scope which throws an error. +* Read [this](http://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. +* To modify the outer scope variable `a` in `another_func`, use `global` keyword. + ```py + def another_func() + global a + a += 1 + return a + ``` + + **Output:** + ```py + >>> another_func() + 2 + ``` + +--- + +### > Be careful with chained operations + +```py +>>> (False == False) in [False] # makes sense +False +>>> False == (False in [False]) # makes sense +False +>>> False == False in [False] # now what? +True + +>>> True is False == False +False +>>> False is False is False +True + +>>> 1 > 0 < 1 +True +>>> (1 > 0) < 1 +False +>>> 1 > (0 < 1) +False +``` + +#### 💡 Explanation: + +As per https://docs.python.org/2/reference/expressions.html#not-in + +> Formally, if a, b, c, ..., y, z are expressions and op1, op2, ..., opN are comparison operators, then a op1 b op2 c ... y opN z is equivalent to a op1 b and b op2 c and ... y opN z, except that each expression is evaluated at most once. + +While such behavior might seem silly to you in the above examples, it's fantastic with stuff like `a == b == c` and `0 <= x <= 100`. + +* `False is False is False` is equivalent to `(False is False) and (False is False)` +* `True is False == False` is equivalent to `True is False and False == False` and since the first part of the statement (`True is False`) evaluates to `False`, the overall expression evaluates to `False`. +* `1 > 0 < 1` is equivalent to `1 > 0 and 0 < 1` which evaluates to `True`. +* The expression `(1 > 0) < 1` is equivalent to `True < 1` and + ```py + >>> int(True) + 1 + >>> True + 1 #not relevant for this example, but just for fun + 2 + ``` + So, `1 < 1` evaluates to `False` + +--- + +### > Name resolution ignoring class scope + +1\. +```py +x = 5 +class SomeClass: + x = 17 + y = (x for i in range(10)) +``` + +**Output:** +```py +>>> list(SomeClass.y)[0] +5 +``` + +2\. +```py +x = 5 +class SomeClass: + x = 17 + y = [x for i in range(10)] +``` + +**Output (Python 2.x):** +```py +>>> SomeClass.y[0] +17 +``` + +**Output (Python 3.x):** +```py +>>> SomeClass.y[0] +5 +``` + +#### 💡 Explanation +- Scopes nested inside class definition ignore names bound at the class level. +- A generator expression has its own scope. +- Starting from Python 3.X, list comprehensions also have their own scope. + +--- + +### > Needle in a Haystack + +1\. +```py +x, y = (0, 1) if True else None, None +``` + +**Output:** +``` +>>> x, y # expected (0, 1) +((0, 1), None) +``` + +Almost every Python programmer has faced a similar situation. + +2\. +```py +t = ('one', 'two') +for i in t: + print(i) + +t = ('one') +for i in t: + print(i) + +t = () +print(t) +``` + +**Output:** +```py +one +two +o +n +e +tuple() +``` + +#### 💡 Explanation: +* For 1, the correct statement for expected behavior is `x, y = (0, 1) if True else (None, None)`. +* For 2, the correct statement for expected behavior is `t = ('one',)` or `t = 'one',` (missing comma) otherwise the interpreter considers `t` to be a `str` and iterates over it character by character. +* `()` is a special token and denotes empty `tuple`. + +--- + +--- + + +## Section: The Hidden treasures! + +This section contains few of the lesser-known interesting things about Python that most beginners like me are unaware of (well, not anymore). + +### > Okay Python, Can you make me fly? * + +Well, here you go + +```py +import antigravity +``` + +**Output:** +Sshh.. It's a super secret. + +#### 💡 Explanation: ++ `antigravity` module is one of the few easter eggs released by Python developers. ++ `import antigravity` opens up a web browser pointing to the [classic XKCD comic](http://xkcd.com/353/) about Python. ++ Well, there's more to it. There's **another easter egg inside the easter egg**. If you look at the [code](https://github.com/python/cpython/blob/master/Lib/antigravity.py#L7-L17), there's a function defined that purports to implement the [XKCD's geohashing algorithm](https://xkcd.com/426/). + +--- + +### > `goto`, but why? * + +```py +from goto import goto, label +for i in range(9): + for j in range(9): + for k in range(9): + print("I'm trapped, please rescue!") + if k == 2: + goto .breakout # breaking out from a deeply nested loop +label .breakout +print("Freedom!") +``` + +**Output (Python 2.3):** +```py +I'm trapped, please rescue! +I'm trapped, please rescue! +Freedom! +``` + +#### 💡 Explanation: +- A working version of `goto` in Python was [announced](https://mail.python.org/pipermail/python-announce-list/2004-April/002982.html) as an April Fool's joke on 1st April 2004. +- Current versions of Python do not have this module. +- Although it works, but please don't use it. Here's the [reason](https://docs.python.org/3/faq/design.html#why-is-there-no-goto) to why `goto` is not present in Python. + +--- + +### > Brace yourself! * + +If you are one of the people who doesn't like using whitespace in Python to denote scopes, you can use the C-style {} by importing, + +```py +from __future__ import braces +``` + +**Output:** +```py + File "some_file.py", line 1 + from __future__ import braces +SyntaxError: not a chance +``` + +Braces? No way! If you think that's disappointing, use Java. + +#### 💡 Explanation: ++ The `__future__` module is normally used to provide features from future versions of Python. The "future" here is however ironic. ++ This is an easter egg concerned with the community's feelings on this issue. + +--- + +### > Let's meet Friendly Language Uncle For Life * + +**Output (Python 3.x)** +```py +>>> from __future__ import barry_as_FLUFL +>>> "Ruby" != "Python" # there's no doubt about it + File "some_file.py", line 1 + "Ruby" != "Python" + ^ +SyntaxError: invalid syntax + +>>> "Ruby" <> "Python" +True +``` + +There we go. + +#### 💡 Explanation: +- This is relevant to [PEP-401](https://www.python.org/dev/peps/pep-0401/) released on April 1, 2009 (now you know, what it means). +- Quoting from the PEP-401 + > Recognized that the != inequality operator in Python 3.0 was a horrible, finger pain inducing mistake, the FLUFL reinstates the <> diamond operator as the sole spelling. +- There were more things that Uncle Barry had to share in the PEP; you can read them [here](https://www.python.org/dev/peps/pep-0401/). + +--- + +### > Even Python understands that love is complicated * + +```py +import this +``` + +Wait, what's **this**? `this` is love :heart: + +**Output:** +``` +The Zen of Python, by Tim Peters + +Beautiful is better than ugly. +Explicit is better than implicit. +Simple is better than complex. +Complex is better than complicated. +Flat is better than nested. +Sparse is better than dense. +Readability counts. +Special cases aren't special enough to break the rules. +Although practicality beats purity. +Errors should never pass silently. +Unless explicitly silenced. +In the face of ambiguity, refuse the temptation to guess. +There should be one-- and preferably only one --obvious way to do it. +Although that way may not be obvious at first unless you're Dutch. +Now is better than never. +Although never is often better than *right* now. +If the implementation is hard to explain, it's a bad idea. +If the implementation is easy to explain, it may be a good idea. +Namespaces are one honking great idea -- let's do more of those! +``` + +It's the Zen of Python! + +```py +>>> love = this +>>> this is love +True +>>> love is True +False +>>> love is False +False +>>> love is not True or False +True +>>> love is not True or False; love is love # Love is complicated +True +``` + +#### 💡 Explanation: + +* `this` module in Python is an easter egg for The Zen Of Python ([PEP 20](https://www.python.org/dev/peps/pep-0020)). +* And if you think that's already interesting enough, check out the implementation of [this.py](https://hg.python.org/cpython/file/c3896275c0f6/Lib/this.py). Interestingly, the code for the Zen violates itself (and that's probably the only place where this happens). +* Regarding the statement `love is not True or False; love is love`, ironic but it's self-explanatory. + +--- + +### > Yes, it exists! + +**The `else` clause for loops.** One typical example might be: + +```py + def does_exists_num(l, to_find): + for num in l: + if num == to_find: + print("Exists!") + break + else: + print("Does not exist") +``` + +**Output:** +```py +>>> some_list = [1, 2, 3, 4, 5] +>>> does_exists_num(some_list, 4) +Exists! +>>> does_exists_num(some_list, -1) +Does not exist +``` + +**The `else` clause in exception handling.** An example, + +```py +try: + pass +except: + print("Exception occurred!!!") +else: + print("Try block executed successfully...") +``` + +**Output:** +```py +Try block executed successfully... +``` + +#### 💡 Explanation: +- The `else` clause after a loop is executed only when there's no explicit `break` after all the iterations. +- `else` clause after try block is also called "completion clause" as reaching the `else` clause in a `try` statement means that the try block actually completed successfully. + +--- + +### > Inpinity * + +The spelling is intended. Please, don't submit a patch for this. + +**Output (Python 3.x):** +```py +>>> infinity = float('infinity') +>>> hash(infinity) +314159 +>>> hash(float('-inf')) +-314159 +``` + +#### 💡 Explanation: +- Hash of infinity is 10⁵ x π. +- Interestingly, the hash of `float('-inf')` is "-10⁵ x π" in Python 3, whereas "-10⁵ x e" in Python 2. + +--- + +### > Mangling time! * + +```py +class Yo(object): + def __init__(self): + self.__honey = True + self.bitch = True +``` + +**Output:** +```py +>>> Yo().bitch +True +>>> Yo().__honey +AttributeError: 'Yo' object has no attribute '__honey' +>>> Yo()._Yo__honey +True +``` + +Why did `Yo()._Yo__honey` work? Only Indian readers would understand. + +#### 💡 Explanation: + +* [Name Mangling](https://en.wikipedia.org/wiki/Name_mangling) is used to avoid naming collisions between different namespaces. +* In Python, the interpreter modifies (mangles) the class member names starting with `__` (double underscore) and not ending with more than one trailing underscore by adding `_NameOfTheClass` in front. +* So, to access `__honey` attribute, we are required to append `_Yo` to the front which would prevent conflicts with the same name attribute defined in any other class. + +--- + +--- + +## Section: Miscellaneous + + +### > `+=` is faster + +```py +# using "+", three strings: +>>> timeit.timeit("s1 = s1 + s2 + s3", setup="s1 = ' ' * 100000; s2 = ' ' * 100000; s3 = ' ' * 100000", number=100) +0.25748300552368164 +# using "+=", three strings: +>>> timeit.timeit("s1 += s2 + s3", setup="s1 = ' ' * 100000; s2 = ' ' * 100000; s3 = ' ' * 100000", number=100) +0.012188911437988281 +``` + +#### 💡 Explanation: ++ `+=` is faster than `+` for concatenating more than two strings because the first string (example, `s1` for `s1 += s2 + s3`) is not destroyed while calculating the complete string. + +--- + +### > Let's make a giant string! + +```py +def add_string_with_plus(iters): + s = "" + for i in range(iters): + s += "xyz" + assert len(s) == 3*iters + +def add_bytes_with_plus(iters): + s = b"" + for i in range(iters): + s += b"xyz" + assert len(s) == 3*iters + +def add_string_with_format(iters): + fs = "{}"*iters + s = fs.format(*(["xyz"]*iters)) + assert len(s) == 3*iters + +def add_string_with_join(iters): + l = [] + for i in range(iters): + l.append("xyz") + s = "".join(l) + assert len(s) == 3*iters + +def convert_list_to_string(l, iters): + s = "".join(l) + assert len(s) == 3*iters +``` + +**Output:** +```py +>>> timeit(add_string_with_plus(10000)) +1000 loops, best of 3: 972 µs per loop +>>> timeit(add_bytes_with_plus(10000)) +1000 loops, best of 3: 815 µs per loop +>>> timeit(add_string_with_format(10000)) +1000 loops, best of 3: 508 µs per loop +>>> timeit(add_string_with_join(10000)) +1000 loops, best of 3: 878 µs per loop +>>> l = ["xyz"]*10000 +>>> timeit(convert_list_to_string(l, 10000)) +10000 loops, best of 3: 80 µs per loop +``` + +Let's increase the number of iterations by a factor of 10. + +```py +>>> timeit(add_string_with_plus(100000)) # Linear increase in execution time +100 loops, best of 3: 9.75 ms per loop +>>> timeit(add_bytes_with_plus(100000)) # Quadratic increase +1000 loops, best of 3: 974 ms per loop +>>> timeit(add_string_with_format(100000)) # Linear increase +100 loops, best of 3: 5.25 ms per loop +>>> timeit(add_string_with_join(100000)) # Linear increase +100 loops, best of 3: 9.85 ms per loop +>>> l = ["xyz"]*100000 +>>> timeit(convert_list_to_string(l, 100000)) # Linear increase +1000 loops, best of 3: 723 µs per loop +``` + +#### 💡 Explanation +- You can read more about [timeit](https://docs.python.org/3/library/timeit.html) from here. It is generally used to measure the execution time of snippets. +- Don't use `+` for generating long strings — In Python, `str` is immutable, so the left and right strings have to be copied into the new string for every pair of concatenations. If you concatenate four strings of length 10, you'll be copying (10+10) + ((10+10)+10) + (((10+10)+10)+10) = 90 characters instead of just 40 characters. Things get quadratically worse as the number and size of the string increases (justified with the execution times of `add_bytes_with_plus` function) +- Therefore, it's advised to use `.format.` or `%` syntax (however, they are slightly slower than `+` for short strings). +- Or better, if already you've contents available in the form of an iterable object, then use `''.join(iterable_object)` which is much faster. +- `add_string_with_plus` didn't show a quadratic increase in execution time unlike `add_bytes_with_plus` because of the `+=` optimizations discussed in the previous example. Had the statement been `s = s + "x" + "y" + "z"` instead of `s += "xyz"`, the increase would have been quadratic. + ```py + def add_string_with_plus(iters): + s = "" + for i in range(iters): + s = s + "x" + "y" + "z" + assert len(s) == 3*iters + + >>> timeit(add_string_with_plus(10000)) + 100 loops, best of 3: 9.87 ms per loop + >>> timeit(add_string_with_plus(100000)) # Quadratic increase in execution time + 1 loops, best of 3: 1.09 s per loop + ``` + +--- + +### > Explicit typecast of strings + +```py +a = float('inf') +b = float('nan') +c = float('-iNf') #These strings are case-insensitive +d = float('nan') +``` + +**Output:** +```py +>>> a +inf +>>> b +nan +>>> c +-inf +>>> float('some_other_string') +ValueError: could not convert string to float: some_other_string +>>> a == -c #inf==inf +True +>>> None == None # None==None +True +>>> b == d #but nan!=nan +False +>>> 50/a +0.0 +>>> a/a +nan +>>> 23 + b +nan +``` + +#### 💡 Explanation: + +`'inf'` and `'nan'` are special strings (case-insensitive), which when explicitly typecasted to `float` type, are used to represent mathematical "infinity" and "not a number" respectively. + +--- + +### > 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 a semantically correct statement as strings are [sequences](https://docs.python.org/3/glossary.html#term-sequence)(iterables supporting element access using integer indices) in Python. + + `3 --0-- 5 == 8` and `--5 == 5` are both semantically correct statements and evaluate to `True`. + +* Given that `a` is a number, `++a` and `--a` are both valid Python statements but don't behave the same way as compared with similar statements in languages like C, C++ or Java. + ```py + >>> a = 5 + >>> a + 5 + >>> ++a + 5 + >>> --a + 5 + ``` + + **💡 Explanation:** + + There is no `++` operator in Python grammar. It is actually two `+` operators. + + `++a` parses as `+(+a)` which translates to `a`. Similarly, the output of the statement `--a` can be justified. + + This StackOverflow [thread](https://stackoverflow.com/questions/3654830/why-are-there-no-and-operators-in-python) discusses the rationale behind the absence of increment and decrement operators in Python. + +* Python uses 2 bytes for local variable storage in functions. In theory, this means that only 65536 variables can be defined in a function. However, python has a handy solution built in that can be used to store more than 2^16 variable names. The following code demonstrates what happens in the stack when more than 65536 local variables are defined (Warning: This code prints around 2^18 lines of text, so be prepared!): + ```py + import dis + exec(""" + def f(): + """ + """ + """.join(["X"+str(x)+"=" + str(x) for x in range(65539)])) + + f() + + print(dis.dis(f)) + ``` + +* Multiple Python threads won't run your *Python code* concurrently (yes you heard it right!). It may seem intuitive to spawn several threads and let them execute your Python code concurrently, but, because of the [Global Interpreter Lock](https://wiki.python.org/moin/GlobalInterpreterLock) in Python, all you're doing is making your threads execute on the same core turn by turn. Python threads are good for IO-bound tasks, but to achieve actual parallelization in Python for CPU-bound tasks, you might want to use the Python [multiprocessing](https://docs.python.org/2/library/multiprocessing.html) module. + +* List slicing with out of the bounds indices throws no errors + ```py + >>> some_list = [1, 2, 3, 4, 5] + >>> some_list[111:] + [] + ``` + +* `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](http://chris.improbable.org/2014/8/25/adventures-in-unicode-digits/) related to this behavior of Python. + +* `'abc'.count('') == 4`. Here's an approximate implementation of `count` method, which would make the things more clear + ```py + def count(s, sub): + result = 0 + for i in range(len(s) + 1 - len(sub)): + result += (s[i:i + len(sub)] == sub) + return result + ``` + The behavior is due to the matching of empty substring(`''`) with slices of length 0 in the original string. + +--- + +# Contributing + +All patches are Welcome! Please see [CONTRIBUTING.md](/CONTRIBUTING.md) for further details. + +For discussions, you can either create a new [issue](https://github.com/satwikkansal/wtfpython/issues/new) or ping on the Gitter [channel](https://gitter.im/wtfpython/Lobby) + +# Acknowledgements + +The idea and design for this collection were initially inspired by Denys Dovhan's awesome project [wtfjs](https://github.com/denysdovhan/wtfjs). The overwhelming support by the community gave it the shape it is in right now. + +#### Some nice Links! +* https://www.youtube.com/watch?v=sH4XF6pKKmk +* https://www.reddit.com/r/Python/comments/3cu6ej/what_are_some_wtf_things_about_python +* https://sopython.com/wiki/Common_Gotchas_In_Python +* https://stackoverflow.com/questions/530530/python-2-x-gotchas-and-landmines +* https://stackoverflow.com/questions/1011431/common-pitfalls-in-python +* https://www.python.org/doc/humor/ +* https://www.satwikkansal.xyz/archives/posts/python/My-Python-archives/ + +# 🎓 License + +[![CC 4.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 + +## Help + +If you have any wtfs, ideas or suggestions, please share. + +## Want to surprise your geeky pythonist friends? + +You can recommend wtfpython to your friends on Twitter and Linkedin by using these quick links, + +[Twitter](https://twitter.com/intent/tweet?url=https://github.com/satwikkansal/wtfpython&hastags=python,wtfpython) + | [Linkedin](https://www.linkedin.com/shareArticle?url=https://github.com/satwikkansal&title=What%20the%20f*ck%20Python!&summary=An%20interesting%20collection%20of%20subtle%20and%20tricky%20Python%20snippets.) + +## Need a pdf version? + +I've received a few requests for the pdf version of wtfpython. You can add your details [here](https://satwikkansal.xyz/wtfpython-pdf/) to get the pdf as soon as it is finished. + +## Follow Commit + +[![Commit id][commit-image]][commit-url] + +[commit-url]: https://github.com/satwikkansal/wtfpython/commit/145a194c8b138ee0f71593fef63290df601df8fb +[commit-image]: https://img.shields.io/badge/Commit-145a194-yellow.svg diff --git a/images/logo.png b/images/logo.png new file mode 100644 index 0000000000000000000000000000000000000000..014a63a4e4be41b28a5d14a12c6da0205f094a8b GIT binary patch literal 8317 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 MRXr7y((}mw2cnT^J^%m! literal 0 HcmV?d00001 diff --git a/images/string-intern/string_intern.png b/images/string-intern/string_intern.png new file mode 100644 index 0000000000000000000000000000000000000000..6511978ae5ce2ec78ea208d9824a552138d2a1a8 GIT binary patch literal 9731 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 literal 0 HcmV?d00001 diff --git a/images/tic-tac-toe.png b/images/tic-tac-toe.png new file mode 100644 index 0000000000000000000000000000000000000000..9c25117bfd33dc35ac62c71a5ca2bb908ab9ff56 GIT binary patch literal 7515 zcmb_>dpOf={QnF&6-h;M$WwScXdxoTNcKUv=yc{EIDjWo5L8J@%`xc`{Voj{;unLUEk~aey(f(+@Je%-|zci{T^VJbsaU)pLavXWB!=AOb`|c!OL7H?t_{W^JbO+XUIJ(SeO}ME7*+2cIQ1S>B zqQ*uKhO^_^x<}%-H;?wsStGq|+gvwWi`H8~xsPAIrl^96<_Szm!6aCO3Q=wY<;wG( z_N=(z+V)v6>TYMMgun`nibCsyz@iRJz~I*{EvlyyI|DD4oA>fs z>NO1M)+;4;rICm6iEGU+Zs1YtfU}>3BVcu}U>u~z?iH-G+j_b+$H1q)w$OT z?cWydPxGsLzL0&DvG}z!v^g?)%a$U1Zmmp~=4qF#17WTig}TOLK23^?_Bsw2-&*~H zd7Bd~_i`Mia)>RZc^6jt3i({L=Dl?un54iBr?7|3z%b^2r?n~&^1z?;?Ubfe!6JUN z;7b)46@ZCyjt@~{PuZh=OOuahz4YFID*--I3%%sX@gq;V_v%X zF(?5fUs zgAa-^N4fTq?opnx?N;?U|HbBp}q9=F0`hv zBHpf*tJZ(V!ZmFuv#a8Ubd*x$QEIoOK-)S$Zr584&MP zt+nNn0<+I%{%82vNjGg8^pFnYiFg=gskwMX82V9_s`_jwV2%42$HdmkCsqzh_x^!y zf-O$Z!%p6Y*{qH&Kk9JB!SUL1UP;va{?(zfc!V8owpO1J@WhB3R|;zR-TB!_$O6VX z;qKQs^l_GKJah!}rZqL^lnl#LWh0x!b6*VEU~7$d!I4lq zR#}{cpm|7KG)!5>!b+&JqsQS)H|>0H^E&iomA_cCHMARDY2!OG+5a3 zkCWg)X;EtCH~+b3F@ib92`XTQCUJ@}q&FcB80%7)tN*{WPW21>nu7AqLZ`24d4`s1 zOA37QT>Kqyl^Q0;shHgBR|{CJiTNh+`SHw)IEp@XkGHr^Ia?wzf5S9(m*8OtZ6A9@ zhBqi?K*f0fTFBsbS%W5$& zs)O*XN)mam++7l>QRVwY;`9l*<`2Ua8d3&3P;%T&a;Je42Z;wcIne5;)~HWqDY7j{0~s}9 zx%v7@z#)f!Nu+lfx4#hg&usxP78LsMwO(CQb~52R3_j}+0h|+YlSi*#yT+77x8Z`c zsl$iaj`Nc;(!7hhv_{FHFOmXeN;3=TlI|^mymRK&qZv4`(zR97XQhJ|aN@anapi=) z5iG8p^lHUp+C7n=2v+*6+so}+7v*qZ{U;;noDQvE+Umf3VV+B*EDzpU`jXrq49`p% zL&%i6R+Tes8DdJ;^v$0vQ?HMO!NKtRv z=nzQ>qCN!;2pl5od=?@v_)SO^MB+UEBKlokB~DC=M&iKeYZe&z(^kJG9x)rW@Ks)~ zO~D|jWTkGoWXvaP%D4M`!0>rzPF6l*$x;^J)$fdSpE+&9?NN~;#`@S`w>1;LTw-P- z7~!6!Pp70CXK7o_;_EbNa-pM` z*Q*Cg2T%UygTI%iF)S~6LOD28oBw6p^*njVF4|JIpe**nw@g(T{RSC$=XYMXRLDy; z{V}s=&##4DbWh&B0DZ#koXXHRr zgz0b<^vTWYg^dP+Drz|H(KabknwP)c(nzV#wqdNZK{$(a;dNWIZlkSXaijWnl;B&# z#A@c=wrtGSLCtM7$hoLnRv<9c^*<9X6^4lAdus$4lB73=Ro2fh!Z(t{_OeCUO!-Ze zDOKSy(<5T0Dx-SzJq-PT!rwQ7m4e|CY3(hi-<$67f0>x^QvMp*=+8){zfv{Dx1gz} zpW#Bbm{%N5LA@b?v5z)H@KY} zR6u(Fs_hc%tw=IU45Tm5Grm7(LLMsm&In(PtVO4c2gNAc5?c9boI;^<>vIrjU(-F) zsbRT6I`gJ{Dkz6YOUrMjkuqyfb=}yFRtBvknEVZXRp^sqp~ivkLSzLpyE3sP7AcE6 zp}lFIJLXt!)y?3CnSwuX!&c1gy@k*3O4c@{M5bLtn7F zue?sM;-$E(H_90JeN%%!fp2Yf(HRrzJ_5&Ru9CoN_qs1QtlFR3F%0dAjoPR)8SsBE zcMHGJYagS+VuWr~xsfc6WhN+XYlykLXdc$Z9~wA`R)+{KLU(^Lk~h!P za$a#R8#@_q_*i&?8PlWZ@Kdm3TSsr#j$h0Vc!#(kcW(Cbo!QCXBg?IwqHVr6RdVKM z*7ip$Mmn!R_LP-Gu<83;(^muavsnB*)%lP>7}WFTmT6xQ_@9R5w65EfxpY>I6w=e~ zQ}&{1=vfEAMksqC3b*fEK^szE??U3`2*p#ZCY#_5!(AM{&qi~wP|vBsEuh^x#C#3t z9IC*@=J~)0GVTbyz?hkM0>Uohv)VNN6lyQpvXas@gAapHf*C`bG<)cln! z6Pz)Y-*4L77vx2w&pY$;Z93{tKQPp$#+g1)_y?sJc*(GJesj%Dh8wg)!~JJY5P?6@`&6jt3|2Nw)kkdD`AE@`V$|IvdrOtkolT%Ue z-;)@Ho=kMcX(}hQ-Lgr60@`m*xSV1D(3@O5APFGR#)mDdb?k7E7!h0h*3Xcr#=r|n zfg*|D?&+3jb&dk+NSWQ~b=Cv7&D>TlibdI5oK~bGTccv9%F3|LUhLT_hZEvBMB0$968K_qR_<5uTi}grSi%ZOoR@?gB~o; zI$=l|1Rym6Fp3!$)8_yt(z{3zRpmCf*K{^2vkFD->)|wn+&h0)9M|V&%7q2algHFJRp3%lKU`@VMo#WnTVgEZ=;vnIr=BRgorP zYk63fx0XBVTV2NlcAnG@gZMs+^`Z+T)D+py@7xvoBiYH?x z$c`k$U`i?)w)RHMy}!$4N+N4b4W7Jx1XIvr8r;@&(F8;7a0uTt(i<4}?P|`PhTz8T zrXq(EkEe`ieOZR@*Z7ZFHrf|X5m?vs6ZZ%&a>yxGzoXPyJEArP$Ew~inSdc$Tv1NB zDZ_KSBV#oMQeW2AD|1MIO^S=`j3JI}Hy?~{Q8AnM4I8!#oYRRH=sxV`;cO1QE040Pa zVG8ngqYP;9N)1v%!wG^F9tD{yO8dgflR~tpoZp4 zxWn~2R6AF=;ACtOerX(g3!{NNYc=J^X^E!4sqJo^ehBTFpuP!n#D{bhW76(^zd$?) z*a?US4q=<9OJkg4`27Y*W8b=l885QU2hyi2&I3&e&If!ESz|+I&Clb8U5^aSgt_k$ z7Uoezc>f*qh76P`_a{c9DwNdzt5m ztTjLPHvz`fIEn6NaZ&MjV;9U-BqHC4kOg*$JId{jZhlOQrEN+I;>DpS-yFPzPG-M}f^9?(>dEe4dep^w=X;H73Pc&^D-89*$6X?V!7#0MMl$|c@v zMYPXO?jF@1P2A63p;I1-UH_>1N&q+mlpSC*L{94M8P#IS?jts8r!P8vg2CNP%3-CH zvmi>k94eP~)&H%MLtA$}lJm*WgcpMT0wL#<~jPmOt361f2HJ z=Y9^W(2^XkZwJ&9xB|L-bjMNbls;J01%s6EPyAQ{aOP{~3G{>Rf9Ib!^r*2NEoEeR z8xqJ_z}f7u$hg;aJB^m02wo68&hVaa_WZ!Ouay~a%G+$nHo-|XgA?h1u~BAA^A1T0 z-0hrwag~I-rmM^5#BRFK`NHdEx^MY`z`K~OxzG(;oU7ZceIQUU+gjAjKdQ_$HBa9R zVeGw*RVj|lW)79KjZ`dLeX8+rb(rxW34toJ)bX2Bma@c@Sal(;=Gb)6kumoJBHpEi zOW}%FI$gCV(-g>la>Q%!%*@wqlwYat+4#M{+OUC6Bkb#NK3h>Ua35Q%S{bbOChuHqkV?*sThr>-1e!c9e zB44wlkc%MUI+Jf?am<kwhd6g5!>n21^Xhu#At~gck(R|9+XCX{ zf#VSjPm>K!o)bb$JKzuRJGlj zF4=UieOC*mwz&qv5vP0cU+9;fh{fbC3WaK3H9N>nWvt!u890gecYjYSnoA_?bx~xm z%4N;oj{>7erh>SkV)A(0(3RAwSHxj@s8F>K%l9C69wKwqr=~i}=@zf6)Re+)_WatN zx;2&Z7Gd#8n8iIeY?O38ne<4x*RoQs$*D<}HzSE0s$fYZkGdaiv53PZ-WKp3Hj>+g zF8(h%b&Gl#cQPl7r-;iXYlhwHX*X-kin<6W;8YP;|BQ3cB{@n8)KGI(b!om|w<@Zi zP`oYvI=c5uHNyIwZ+~D9hNMvG{N2sWBi83R+P7yb&G#D%rB2ZrCJByEDP{A~34IRN z62mpmX8nGiJRI?=S5=y4(gNT`9dX2VeQuL;q_6FC2-t7(7*9LEuT~3!!hCHksHqcXL-p8eZ z0#)AIot4S)$xm}B=YsWD*LjUOQO3npk5bOa_x1Q!OSWAG*Hj;H-x zVw6^``MY4fpPVLCxih>v)L=OHNopp`YET2smSI&%2|U(g?hWLt(5H+aWNR(#4iE;0 zsiwmy``M`Rw~^Az$Y%BAO~@fO-^h#k8-asbFLZ}`E;JWk*agC*{S9l|(|PbtK`d@q zH{ODO^Vca<9LQJ#Nu2&Rl-l~>ofjgCw2-uU{N$;Njs8x9;!Rt~7DaAN?IG0lCeDwQ z>y|guEPt$*9;Mdmn=Zv(Zg3oJp$*FC=us7ph8MP!0K)A5h42IH$QR1{8joh7@i2() zjVgKVmiU~g!B1k#k^(A7jXu(P_z>G!%zW~OJfU#otH@p*kChpulE?p?>bpMm?6~{V z-VX|q;(_OIo<(1Qs|sEvb?n&o;KkQyS$Mx-2xJ}aC-KJr*mbGaM&yNxR_xexL*;v| zL|nd7%YM@({EP==VW?CCMuKs}cSJN3`lHUa?(NNlum|XmDVBCP_|tr$NA*(PLnk$9Dkk#;9!AOW#i)_ekar21(A2fGk0&IS7QOZIyA`bG~Gj&$O zAvZA6?Kl`hHGAyR;f2}#iD4TXc8TRR&Q4ksf=6BAn}b35lFj5ZMvh#vF~ zA*Sm7b-(4(jb^~*$m1w_c)qBdi~!GmC3R^(c>hD>Gp)}YqI<%b72f+7b;HA%C%?a5 z9?UT+?nNghKC8(+Oq``o6Pja!f1GujN=zYj^9>s=?i@r{0{y_haC+{N#m3Ig4dv!( z^?0paLLs*8UH z&)Ofau2Ey5(43iL7DBkoc+FYg)jTH%ewhQ~sCC%xr+^50d% zT}j;n``EZRk}3*3VqjN!Z=q_prjd*0Mk3-$osaam2c5qobBf=^fT8M`Vqhd%!&&X) zh3J{Yh$_;iQhMBx-V6_-uev41coenpUlH`U;_Uv}8uQT{OVdwQ>f`M2K9*w$WeUxH zJ4rB4KuJBE(Ro+7rdu!I`fUDx7X&uHH+tnMVPdNEf+MCsA*X9X2alIV>ap#evM5wt zPz)UN=#0IY=(Cp{e)AbufqYcrBiC;hx6K|@ir0`%?7ZzG?B*q#2n@Yvp4 z$zOwa6N2j5Ij)BLwOg^sd)(0B^RaE@R`!G=B35K!is*LRoKnpH(EtKzceAiNVzV-* z_$205)Y?@AZJi$6Q0Z6Q4I=nR?~K3rsLn%-|L?v`A|0smsg)O^bf4VO7WX6ltE9wf zwkFHjryLv{3wT^op|mle><>Y=|C!2Q5L760@}btrlih!cKpJ zw$xKqEwZLt=kHUGbwh|o^+QEoBT66cRifZr7QY!!zt8CU0okUybQ3dfU_Gk2__0f# zYZ(Cs)|;4af(u{uK*8h%DZmeAA4 z$9R8l87F(y>TEUXQGW>{v9Fmg>=&dx6$`Eu+W*;SKTeV&viJ;3%$@3gbNpxz3o|6eG?)qd-$i2P@##99Oh1*u zsWDSJ|J~=|RuZIpfNKH+6VC~|MSzL_XK(T05SL`clUMz}&#Z9V(qEvk#Q5L;@4jc! zEwxLPQYDoh8>ktKk`-~lDmecegnj)K`y(av64?z~edR0(aH@3L0Hp&&ICbA~k;LTl ztK$G?r-c>4y5Ug~53Pbst)S7ThxwEGZY}mzqiLZfd~xsDhWABF__k@~7K&fb%a!7G zMw+{oR2qbO2Y({^pMOPBfF4!^Nf5^_ z9@;((M$wr5e)~e?1xZ?Pj1;rSWO$S6uWVosNCIm>iv>hU9&(019c4d^saR-8jeoo* z{m)y47#txy2&N2QQMw8^Ph;gM^AyMcc**6sn?a+vRQsQtT71iGc zedDLpk;6n{=D7d!m~m~UIrS|Dqy(54u!Q(RASh(+cK}(AOrO&yKJtoR4_58W0&Hz= zH(pAS^CYfzJEE92IA@UHZ2C%NqbF^M+`o6Ow9M7S!oq&zE!E=`!jJSc#1B&m>B#3I z&J2?EZ?O-uF#bE4?`D6UP!UJD%Q?5GbDi~}_PPWE{yUH!H`KqMGV35toc&`twf$tK zVKl|VN+i`Lu^&%5AK#P0^8?=Jh@maS<5it0@Fia%O>J#QwQ3~vUcx|K=cNg>J_j~8 zJAI`wE#b!(WQ8+S`wrkV?_GyqYD8%Ye_}*d7UCG)uIgH}NrOzsEoW8~TF6=!=MSH) z_O>p+D5>o7MRL5I`fWRrwrtTzqEQv&Q^m4CynhT%74dUT#uM5%3ys}|aZ+$_N0TI( zx`NAB#+|rAJ2{iA}`&9!_05F=}SbTVzYBquysviJn&Yxprq)ahMlaFjkA4xycDc z2D@e*Yy!T7(=X=9^=jQOI)w2g zk6$^*XwTWVPAB2cmIu)9MhFOXLcJMZQ(Fts3u5fROizpKNvbQna5n)EY!*rd(*Q&y?obj`LnG` z(VqOVx64>F6}>NQqtr~&&B9HTM;AuT_m|oiN-h8Dgb3*fy7fE_2y!^*|K^nAubCF? zj{XQ*O0%l>r7r~QdLIJvHtm44vZlv7dY%hV_iPLlM+#AL=96{5v?4 zWsZx2H!(>Jt)-{TJwd3f*&wBuIn>3rgdL;hGFZocP-i-(q9%Dt?Vfaih7&RAv>eO#Z?+9~oo{D#lHND_49e+~H9MMV$Y7a3; zf3y((ZFFJ?nH2RB#VNs-XeN!o{pO@=l67l4I5)i1;)&Q)92ZA|=aU)PqKOzYEJdKAwxXW`RZ1v3vsf{cTmCv_! zbFmm~S$+7VVw1NcCvb2<2o%T=mBzbII%gCxe;?XbU87xiv5lJ+0ZB^}Z<0%9^zU#5 z2W3tfzoYT3@|kKaSG0DW36Lj$_mHH|F@T6Mjw>BDY(3kkhZYopK`KTahzfo@w$7=V-hO?Sv-ZKiI7>7%{O4=(j)Ci+MY{+pZ ziYx`fm<>dDGZ;cxMbz1Mh2_bV2#T_aM1lMfGOU&7G<^=)Hl%2HVcBxaG;=Jo*bNYJ zGZ0VjVO`>>T%qSRp+HPd0(QA(*EmuOJU1UREGRTk`;(zsESL({Us^L58;$}QYiZc2 zbJwa=_x1;jK#aN^Q(<2pR+GLO4=9AP7$E+jaA;4*u(W@e(v;^mnq-v0AXj(TZbZ8#8xHGX`to*6y|Zd2RFW-7i`*+V)~D z4P)hs>`>4vwjkI-YE5r9>nyzt+wIRB)(3NnH_-zn*%N3Y4&lC+ZXS|%e)gs_gdsuB zc#>5zFMF0e&2$Jtj_F&o>!HhwTh06Ud7k#nhe3I!MdMBv?Ic`ER!|eVSy#Vgn&4K2 zU|%_Zk{V58Z2Pz9b05(^f$bzee5WCS*xr0$-{YZ7GcMY%*BVQ6C|HBD&OuDZ^skC* z&}!HIX8FQ3%nNhK^!oD~E=Bmt22u|3C*aL_i8?^oID*}veZ*TiTLP8}aC9!dUA8f~z zS7cP!!R??Y8dfWU&7`CZ3>%gXXKP(jukCz=UyG`jc!nj9x#{rx-R#-P+pP)6>(%Bu|@@L7Y3K-?U0tSlH+GHYX?NsP$sB zrfyl#@6ekqfe93-kDe1<8-h#itZ2;0-{}|;B*Q?3ksxDYZN0zN6Atg202;xyRROt%N&zY*#x$GIMX}(P3W>wjc{8Q2uV21A86F;v9<%el zD;QH(S3^S^r-DGf>S_GBh2u0TvjVR1t4j3lI4AaQqiXDqUx-JgP_>YZQgqVIs=$C-6cuXkSu$h?Q*L7`OS%_&s`wh z&8nH`bs6C3bJl|CavrT)9v?!bNx4-N)zuZV*uThSp_PB2PhsEu`}Zd|jQsOUG;T65 zV@08f1u@CwJQ6}mu`sL`)sLG0h>P2+Dq~W%E)hPS?5`ZI%Ame|u*;0FLDv%FmizoD zf>Xa-Gq#~rHEOX7`89BgP5!25$+7;Vd^)jnWH&l`j9EAFQG-nNJdC$RSf1v>XWq%I z-0yZV;=gKwTvD5!4M8s>Xv>yT&AZW2&WrZMCh<{{?NaOQS}2|G&G8X)Mod}B3ycQ; zu-wWyYwk5RiB08+-XtC?eWT>0q{PGJhCPpE_9QNs%@dy%;c&!9;d5a+%5sCQeSXf* z90TY>va%bBnZB2sC5m@{2JC!K_E;2q*){43kUBb=CGkZ-q*&InYnfX}i~P76kb+nEiHnekC^{zNtNT^6HX8;yWW!6h zP~%nar;&HX4BXd2=kcj$xG!a7dV~7?nJdYaC?@m@Ro{$7<|s)QE@v#4mU7O>!_0HK zZ0nNiQ%!#9^=jM6?j&!Oadcy2Ot_wB)1n{8eh%N+rr8nuxp;!?mEI01!wMCMZS(K`{^H>L;F0e|litnxv&{>(no^1>}Hei0iTz0~S+y+2o##HHt|qi%H&faBi_ zDSBnyEd|E>qN0-N{ded7CbO;nY~=MAO9pylZE5%(^XEci?gZv`BaA+Us3<0~!}&ejk7x+F-_ZSp+3I;$Ja5T2Z#-fTSl`}1#A zfuf!7?O7<@-O$ujJe{Y#LCx+;i`T`^JXyQeOG!7k*JOe*UB%(jtXc$Q(J!s6^0ev> z@BVh(yPWKmZEgL|j@L}KPd|A)s@>>({C9H*NY!0Hx>KZ4d`6za%kMn(tdTlhk!BX?WHy`?Vsi!27%ZC^eHmur>FI$7(u8+ zr5BG13JP4nU}#ol;Xtxx08}-Xf>BB)Bqik&DP?F4tIet~Pi4vWx<>|`ISBJT=-czT znVF=a&6H>Zqgj}f^`D9wXaFfL2)BLK4y`?;@>SaM9DlNW22Cg019*eE_WWnIqeK*& zcoC_oWJFFc8Z?s$)8A|?4T7mT(3TaSFbT>n|&SyNLZ zZC}s#{&##|sQ6un9cUM@a^ttI+1ZCOj(EzUj?z?9*s~5~r5p6nS!5E(U_zQ$FL+ZE zx8z+&z?^*z^2}%tKihE;*v8%>>O7sZMPl(-4QlX7wI+%shKGtZeROSz5<%ertwu9| z&LCT)G12Mam>~@f4Z%GF;%i6A%jxNx$dwApiWc&F-K zkYD3P;!_cK4Ynkk;-Q;%1TQ- zTKhsMNm-%t)=_(cF^>Kni9V+onG|e!G@JY}vO(YCkFFs?UNDFeTSCN;4&hTFSO1loHL32%NG^8`}2(^x1;$-Xhz&Ap4V4r zZI@}8w>MjUGb<~0C)e}eolA(&$w@I7pNK0IkgJz!AHQi+Wh*Ow#F7#1HO=i`Rat$y zx_rBGcfOI4kx^wf#^abv2TPFIB*21V5f%%;I)Ko6vZbOsT{RFK2hsJ`WgIYn+;Q&rs)7hwkCC=W(aVxw*M9e?il? zsjl!fO)cT8_B%{w{N8~>m;C`~dNH$X_`MsT`IK3-`dxg_8NKtzTxmzJ{lNpHhMV;T zikY7Gw-YWY6G-X}G>EtaF@yic_qDYw;1JKU@+jPXtFJmwylGH}8 z{E5QULu!;f z^w6J;7<0#bfisz6^XcYQ);1ywRncjgo};NX3dATYRA_huMLv-F-H(=UQ&KFXl=S>o zdSsLC5B;v2CgLWHxk=BTp@Xhk+tgkFyM%uQ-sy63>8+=y$CqY=t)d!w@bHrne+cH)@dnF^@Abj(upD0+RJ_Z&%T&408JeIR zW2NG5Vf16#a=Hjx?2|MTSV@2_PMS=)P{Z@)-*Fp|*Zgj$)t#!U;NuGmCs%ul%U%~P zcXxMy$uehfS3Q<@cV!y1|K7H@?l6-Di)Yoo)({*|7F(|MK%JWsHAr^gZ)CKJcuMb<_xsSo18$*pgy+ba;gjl4f! z@x59C+STcVXNI5yk7>)A-Rq~^q=I}>k3eLsHucJdfZK1k6MTtcC@n6HiWTKh9}J-) z1zK%P!XCrp1v?;I#rkP$X%V$#L1O4c@0N~yF3x7kh>3{Mt0u%&)qm(}T4i>C11f8& z^bwVM4B~xCm)?h03o~3gtzTvG-m!vE0dRZEMvh3X!fvv`vlRjB?#Mpd3m`=UGMr> z(bxOnN=tZY32(-LFMv3i2ua6XDZ!k;J2mTL;xxCmwr0(_#g7k?jsps>fn4H`?HADo zP;scK3R{AiX?|aCU(vMX;*VbJ*8*6Wm`LC}ff4#MWXtgh!R&`o;$lqjo+!ZQ zE-(H!=SSsvHy~nPyo7ctm4;IXLKp3m za<2kjJH<$C6s0_9NvV%QlFykxdh+z?(UpoadMCFgPjEr1c_&13DTcuyE?8s*&z9rMReJJFaY>hxO}G)iv38; z{hheeX2x3~fHMuM;S!vWtX?LwVRA0$(bs1efQml5ekvrB$FqZguCWD!e8K+$Pyu*F zbr@sn|sOQPZYe^|76lySl4#13$of@p|?CjhW8P*!ZjMLN6jXt)!Pk&QB zpM^I=xtv|n-w342F-NV@e-}W!)Y4;pj}NMOSxl2eWJUhTHC$T27PwX<^V!FKMXjm; znTF=(=HePjL@++-K#w)E)A~PqH@C-DHi6C{dskaq4-X4-cj-8Bgps>V$?47IX^xcQ z4@x?SCJ+4r;poNTlHZ*-y7&SGm=u&Kv)Rya>DZ9%qEW@2AmifV#v05#Y|wsA2(RuF zKmYa#7sg3L6)SH3T#^Du9Y}#<=6HOm?0Sh^@$5u0F(bj6f*M6|3K2qse>LN5*2yl- zr5a51pLOc1F01`ktC^HxYf!9QQG%>L-WCxgytNwVc+{ z(INQQUM>b_V#-B81z@moN~F5=-*tUgTUQU0XRerp=zf-ty8~ZXHZ~NC3|>T3EIVav zMgMnuPA9z8Qnm;v`5jIW~M%jyZtt4Lr(I4Jn7`9*nvekuGTS zH9tV!4+4r8$LB^nfNECb{<$ei z(uy2{B8=)sz=LE25EN>U4X{m(LGZ48jTdS~2`-{hzxW4Tbg;|k`m!sTs7I6dW3W1L zQ*ry0!V&0&j{<*P`xdHJD?uGl`ZEq*Ue|wvo2N|(!I*cQHy`ESo3f8x`~I;uH1ziN z_B0)22ERp@2=fm(8XFx2;7Dih{X+G#Y&&?3vW_m2*cu7L1WDH`@O^QKM{n;h?LTG+ z^6Rx||CH^grA^}+69&-p!2F`kNg5oT!=~}2WEalYzIU%kv2Qmr67DUfAtCO`$q;@y zBNH&MJ_rnYf^Flh-^m?@v@+`IFG-3wAZMo{N{ve~u<-CG(Ll$=Fa-|)NN~_zeeQE6 znJ+yKV1l6ExZJ%EBSJ6nEPJ}L;m+H>cg zP^&0SO-)@bof=mN2qpIC*T9CEVqZkj&^+d#!O(z1O&0_z#P^AZ{0Or~!aKq1! z)f*9QCpCkfRWjaDahu((17`|`=U-;!^s_&GhGB41^GWW(7w#==c!N29+m=`+itBald2;zx zzJ?Ga1_p4y7o40}0em4uKy3VbkYmTfQc%s;zPL2$v)0)Ilxr6k7YhpR=ho|A6h(B9 zNL24^ue&bqusC*@bWB?R=1EISOH9r;=6L}!U*4Sevm@F=+As1c9`@z7K2mr}L^sem zmjyEQjO6>hin&;=9&u;_Je&JPoF>-#znn(Pkp3_SIqX0K^5D-}6J5O!KHOdiCP+)? zY3KVC7r}APooKXd^A!hDNrX`pN{Nl5ypR+Cj=>!J$&Dm0FcHc=XEZ zS?p;e^MC=sn4Y#k&@q`~qgx?KR8OK4_23o~!U38`e%PPiX?B)64PF=LCuU=4`nIlz zqv=ACvXL2Eh1KGS6%v`A>=6xrK=trr{KNLnj#`YNsn+Jt`7mobsHDLu%~_w|2O8QR z#5lf-S<0LTkedJ!4VP(2YhKkSsB10;?rgDYTYdka+~?dFv&mq1wFv@(hW4t8 zfnFIN6jEZs_-*_wylT#xEdg7#9os*7pvW_0YX_baS$oq=hj|u)3j&oZ?Hfm({ZI}< z1O@4Xd{(q{G$-aUP=MBNNA*WhQ5wxu?F+^nXdcC;3r!8yOu2DzIE-R>Txi zz2%1ikv?u=5&O!@%H+(<0e^&8T0c4W6i=8zDY};`WD7g@`E^+&aW$kR5Exr?&0T#cA?193hydrNJ_Yu(U=WBM0PodDX)~LCYTbUZ<$qz&6JQZQ# zrQCRfz4S+q(&d=HTza<_6%Cn^^MxcOB}MjR->xq%E-neVB|duWGv-F?rf>geJuh;m zRL^TOK^+@ACOBAyPkerbj zTt3akl8^Yoefig`8?|>`G=fcB7+q^I$>XK*_if-89t2N)k(&R>vV^48uX`-x2nytHm!`fPo zRDui^m}Z6wAQpVCex>jfC}arEt*j(T*F#KRwYnWGcXvAhoByBhsz=61(>}if&^rPt zK5KmQInKH{{p|WF$%Z-~@nj;y3u+u&^_&*~>9lIy3O(o(75kqX^P)DftgdI*MvgCR zD8kxK&S-Ox%oCYeBR!xepswN+7sv}+Yj{Mo;o5g>Lz+5e(jx(G-g=D z^Q5tS9t*8((sqz}&e{C#?(k{U*0uCDo5@?vWCmRH5*H>{TsQ+O!erwF4IrOSPlp#5 zy&F^~=21zQ%E_a-O-)VOeOMqHIdgq94E@go2z7?Ccyv>vYJgV)NWE9wFF0O!Umv_3 zE2FP)v^U?@uv2vFbO;Fv0ZhTmE%;fQ3Dkb_qt15eDK+)$kZ3;NZ^ELmIDzL$LuOT) zeM$~s85^c-@{X&FwMHuA+NboGa9jP-0Ud3yV8Uqq(Sw}MpYJpKv6ISjNSE!ZY~{#A z_s2Y)*rJh|!E=qeLib(?fsWbUeCoXslXbBu6_wCha`FXa=c(SBZC4P1L8?KNBl(va zCi?o)v;otQlt1Q+%(JSw;%r#!3L@Hg)tXa?pMRBE8wBFBmIGsEsB$B1tG*F)dC@#Qf%1k3Qjj(+f0UbG zVpFDi?-)!~-Q2z+Bb3ju3lq9!wCdD`Wk5M(rE?l-dC% zrw@u&A|_{u`!ckp5EY}{?CfA*khS{(1R{)y6}^qs^KrgS-`kPfof`N;7=~!4F}Hz0 z@K_fG$j}+IUUQcu&7f?T8+k=Uo~F5x4Rl{dZgI9bI-E{PbEiy6VxSA;(m*9}&8_$a ziP2`u-si2$%a3rr05*wvcKxn}4ZcqBq?v+Vqq~E?etS6@A3%7PwO&~Yo^bg;0TE7~ z4zH{0tsL&`WTa@lg3Dndetj>^5Eo41{%#X47bu4+58~@W!}w;ZGoxvJ@ZQC#^89ov zf)dIEWq0_N_-fHsKl`guZKvsXPz@?9H{NnO6iZyie2!rMY21b-!7e&&-L3hM-JBwI zAst5&SC+&4#*HO)gEHMa?|KdkPFh!fT0&9=YkhrqchKHf8d{I*bhpFhmO3@<$yO5oO-Bn$$G>}JZBL&(912Vn zWUQD>TFlCfmC#K96{KJ-N@8Xy5WU`y1#tDRsi~NJp#6GVH^ninndL_J9dYKgm#A(7 zNPD9(8ipD7j&E8myCA8$`b@?f4{pBm)17}+?Ia+%toQsbSHt1tEcn46g(D6R4*|3< zgWti>*Vn+rB$!B1QQqh7GASpA#nfyoiZ=^JE-sQelsgHYFN1)rgw5q);MBtGbhg`?N$uy>Uuj<+QRGYT`!X3P@~-7vWI%0JIu^(=;2IxG&A!2F-7rjb7?l~ z6*^tW5Q7jMZH{FC7!|!g5v3FHuCK2*r;Z=Z4UNsLcReWKF&ljj9TC$WC#s_^> zFuS_GrtJ%lc?=|D;B;Tg)P*f05$t1|k4O^6thA8iKHKxJDx7q40m8mx!)bQVF?uF;j zyxs?={iO3bJ$aVk|2;Z|9Gzy69PwRPCCK-D_)#Gt1~qQ zr53W&=sS_azkl?)mDD+C5DL)ujO9ahy_TB}w`Hy*S-quyi@r6=XCjxszBo3hzIfz! zcOgnA-~f%YPmaSSFXfiR_{c|yY3**}a<&occfWRjJ@mlD5fDW7!syYv!pRvQIQ$jA z``a%pQbc?7e`@ePX)v&gV@iJW7V-1`SHIT?9^_5^`t{~?Qn9bEub_Y#jSzHxcBa>C z|1w?XC3P3}Cz_ic5smHq0v!V(Z&4VM_8ktY>b(rnMmJia{V( zFqYW1JMpTV-7mG)w>-|1PbvwFFBz)wq3XmqqzofDtt=PEiGeQnHHnGRzF-jJJX1$a z=tZx_bU+Y-&-v-B$RJ5H&jhj2oMBy^A9xO*jjvn$OLlJB_R$eA?~8(he7a@7_nc~k zRm3-&c|8ktwpf5%rlY7#SHS7Fvzr?L61`(458J=g1*VXQGBq_lT=Dxe(RRN(#MSmS zBeiJ_k6UtNQtnVD397)xI3Q+nEK<9RTddz7`r8z!y?Jr&ouQa*Y z0fASW?Xxm~#ug}~i?|(Xv!xrFmhdvr8wjSiI&LPEwcX$+qsi4EHNR$FH2+X9Nu>wn zBDg<1cLs2XJY`lD*~Z!l#v;yk7B$v5*N%F1hEfQX=M{2dp#hjXB@*OjcPNh#&#rqnXaJMa&-j|K_a)mCc_KH*c0#}7?=RU z%RV#|87Zp{AXx`>Ww9|C`v(Uc6pk_m6{_0FnZVISEW7oD)V35ySmPm?}9 zeWZ{n?6mVUPmYawPI3nwPzi}1b49E3TK$=nd;YWsg$&(!N@a{i< z{s34SfFOMi4>HK9aixHM*%LGy`wFN->NofUOi=*^HCrAA@eu$(-3XA8@1HZNg!8A& zxc>ciciSjZ?1ocjqn}(utfsEscKJIEpiSynVlwM*1~+GPn^NBaDq;tk;O*G}<1TEu zU(GnK``K|3p*zo*qwK%EvaXTrmaL5@rNGScvAC(7#-0(3V-F4F53HdLp&}%Qk#bj| zLgM^!L7&3Vs!_usjApER?y7X?9qqk>t`bu{7R8ZMQpQH@p5NxuF=@bTeGV}sBsy)b zHv23aZ8v}X6RLj}r(j)j=; z0KP`$8vG6ya@)F(d?AN->5omL@YJ_2kEgv?;1j{xtdu z%wGUEz0?+2W6loh1UX=e>$uqnJ~nhP)U$tazVBO&8X6k9KexNTE4#nC_c@&?({_|n z%<#S)nGtor7fRyP1DXUm!Du{nR^?yMvH6C@Rxv;fmc+ZR*JKeA3JYqI)q_g>~KO@JVB{At=qVQDcQIO@lu{Mz7I%r|oXvEXDb7h^w{PXAjl6F23q9 zoUhCYv|+))SoG9-r64#!r-*8MC0 z_f{zCWspI&Fa~t<)=q;l6{FllO1!(r_JBU!OcH?cN?6z&4?R(cJFnYd5ZO*aL z5d{T#d67&^A|OVqs7%H_6%ldzJsceQSkLQh8c6pcD!%*eP_hn`9e9Gq=YdcBS6|BK&W;? zVgbC@DKc!qxnR8Tu&}7Les{7~Jb#C{GI!&bY*$M6IRJcg!AmL_gCQ3ZZRf2e#gwGb z;<@>Ab+zL4iuXnriRjJx$=K0iLlwX1<9{L$%+5cal%Xy#bQm{_N+G*?>CGI8-=D{R z$6Jrb^dJJhi|+&tvUy-JIW$t2V*1fM^Kj$$hSWn7Gc#Ytw)}~x1Es%*1ynT*ACvbf zW(q8=%#aWwsY`6YxM-hUa)El(cdx|i{&eh~TUe+l5JZS!4oA;c6`Y&?U>}d+z->6B51=MX+$w zIF1&kMv9pwzXR`icv8t#KRvrV2^8$^?Y6 z{a@P2Ov}{M(9qCD{*+{w%2O^pEG-QP2moj)az;k8(XS2OJL?TjTaAtQ1Bjn+Fw&$S z6-PqO5;*c4+|W*Hz?tNAeNgwVFm8f0hbT^Y5D&erpzdP5CsJLnX?|vAs6EVh@8x_x zQ131+`D{+Ji{9?&0lr4La)GNvol}Ft22j0=QK6$>e?8JZ!&xPaov6SeZ~c`}WsUG} zNQTjR3@a|GaeU?(dBUgE(kzp=KDS$AdN-?qB!??)_h;&_>4d%iSbH~Xb8-!H$pK7m zvQ{%79vRCJx>)uCc*aKe-@_?Ed*IJ_X?EnfbE15WyEc4(_hFe#)3a#h)Yst;N(Ssz z%RKj4o9*YjNAYQiYFf=z9!3VQSFffGCL@h|Jbr*nT;C6(eRUV{I9dz5yu{igQ!7-9 zIlD*~ayy^eQJHhbMl14_pdJ}UaE44j?JD;w!Eo=epFwp)N*1i1J*PtZ1g2H?H|O9T zUcK%(9Uktk3h#?;^ZEB@;@`i2-Q7WS?szjJkMS8<6o9Vtc;xkRv-hPVL#9d)VXfyI zYT{y-V6lZ3E2B>6vth(9{+N%L&`UAcOW-)Z0hA*Z+J$OGfC!~PF&#)HfWiwXnm4RU zqF*9%yh0Pvsg-=KptShZ-nedg`kuE(6Z{Jw_t333p=40SXZs@X8% z^GmHWCHYc)8VzMS(qH_gw_OZ9pwtv1uZ-71Lf2#WV_YJ4BX;+vI|X@;h1#4z(SZjE z!(Unwy`Iy%pCh^354;fFJ~$jS25P)i3TQ}zYt+kO<|~0HEY+`X1=yC!Y6+n=wJAj8 zaAP@@S-K)#+Y_X@gMHfZ`dOLBWExk?*4wNdH(~Q=jK#n8$Sea60=tu|;A*L|2yF{) zpq@=M9Y`2Sr(5aj1Y!Xxt1>3Mbt{4WLkR}8jct@G4NHnN)0cO76!iaE`wTQ=-$M{a z%l$uIy($4seGZv^(`Om1S-hYL(d-DhrT-&brd$HBDVEbG!m)GoS<3PD`Uk373 zSQo@W`d!R_ohv7vSVzW9-DXeA;!~od`ETL0Zh2)qrVD<#&kwNp`O5FKBALepWz4a| zP&ovo9T3h(LjkDaDF517W}bRmXo?IonQ_&pOTq6#uCs?SPh6OLd_G(xl&|s4J|E?Z z1|G4yxDCF{1E|@Zot;?GyMr>n+dVFkdv6yHO{<(mgqtG3!3v>f?tcTSXFwM~(t46k z&Jv5}ksF7jD>BA5E_CYfz+oOriF`LFF;j^%MK? zo4H-he$ESPE_-itQ(@rw3lpxrOup?8aqRN>cOOlPCLFZ?*%rAO8mIhKex+1u-H@58 zT~VYMg%jQ+Eg9TZ(FE^&)gKW-q7P z{w~ef!$Ei;^9?HXVxDGQSLg+%{j42*w#Uq!=GF>9VK z(0r>r+*|NQWGRS8sgl#9W1wU3s1;4)kQ}W5QRl7&Xp~m2&nGsdV(H3WaA1n9HXinG zZvz5&F1?1o^H%Dk>B0bcJlByGfPj)dZ8qTRoea1Qhil!2^g;+_!$P8~3OCjxI327c zO80S~>hqCrpOi%>U6>wRO4w#!2lZ2S{9JRCxIMbxx_1B~fQGAYZp2=NT}0H}vk}3O z+659+F*~mTSi*_X_7go#no=#Bc%4W61%9Y}lvRflE%*ni%6)!?(#bL3o+~A-MM?0Q z-^)SA-ikjz?z8@|SzOqy(_!i+nGy2cD)}+-eWJCzo-glk)m!vHpL*&cSn=&zh2>YwT7k0Bn+7xc(v1P>l^s4EdZh7@;B=AbZU2=jWt0b?-LkAA%J>2 z#;j9bYFOLlAmG>A`Tw;5Iyl@s?0Lmeg-$OPe`JlML!>CJlam&Fv=*m?J|`uxUn6Xo z_rKN8Upm{)6)sm2Sy|2JsP{DfG=5T7+Fe$6)2M@m3{4EQ@bIdX+QYX!@ysE44h01% zNN63Je_?4CoGJ6!2qq|#)S-n=SDH{}saF!akel5tu@$GXmd$MHT$t`C zj}Wt?<$7RKa*EHtJR)27pe(yI%5Nx1lPExjMovy{WMp(f_r~4+ej@N1@WCb_0p86I zMKK$MglFkAv<>!motLs@+Q8!zfUXn}a1EGpM}R)nOw5~$|D4ARAZeGD&IN_dL5!>~ zAqb{m^DgJvCuXkpF677vV7zs-LMt1{)4_RhKvDgImQ%f(%9?J@o6)>2;|F^;ap zA?|M^!x6V@%6UZFEiB^xmR%kEWL}>97yc|_ME-C%x~=E9o*IA1ZN8Jgmhc&OnoJLS zY01dQ$Wp7<(eIHoznlF@#sA0CSNJvgMtzS`5Ri>-#^{oekggE|N=S_E?(PmpiAYNc zNOzZnNT+m3NH@|A@BMq;=kxFfjKzJO>zr?$z^B&Dd>IM1FY|Vci;I)4M_tWY2F)%H zw-=r({+3=|TQrCzILFvI4y17rFremr*-DpcXI~=gxSaAc`p`|t8f_A^xnGa8wlpeSOaekdXSc! zxyP|s)leYnqX87=Q&=;8%Qw5`>IVr;F3z=}jll?vJ57qZ)p>&BsI&a<4mYOMo7FX=KoTtB@bCTA3=aIFk;F4s9<+TxJ96Pm2-n)#=E_eM|cl%AbUkBdPYQ=SRO}zY<_seZ} z0uJ}PfHB42!e;PFL?BJR@Jq8D|B60!Aesd%hP5bBL)J@2&6&CWPR_bi`l%Vl1m8 zaEC$)J^-S)tc1e%zyUFLbK^}KNK}x~r65S1oteq{6z6|2J#tcgQeV$UuQK?y@Ix=D zgt`I*B9+Ny^2?~qE4crV%Yo)~W8B$a6jfImbR&MG#K=*sJ!+)XQpZDM!_5MOs;qaP z@o-A~9iEx((UDMMvIfR~5ACzV{L)u5JRU|B`ZyE@)ei3nbXZ0KrZvyqd?;1`d*)D+ z_SA0o^IYBs?V*~hflznR>aiu4H!eMU+!p*1X?BF|ZM+{X>0~X95ndm`kk2S}+<-sJ z-QC^CW^43NI6L5ScRM?f`|^5mci^o=l2ZOzvtAC9=gnz8(7qoZHm(Q;K6VWx`jIKi{ZAzVZr#@gMx{LRbSCa?c}y(H9Fl<{b>DSB!mA#OVzY47L}(}QR83N z&>OpTB+Mn>nf!;|kKZk*BkAH)&2vkIwx>CsQyzWpJGi#m20n~V{@fC#xlZq&<*Td1 z%Hq>U-(M9(Bp5jOE`gh2yb9|qnv4G~|NL~xk2D?UUcxuM`v?j88IcJ8q@#O1^YKJn z-H;3mlIm|bHasl$KSbXBQD&=Q;Kk;{b39ASZA~prkb7X@@ct<{cDLx+n@#?P>= z$%xtZ_ieF!w$1a!-I>3tiF`}#57O)LY%5bC`J$XJOBXakF}gTc^^b|@4(-#x z8Rk7UA`vTs&(UyI!p2u?!HU@acu)wAt=%_Ew8yAZPCYATh8l~7`PSO3St`K8A;81q z^6??wvE$(=np3Pb;BYVWjxLBXP08KO4Dcs<94`AGTt|A2W{CM+|F*rmyf}AbPznNR z(jnkc4TKT2uWf5g;lDpHrrDdnE!m7oR@XB4?1=%p>^e1{C#flKXk$zAde4)3Y!%f1 zv3UaL<3;wgEL)#OW3?vO5{&dGysEywNVW}_GvY5d%dKx?8&iXiSwqJSFm z^Y8IDsP13n1}8n)v|on#jFWmd9CWkbguvzG`wr@f??qIXJs&11$}(yKG0t+BtX?b2dTdQxHI zEeV3bx|qM43G(Sr`jn3`IFCr22rMU3T=4bwij<``Oi8Ub6IEq39`I{IMrBvup-F5o zkB?(q1YCqnCCQ9yYL(=)8u_8l2Ar~*{$gQ`y3jrCwQ?L|gX;?@-j^eh^~pUon6P40 zG|;Y_&rtGD>5ng|-c$u{|5j;NF&oM^87E~WezCs3es#Rk=6ZM8ANm}qZc6kCw{PfS zxt*la!4@DR3-Mor%ibJ-q<}4UpXlkwW^dezc4Ysi2-07}*&J;`@AZXF`GvhGXACFh zoRcDpVS|va65FS3{spgQFdj^;gAXEOXQuBAk+8Q^G59^Bqi>z?vm`jHrSFleZ$a6> zoOhXP;c(K#ik4^W7QU3~i}cTh)wm|oX9#yx1Wa7MtE<5R%U=F~FX%rYR8(IQ3_=!&SlF&F%9`^28J@{*!51DR;EQ-3 zukxA*%Kh5NJ*nFHua??tXR$hqe=pL#Sg((w>(Kb93r1qH3l^)w5%`?1i0g=C)%WYp zdS%x&9V{r}&McVBP;?{`C%5^6uCib(Lwm+1tW;!?=qIPWdwy(6BrcUrhw8Z0+SV;R z31N8G#W1a5AWHiJvla=a{gTs(4uZl^XhB>c)Zx()aliAONnrF?i{@;<-P>>8-96}% zdX@bg0-czW z5`JliOL<#bPywceXxs8h>lop~W!qL%s%1G!H`H#h?Mgb|CmQ4|HwB-Fe_ z(=QC|3&8wfu7x2nJzbmY|QMq9ofC(izpqIPsoJVx(fP z{O2<_JW(y;&fu^Xd-Pim+jLS3AYksSDat_?74T114|v#UFw~N8ToiP~1u-P%;kWte zSzx;N>KWd4LyKDMoDGuuC8CE3u+6;x4P2B+z{=oKx_2tEF{&9ymW_aiz=L+wj)a7h znx?1}{ta%s%sMXraNRyS)NKU3?hY$0?q@UQdLF^$?-&#AE@|c(1D}3|KEG;jxcZ$F zD)))oiYqxW#^Usiix<_CR~eEipjtN1RNv;(ykZ`J)%bb@8Rz%x~&6 zK-Xc>B?R^qDUrE2Q}+)h(n(A{Y+pCd<8)*WcM<#*jKYN(lGT2c0Jy;d?(Bzh#A{Rc zT8?g9O*XyHh_PKN74+045LaMq01EO@Ujk)H(%uZh*0OuSuVsI zJySV3OL+!im`o}*OlHU)6ZgCRm;Jb#U18WUnjD;;`x#dKu0B|LAi3BXsq&N&OcIIP zl&W}cnWVa?UjD6yPr`nipRTUSc}|uh+H`Y2!i$w11%`!<7!T))mp`CfzKMI<76-H& zx$3M4TN(86B8xRb!Y4!17;ap%2@S*we@IKsLXmq;T_&r2-N|5XWHV>iuygZr4P!}e ze=oZU-5FXmM|jyXo-wKv`mmXr^SNMwc=79m5&fCKD1ZH1$lWL9e6TLgg!0xlhi{K)DT!C zM~~7)(sGhewtyU#ZC)(@0%G>J`=_LnO%5qk{tdwJpf=#)=4M_C%O%G~OKpOel|%~! zw@G~T1FExZxdpzz+E^d{mCpK}#YRynT|H4D@Cwqr0!zecN!4_?`FqkV+u{~x==3~O z)03II2b83LMBcn0DZhT_dlZ5JJ^C5vrOBp*q8F*5O9UDE zSn;MF{WocXJR=GS&XYF0XgLZve6G$fwp;`$BKG7@xkV0qLP|xpP>mjJPZpp;ESn{Vggo zpy>157Q1Tx8A$G*GL3ABR^?f|wYJ7G8lPAhl_^|lVz|mg@kZAFpo9QXxVt}FY52o! z_x@&#Gw^DuHuB`Yt1AH*@kIU3fpNp23BcbCf80FY9cKsJO(mD>0!l|fqR@pN%#DL0 z!Ayy#^2|cg3?%u`!O0(w@{{y#h=nb-_V`t40YIK`Gn>?)T!U;l{4BL*9Rsgg8Cvg0%l-dVPT4ee?Wf57-N?H{cRVZ28v8zTJgX7)9ksjRO6lS z7Ci#B8~RUmpbJM$tuQR%E*wQ3zVx)!y!OQ~s#i)ZGsq!f!^HDPNYbd;f1S?7tTH|R zK)J2}8pv3Cfhd_-L+9Pr_H}xJ)ZwBPsv>V5a;gM;!Ol10A-A63Vdn3xrAefiA&Cxp zch|KrXC!eYuF~ZM@JweTjYlhOfrkszqo0&mGvT06S>!wd|5WvYuTiz*0h_>%|5MAv z9QgxG2fT0Z%!#U@VN0Ort%0QsQ z>5HTE-!K1g1&~VOE>8el0f3bs5)w?;*MT&K|EMOHo4bd*E2_B;M}Ry7Ea6mCR4rJv z#yrIqeCS}?a&rbX2&jt4krj<3oRgbccZh?>+}2pVZqAww6VwYZ-|t4nVdIs&dt%gy z1RZY~3=Yiv%o&BHLuog7Bn8$_tddh_C77>Jdfxppv;VNm9;p#;@ANj@T#zaI)k9OV zuE0VOUdJk0h~nXAPC_73p@&So{nNdj@@SyQq-;g#ybh}OwU%N*Hq(bvz!1PwC` zfu!W&vhNhClMM%npF;L)#>c-ae$QAoinq{?D70k>_SHaMlumk<@}YmFRPx*EdH>uQ=JDuy?`E00I(z1n-4*;p&;5INfRh~kcxza%2Ll~##^Egz(3bei=UF3Hm_4!jDxvk&C9(qoEw~DtMF{G z$;9NfLHvtj1%1X;UJ)frLBy^4-PWy%MnoSrjzYy*6=PU-tnkZ4D|DEenhOu6o4%QC zPfb-AEw*$J7Mo@mMobmB_#$Jynhm7V46PIc?#|O1XwtI@jj;~Z6ttO{CVu*byKc5< zq&ou)f)_J?hl3LY;^9Jrk>#rM0320o3m{PQ^*AIK^EvO|ZB+g*En%iS-P2(yD=m%s z!P^aRLHqd~^gYLGzq#H2^${;y#M=ev`*oi^2fWIX=#Wq-RLc2naC|?Qwswl0hbRqi zwnoFGa$h<2g}CcMhnhuOFqiHSG&d@StDAY&2KRf-sViL-hzY z(ZHd~sM{%eh=cn#vL|xGDvNMy(|VOgW!u&oYX(XX3gjL5b0m)}421FmN(+W+J(?X} zhR1%Z_`!~4K;EuD^1S|as6F%4rvL5nf_}5XxDkp~GPg23>tCdgi714t7E||`bQmf4 z3lcmIV9?K=3(yFAY&=|vHw8TO-kfDW2qt*{Tm9MH?d4$n_!pq#uGi6EuB)BFuG>Jq z#MM!Cp4{c(Vv0OHek3$ro|Ff*s|)@LlsVty1J{{6o4LB7FfJCB&j{HU*T@FTlI;4z z>WJZbW;<)UqvYz}(}XJO3@AJY1vm$JTgtv9HW4FAPc_)nz2rvWlSJwLL%;dm z$~l3@+c^ampHPBpi=;!E6I)0Sf;+mtJwiaBy@SDwH{NbzSviJJx0MwJt(QPbgWpXL z384A}eqUqVTjz~O;2!MoyFUSrIKZ5H?oAZ~#SRY_H|cy;UI84b+lLNEgvGj^Xl=f% zDEV|j!=JavJBf)~VGWjA|AN)MjEzDHl7yndj4h;KykZxAbqaJQ_HDV!U$uu9@eL?| z`g7aayH`{jdN<9<9?oC4%F>8#r7OW`UCK5V$6SYLP(@dtNmh1I#agh|^Y3&voZsL@ zn2b7sGd~#Bi14>*7$hiM&`h*4L|z=tw5YVUwl>ey$>|LE6+LkAfGdXNKdEuR!|h?Z zKwn=kV{ac2Kr=Er`bpH^XY({E^y5ovAXy3+2o@XcsYprXQ$b*|?$jXp$!__?X*7uF zET2zlnRyZSUljI0)e`kT`;QIn6>Bhf=9=asZK*D+iK_-vWfE(&X(Il+Y50?Q{as7j zUORiYFTGS!!r_fj{!)^?ogFV(75y-35S(6ht=q*Y353{^K_|Am_DBLSkSv;M?>jAB z)8ba*MhlCol9EQH<{9F5mw|#cEs;YDUgl6#)H0LTLGH~zLGa@D8-J)~TGp{+$6eJy z@#yFnUnEUtfqVG(zvnc5URTRYoE`V4V}Xxnv9_}`F)2{x0yYC;rqeL}31kQBvV=}AE*z>u4=O*ov&rkcsVS zZn&YJkU)py521Y<^KU)5xavL82CV$1k*z%ri*|xqXyq0eB^7@55fj%R>qDQW$@0g- zNhXAn*2NVLn|8=GY*9!c_&>wqG*zWIK%giPTmFo4E+W}ifOK$vb1~=gol*Tl(e%tG zP3iBhv;68D<+&&`HJMt7tj*8f}Sv|+{U z#7Gn$3lmZyrck0jF8+uJkC#tdm3Pa6u9pBJmhwvf7Le>ZuCzZ~kDD3^bMs$rrWhLB z{r&j&uYTYAjQf9~ai6F~TdwMXS*c5rKA0Qc4ehc^OT)=!1o{|b<7iS;l;kv{5To3| zZ*c#0d@vp}bt=@x^&}0NHjQ_+iQYpDSG36RQy6vt$qAdq=~??E5AszihJk zEnNCxYcp?p=2!1+78FMNg1tDmQKwA@ozu@MNBAg2^-vf2!%G<;Yj}z-QLsZ!DAkal zFe@bQi0F;ooKAebB4N%P*WQb=UKNDNr}AonyrXr42008{1Ll%kJgs(t%2%3*tnC>@ zR$;;Z2QAe)osLR|&ebbD&d#Z zLSEaKnfn3`f12IzfN&guJ)I;-NEj;!c=SFf%%(nEY&`y*BMtP~WaJCY=0nNqtmRBS zbeIrw3zC~kn;?*PArh(KkLFiA)r=wpk-y+LH@unB7wXMlW5+BUQ^)&q%2XrYD!Ew_ zrtwutZS z7~p?*7_O-!`vXo|uWh;Zf(GR(DLIx#IjNGh(UxFsOXjuE)3&DS*&EGZSxQ;Qhp+hn zhNtB4Z}Ei{p<#J55v>CbYar=UtH)AX{8SSE4Co@|G^HF~Pnaz1YgpXVHZJd-gJML1 zrWmG(3JL;oVdE3TOHz`~@p4t|UL-IDK6;<;P45E-HoN2QXwg=ya%60D>+HtY(*aOB z10AT*v8^u<026R=yU!FyDcItF*8n(-fKv+w$0D;prs1jxzYtP<<4Q;MCdNNvQJA@w z2AUK2xnU?fdGn^v&U@Hqz3dW?X|7(4ZUE=#|L+J8mEj;x;#~Nmzk>~e+fcuul6lwP z@Fkm=+xQ$r$y7U?oL3O4X|7%wjnP2u>+PKzSiS~f3U9VreIaW&wWKJ%iQzsHAvfi) zaJuI>rOA1P0fR(+D=>02weK`Am4xLxR@a+I?j1xHR#s@1mljEL7%4 zY<-VSGh>#cmFSA}BHMjw5J@W{63Li5)mMeAf|7xVn2d}j3jji-t>L)da_sTwXMca- zo#WF(t0U)9o9pv88QJO0K#MsR7kKM$xbm-JDe$iGX&=yi0Mc1e)V?YZQgbgoOyWL%!UOScrzjk z!*B*o3I0x>q7V?8slZr6@3(pd4WTu8YM}P6Ova`gXLB4K$B8bVPT$wp z57xB(jT=*<(nHLDU7j53g3C5nV?W=!XT%}&<_k6KeMG_N>;QS{H$aBn+G=~(U@z=> zaIm*0<>u80hS^U(<*ulrn?tXi`FkJ6)F`DG+aM5$;_s`kO_6ES;QgH-q zL4aCJ6H8cViboPW4N3BCys;+N3Q@%omhf9r5kt&(eT?R0QJ{8hCbfN4szN=u5LYv5 z5?As)LSt9()4UA43)a>9ndj5m-|vqf_XNAh1HP(H=b!|0c#M}=zup7sq+4o;w@^2a zy9W}4Ye%sX>rS*~v$cHOuiw-v3vaB_3}apX`iE{XdQYxtsB<|e=zP#9_F2-ThDnCH zGMaQ{DN=So`a-4e+C;Y+r;(pOsAZy8CpX?Tux$~t-dY$?HT+P<&N3r?SpNO~-Qk#y z1)Ke=y!T5Jns4deZ`h@MttU^;5I*53I8BK^2VW4^VzV>Rh)Thcy(+9p3pM8d0A;nn zamUl+&dyGXVZg&~VK%Yi-}?i*SLvDQX%7d0Bl>QGGgE)5<9@nw+5c(@Xy^{-Yg-!& znKIue(9$?4GO%##x($Fne`ZY;WPY#5v0WOER3oaapuWa$Hq0H=Y>XuNLf()ruV)s; zerzuFm9Dy*A8k#hNj-bit=sQb8Zzi3K=3mXmc_wBZm7(0 z7iN_}yuV_G^bSzn*3m~@(Bw6?$n=JxxysSj;*S`p>L+AXQif3woy2|FUN9*mBds(X zNsoz{EC_#wD&=CGM>}W_=5(W)SeT%Wn?CbqXT0dumxmIS-}`M^zyDG3iM9APc8U!P z^|Rs;BRVDsrxSngFqI4f9spHW5k*`5$oeCe=e=oFWH3`b+4?vEdH)PJy;7H2w#J6G z#2FQ==umdexlKW^q$zJFW?dn;Y?D-@l6)AaW-g7DZ?U`<25(HVo^FeX z8U4Ct+>EL*q}Tjy>SMVxLFg`RHQmeB1p#VIT57j zTk@3r3}5%C46ETKsCSJl*+D5E-%1D%%<6xJ8>pOBSQNM&{_mZqcms7bgQB_(EQQ;=#z@-aW~xUwfvSUuZ2xIn*0~ zr|W897gI^Bqmo2b_pw0~di4X}4N%Iwlcpm>RzD1*LEdhlNTW-jND^*G#l-8>e>>>9 zDS8=MiSqht)A*r;&75~Y(x$D~&=L`YtTC>_WNJ_THnDm|RG=sEukdmDq5SFlY4g5X zfLzS6%_hgNV*0z!*Xd!F29>|m96cc}%-&vOfY^FC-N0&f)n#1z_MuIYc1|I_4Py5s3-N%=Q z$NT$ZW2Onp594*=2{s(rC9D zzJT6Jlp&EA$SIlM?@z?)cLLq@bf>Q>l$~?}gdK6Z@i$qj7AWSYI64Knp-Jx5kW6%j_rM^t@^&IBj z3sBK`KKFv8Q6=fuY`Yze*cT~FHL}r1d0~vFlQSai?JY3WHK_zibE>Jj_e0*dL#Q^$ z{7DVHrO5tSK1P2{m1Vg7;VKqwwbwoabyG=?VIUCyqT5qF?r1{N?Jn(N$%Tr|g;`RH z0r}Z7ghK{HL(W8TTbyk@0uqj^5dr1LT^FSj~QGA1bz!j4JYdl-$GT~ zQMQS+fmow7Sje+C8^29hCbCDnERmOpkSVY%csh5a3B0(NT>*w6E^)_ljNBI_QJ7Uh zjf!Q3h_)0ScN^V8GBWuLQ)1lUAjBBE6gn!{sg4s}#Z@IqY!QUH?})2idpdJ*GGxMr z3krgw(sG$@Zq_UVLzwLds_azrFi zWUl4SbC3>&DUyDjl-rikMH?^*7 zX~8FX)dtdj96aVHy8rl0AlRLOV7f+;U7P9Iw zXo4f>(TGaF?@l^Zv4NVaw8V;L>_-`^LHDmk z26@)*8D7L#?eKyqN@UPZ(UU3_Tl=#W>?ADnOpEonm7-j`EkF&aG zTcBk1+18TQ^4rd}-X?A=R1o3e7bxcC!E(K=*Y$bYYrs=|4ID3V@xaG)Y#`QIdBe3i z^5mqtP~5Qj{xHSxP}qB|TlhFb(DyPkQ(E}W*Ovvt43dB=_>Voo@Q{;n{lCX0I>aX8I;;h#U-j{lWfLk2HCmMET*gg2 zoeF4p%=&eNxy7~7%U`=s7sR~$!d;g z^R>ocb~Bih&p|~f^LDo{yZzyEaVUio&u-xyNRt7K;6L*6=y1yGHT4Xvz06xy8Js#x zf{+7d_#nn?(V;DuVs)GS2K&&^bRc@?Lou%|MS1n|7fjXT>&72*cF7iqWZQ7S6=@Sx z-QimB^3*k zNO}!18cG)A`sVsdljkb6-^aAP#2N}C?@*E;zYKzv6`nPRXv|eU;4)wOysev(@E<5z z`t;j+9Um7RG6GwdHix(e4w+5J#Zi(`llyFEdRFK)yKD|#0XOK6+h6tb^Ydzm|GwPb zzFy$_U1Q4j^8i#t9{`~g@EzMN|H%dx+(`tPRJ)z^j*N|EKLHiL!r&nwAi!t)_a(qK zFeb1-h+irurwL-#xlXG{1ofLhx(k=Ot&sc`)@G3iKV*~t*FV)?k(f9!L6V;V7qYOE z(NmUa>x%F3LwRWEt{E%gn0<5sFNhXDh~s%R+*CxZRjcI}r-d7WcIG#MfuVq{3Moh2 zI%gD^3=#lHRnE_OqbbGQb}}ameQ$l-t&MHd1dZ{L{iBEVYxn|7wrmAooC>v(-&cKTFz?V5y&xiTlMFZw;k`6(ubTU zEC@g(v9WZs{nbxhPKQEysnRJG@Ibo)sZvK(k4j9JqTcKX3&Fs914zX0jHBOgHBv^cwNJoc~m zDGLb+#c&5$|90IbZ42T=Wv7f_uy`3_1l(J9cn37pwbqd!}PseR6r(YBu;jL08n%DXy_ z`_t+4_dR#HF%m*9d2b4yxU0`z)gCGZD$XCEp%PHv}ZDnz}wcw7QE zX3AR=#uzON3b(gi#UIZ9?M>SPva6@g;0HkRA?C6HgxYzMCIj;`_5JnwWOcQjgR#*! zM}X-GyeJK9bl-0<<1tnOAhbkYEm8mrMgd!(Lt!w}@=>aqcc0gWE=tZ9r=|!IX)dc* zPELtRummMF#)PB2qoci@)hOeSK~NaFJhEXpN3tWHOC+VD=9IyW0d+na(bO?>Rg~@CS8#Q3Qs(DrR|>P+VF^HR(gCci$dQpq3Dvo z=jYQ#%=rd#Xi>pKYs&qxD~(F)Mc(vv2aK(srjl%^-=kZMTGZw#%L2(-6O&8!>r>W?;{N~wNr=*b&YJJFfH8ak zNPb@0JO;#)q0qlr98lDmh&|;hJDISwvzs#9UrKU)^R>tKoPlQo=>m@L3qK62u_nF2 z|MPZz?L5f-SY2Im0#C;?!%2IFNmF$!egqsD!<{^>O*6ST?N29#g!>S_l4GKPn)s;| zF}*fnD)rK2O$M@%uTJ^`0p>=WgPon!R1Mg2P*XpnBk?O)+7<;63nH8S+7ax?{)R){ zz_av~gSl$aBn6PXST+Gxl-%C3eVCBReTZ(Y2P#l%`YP0W&R`;@R51Uy1B4Z6l9dk-Nu-tU_8BXElH%wds?4SK%(jL zaD-hoVtCsnr~dWp+O{_TT{oS1LmvqoP*BhgJql|!M_z_(B|v@gvS3XQN^nYjkM=4V zA(8%jR+`K8F<*^8B{L(#%oaEziVf=Z8oCW($e=ZLmRQyhdBqvRba~#EUUJ2yh>~2D zikVQG4dO_HB6S?lyq<&Kf5CvTB!zcMN;r6Ug$%f>UTu&&=aHCHPL1F)@vhm37HiYi zS`gRSeHS2|=<2%nV`0Za(!LNZb1K(DwDfrD@aedE>dWm7<}wpU18NIklZ1HSeW5r+ zRV4k(}&$v`0cp`o?OeVfK76lpkd6Y{jPrp}(f4CY1a8}kD zHkl~>CQM`%#@XaAIbaJ%A>d&#wmaDU^XI?+{$E>=C3;tC=-*^Hb_C?+sudG1{MMP# zlSPuM%Krd`gF-<0YJUOV4k*k4_y7KmZ530mp&OxK1;G*X+N>KzoX_F-1N7f0-&8%t z3cS}zhs3KP)GSEJ2vX@^qar{mG`R8Nv?21=7I3Q=TAq>*@y@#~^7^lXzD5$o$6#eh z3c8$C2}NJ{IRFWF((-$0#>8+gII^2Pxt#mix3UYO==^MIu@?9J%M07tc^!Isp01p2 zY6$2Bevuw#ZiW&{1}P1Y0sM46H6;w^+#IJ~=f%s!} zR&5LLyRFF`#$^M;GeP{iWwBO=sibFFn_M`6?)g9W)8-%%m?c?(A4e`bhFZ++4UT?l zd>+BIx)P}}VFakl;Fi4-&UQuKI1WP=eQ2o`3?RY>DZPKc)a1Or7LIMIoK5`V#>8rS zn*<0ZHV9nrzNA`|>8xpak*k6D@kf(IfDWqm858tfr5`QKXMr=wJzdgl%&8qbKFhAg zOejSm)J1-cW6X?Hdx;?lLN#*tP5fAt1$_w(ljwzWKUJthYURWUNPcg+gTPX!&3ZD3 z?o6-MOfHa*+DFcWXcp%oN?`NBi?bWxbfI3?LZGLeK_|Qj3T!h;C?O#rbrVtodp*YF z9YB0MRqdX~-m{h4T+IhLNuvi#!cDXN=AOX{)CSa9rvXRR%4~=0_9uYJZM%s!`~#5s z%S)}mZMhD_xdDDkU_6pNigR;wixHy+%*R4DFT&U6CaaYnPpugzxtqMtvf8AJ-M%10 zp#S`;n3uKU%!ri(&AuhMJ>}lMh$g+_fEnw_aLXUafB7`CW7#&U*;kP$^D;JKtL#G2 zglKd9nT-C-yRWTIs&R-s6ED^>Lz_P?ouiT!21XRS)egqG`E?WJt_hg7EEe#aHzf$; z1w(qNqMH-eFNgbUtM8QyFA`ULF_08L3{hdhk{pq$a~^t{Tc_rrBwN)wTIq+;FDZ!n zo+^haB5_ZfZ4Mqq4`X9sbA^M)ONk&dbf7u4w6x@Vi~Pc>9Y&g=sy#N?vxBaQ9I|AC zpSjkv#1^g1+?MumdJ(BwnDafxgil-Nw9?Yn0Fm?QKwc>gu+t&~9n2M}$1f}>sLe`D zN3B(dzSGU*HWM4sEey!;7piWtG+ynrnQGsZbLmB9JD0tX4m*e4|dwY0Rr z=)Iqj=#o(8(a;c5L1{oC(!aSNdAbP}Wv3ih0fB}oBlzo#Nt3(2IP8^?v4DR9FM}Ux z)|J``CYNq^=KV%WiPb;8OlcXR4M-9hUCz-!A*3O0Let~%18!#B5g_w|G!XPz$qGXE z#V-@mh@jw>7PVq^;6E!XJHq0t_~~IN`#(e@k$B&0dDJwC>!%v3_mG4-;r0BtpXKA4 zVZfTScHmHf~qlZbUgjN z%gV~i$rNt&<#y4yKaGK!QeW5Ys>@i#UMPfz4i(MSo5jL{+ozLBmepZs0I`o9 zZ=qH@XG83kGKkOTOOdO%k1F4eT_x656g&Nqz+#OY>ssc8>eK{btHB^vz@T_hWm%os z^9l-gbI7*|t(F!ap0t+|=+8h>p^;`hnFD~zu>KgI+<1I4Cc}AQMBY)|wrxb}YNEzp ze=xgmHneD!L$K3;cW;;B=9 zCW?9S!Nx|Y-0|6{iOl&GnA3=RsaG2a^&)gG*xvpz6**9$UAMdZ8W5}tzxO1)jS+(u z+u)qS#_g%%53QbfObI}CC8kj?F$FbLe3$tn}(%#YnB4L7RCXxS!5&sR>@4Fe@ zN*bZM`Z@)vyK=rD7R;1{y+V10P4LyKNv?bRx1ffbSO^}uYu1F1 zn*KYshON;KAB5ep-;qzPxU71(Nz%YnFX0kFJQ7_M8Dn65V=jwpPuc`$au@4ECVb<> zkiaq;J?md?ZI2(9s*fgSLx-BG>(@PgW+s+ISrRO@FiGn}!G#gRCcUsVyxU6IKp@Oi zdB&I=uj^WFMoc9b*QV0sDu)|65g7)RukXK-B+GhByXNa?JCMDttbUWlxcBoWv=sjma}&p?#kkb@KV_BVtIs`L(qh>ZWX<9{ zJT6y9na}Y8eE7M!MfvLgyE(V9dte|ylB6WGG(WwxIQhECdoru-4)7=ZjR$%+MT}8+BcaAP07Un2vmW=< zcMY#bfKk2!%WHs45I8It*^6GRzOVp;s@T=KJ@33JGbw$|xPW*$SdwGWO`PHsqAf4c zZ`~LX!z~HuW$E#OC|FDY1pb+owG2cp6Q14xzyTa4LkK9Fut3uiUZ?X@^`*0qhfjBn zN{rK!KvzFcmI^{w$p3=mio#=|2RR(=Ok1cJuXd)My${>p>WcNiB8C)41u*;i^Z(FM zi+(1Y*>tcsR$7kDgg!bVi z6Reb_L`=eAes!C(w{laTm=xEIXTqHyZ@I9K-*P|NiIvbDjKqo3lk9) z6%Z9Y>kE9CRjY=AteF3kw1sH~V?Xts0mVRFxblfvydLNA+~g%}tJpi+9*Bt^!2XWk*A0ZS618 z4=)sl+1cT1hfOW*0(zBB;{rqsaX6#~xR>PEQJ_|qysILSN3!$J$38aam8)@R5!1lU!^1dpoE*LlMBR?tsIB+g5yiD!3 z)_d64909J+o4}`kAAwv?mxFDlGgsFhlX3gQ69dg!QZ6VWxlp;!!lDB(w~U6y-_ZnI z1IuIls;oZ*e&zy2`sEneV=kxAq1tI+NWzS&@gqQMxt70!g!j1JUiVWe1jm0ULa=YR z%mb-i7Ft%giPd%}VPstZOo|VJ=FoOUAtlB=9N0KGG2%ZkES$yAqM6zEcXiQ1lG#5t zn1zJVn)YLM4j-H^`8IMI+;060ZMDO`$ry{o|r$*b$uJNa0d*VRJr?l=e1F2%jS|$%EV@ROyIZv%w zl}>TWQxFw-h=~ip939=h#eU$1%r7Km_s`36sI#QZ&EzqP|JGO_y~w}I2o{UTzu)&L z{K5N%>RIQj4~2xQHP<+x-#TtpfaJ6LU@4d0)Cu1}gmGdVOHZ8vMuy7V8lQQ)Hg-xU zHMT0Cp_$&lMLM6A*Vo5T(yy-f%EH_$*AQb+pkVO($){3^Gq+jt&xw;;?pzN^@FU6M zH?rVPimklPleu?#Qi}*a?vnB*S3K~a`H4-|9tAc31s{6*QU)TZu*W}@$RO8YH+`%j+?#_y3vNOs{PqfEKpKkL(#AdpI`YqMUlx_S}| z4j{l2ev%98cMoMKWh$;>%93KY<2G4sI+P^9rNffvPxl8_>D-(d`d`l9D2v|=0p0}c z8#^<#NDYi2Ot1v+`AZon5R!Iw6W*LA?#hy`ZxrupIc7J{ld8ZF%MG(DmpR_;+{sXI zTsCXiIo*vM^fj04`Y2Fz%GiZHAFjtgl>db-J>sIzO~TnTZdl|Hhz?Y-t+gN?(L-HJ z)*-flRKew;pE)-ims@W704U>7SD=8A>1Q*;oMJjD3n}WCA&cXc4lQ<~t0R97GhYBf z86CyZwUx$3xtW%r(UW#?`W>G4eqdkcPhPkHOoRthrV%Nqnpxe&!nUft%6GQklV`5~ zTu}&-tn0J{MK29E{3on)9~q$f#cJJP`PTx1lE~NCF5g4QSED13puptrT8FR(_uSx1 z3rG9hModiPZN+jpH@D+vz8*uFr#pt|2|Da;f8gKc8~e8sFmHM0txZnP7*MSYJx!wu zRm=#aH5gn7+j}sIWXymU{d~W`Mmvhp{CZ#e4#@ z%L#W6ZE9t>ybTMF#H44XMSamdQP3<~MBa>F%m>kWQP+vOrrm46!CXo)oyB(2gJD^2 zNT{IzP3Eh55epZ7x5-j`pVW|~IE>Lfh^QpxTX^%8JhlG|loNL2Ma8b>*&Qe7G{#Jf zZA`l7SYChQw@f1rn8KS>g(I^&;x>`vTm?P$vmVlF(xO3(AZS+{Hq{Ac9P2UZ!9C4=C{14cCYNY*;=Zlm+;7Rb!YXSFnxZC zJ0kFR1dr{*h~*L3Uq0MjgU-=(#DHdu5-fcZbts(-|F4-23($xfw+1+z{@FZOXkZL^ z4L7l}P^0~--$^2lq!v4EaeG679HdjB1yQr2@Igs7>P~LZutT2R)+y0#7|+dH8xIho zfjUWJ`xk#LeEBOktB(0-Px$RSt*NL9dkW2XByk*?`O39<^J~1#H05+Fti}t5s=i{| zfV%Hdw_c{i6-I*2kugJsuc|!VQ#O2Rb^3R)`l_rSQd{LBWZy^AqDm2whIYbyR%3#6 zDC+u{X+I&fdf`M2@K6Xc`R0iE?BVGBPnFsaMYq z2Q48Ki7D^LbAHM5rgQBpvlz=*NOqVuyoU#gdS~h5a@V}IhJcRDj&Y&x7OrU!mS8=U zx0QCr(EDSwvPe`ej`lA#gK9!6IwGX=_g*C!SoJvFO;yl)hjTQf+D-dsd+Da-Ed)Pt z1uDHtNAx*_Ahb86KB&Q1#+1B-WRSozm}DvuvNU$cYp&X`+-tv`$fIhYtDSjtJ>KI4 z32F&Q5`<0;Rm9U#-02^fGcke#`Wo}w1mzsT+RpmuXn==PBmovDzv~;sUi%g@-tGE$ z%GkrnTtk&UO3Exx6Tdt&myIH&OEg}*Jj7)kSc_6!{_xWT*XW>QL!u$QJV+n7gU5eZ z21`W^Q5HtZexQ-c&Xq?+`w?CHYWZb}eUWC|_f6t+{;9XNMsQbpy$n6`f$GrSDG0>* zK~r<%1K-_Jf#9>3^o0DXgh7@fydrj4x9B$*0uG0V?4arDZovcgeaUjDuX&&Z!Q6e@ zEcUU*-*LJvc$ytlLIY7SMUIq{X=Eoz0-U7pDj8(@w1=`+rxgFN*uh9qQDtQqLRFUj^`}q- zYVv+63V3$|=YNo#bQPwFmT1G1O#X=V>LA~iesq0bX|+J3>4x;|vlBLqd0IV>ZBHF# zBN*mGkkZJ{xmrT#X%J*1ykMh~M)G9iY46*EpkFc6g|CZ>5ggr|3?X3M_$`$KJv6Jx z=FPttjc1v<29k`7%{IawXY(0Bs0{z8NNDKjfHYi2C|N~n@SY|P!V%L}=@|W9@T8Le zWWO;pnaXb>c*YtJC+nvRr2S12R31ah1eq>|kI`ur)8`1UOt_>?lbhPyh%;(T?}##5 z#Gj6;ckl4c*MQ!_Kl@bbv9^1lTfgu&wd;eIK(0WhXO+pBf%Pck zWS*qtpA(+)4xV);Eyy94y|R457v1ttI%7(x7D(nwJXvu{jnftQ|vuG_ypRp~dt-{J#;WiYt1LNT5miq`}#Ts#N2xSR96wKa1&bW*Ta0mFEs zh0A%6CvI&8@Zk9*Q=aXJL>5@G%=2nV_G9@P+v6`K7)>wn__2CgD+`aOgGrm3gwPQA z)y7_EB0dLY)YC3RPEVME_9Zs7Ts#%%%;J%*E0lAfqzn(4SQ z6qG%xs@lcA^H($5Gdf}hKQh!aa=z40&wKs&CnFU}U!r;~l!U`GzPsvO(eQ=gL!F9_ zHchz>rIC#>+vz6fqRKbDH2?P7?@$c$x%bhrq$9@Y(-|#wa>ic{vOeO^&msIrwehKW z$~A?PofzLGIp3DVLL@x%YKL$`p|DTZPoioVK0d3peefKEuZDTb6b(JkzHzoF{I(9p)IV|nm8f{OrNvI@`1zY4{g4~}~Di-X=ac4X7 z_XP|}=5fMqnD|ks{FRz#|J-FUVr?9Me)Vqi%T*}(b?R>RyDUfo#swQLy!L=_lRK{R zz#w`a%z;WtYPoNEirM*Pq{jR&jPN({?nc)S>?|MAn+s@BHmVWP{A2LgwLp|oe)dTUBj9vl<*r-&?jD2)T3UpEaPmV<4BtTT_sN%!hm70B zMR;@MPysTbw$Bb}b#Z_3XWQ+HzpwXEo>=blwp45#wK1fLhv|spJmPb1ttkKYQ|Y8} z=jTID2X_biI`QB7=hA*yyI+Ypqo5%0Q7DJnwhKNtZ)w2u+MwvXrMz$1CGw`>kzp4_ zivInQKU=AgyU5Po;-KO=T>y>I+dt@}344?q0G8sSe57st*>+7@3T7os0rFj?KVy5| zrioJv@09V^v`?n}Of%kcMdhDD60&oflQhT1|3u^YlvSUD=;R4-yPLKXr9;49&4MQ@ zAtAx7rJEG_90Cc7vV>?fRGvPou{6Osc70NYfsbZO22(Y3qO#j;4hIOXoT1HBmvkit z0K5R(e@txe&=={1yM4nmYMaqCHYV{Ebr0tpsZ4z+MFmo*z~1>k6Wgek;qzI7Fb5(ldZFl>ryX5}G8sKt7y?E=!@r3V-ZCL}!9J-rHn7}Ye zOt_?cCMHdmCd{7zf@1!=Tr&x}x?mK3O6@`~R2_M%*-^Fh$~^E~p-e;P3r7?M2h0iu zZp2Tr^5%7TcBYrd!R}P6=b>nh7rF@~EDrEC#lXNDWR{m3-v?S-XG7EWN+nHg!ohI| zUKgCF)^g|%n6e1IeCZBS5{#-;&z_*Y#;aA$PcUrrIRIQ@Kz@Gy9Ee3N9c&z!%>1vH znoi7X^t@xU%vioWclA~P9T&&$x|GVg*M4uRrMj76lOjX`Qb^{g?5f|NsdMr+Y0?pm zOvs_&=Vxn$>EL0a&Ek0G{wo-sZ1QxerBNfc)qWe+MN){0IHqK}-73&PFXQV+93!i9 z-|i}Z<5_5lpYC*dJ6K0(@ZFQ1XRaZF-8r|MHMXdd2uAMi)TDKx+YIXS`J5KO9_V4} zW94J^-^cf)u~;W-?X6CU$8>gmK^*(T{oTROywUIvQ4*PH)zUw;@Q|Xhr1+^( z@ljF1++SR&C2SnPN%W?RDJf7Og1?xGvMTUV5o39qD_L95{Q9M)stObUm{B2cSeBB- zZ!(_c4t&PNvcI~(oI*xyHMFaY3|VW#O@E2qt-*|~sD)c6(HS0oZJh!N)+wi_r*rni zXKtrTU|2W;$P}RH-k0gdvXnLO`8TsUrSa$!npJ6ewxM_xId@S${LxL9dRN!!2wOt- zv>32RxWB(2fU|r-(r=jNu-F178iAbW{x_#RJw0cWZY4#n9o6su`+wWovXo>&%;u*X z=}5~SKLc?_JFBpF+w$c2I|d-RFeL>lmeei+ed0~~SArsf;({4CQi@Q++^nx(M}hmj zuxE18?Nxr{mCHU_IVncfB6iyFS1W2Y`X<2^Em2_Z^K}R7H_l4se&+Ob>GL&xzxgujs&}kThXl+$`w^gg9t4i~)Vfovs zMR}3{ledB|zV&F#5v}&ruw*aZ$i_2r^Ke9=k9$`HH>EC;$5>%Yzbcg*yY%J@8yZqX zh)kBLzJasg21Jwmcx24mty!(xnsLo|_#3giL>%E7*~oswNusDiKc;G&v-+*}M(xA* zMgn1}ze60FWE7Hy<8L4zy;Nb;mAb}57bj-5XKRVL0Luc5pJ_ne08EKsiaa_plBz&& zN>d2xDIjM}CH?@^LLJ_qS}N8W$(!}<5csHu1h5tROaRDauayTPVevEsvYI0Zc>+wc zt>D++7+Mhn*paP#Sx_tx=H=xT7dK`hj%G@e$31($yAM8g$+wRv=9^DJ*wA|PyO@yB zb{D!1z2DF%`p$29{G_I}KIt_2A#A8AsfwyY%p?jzGG*Bj5ep^)yKP;$Ll{o62Z?IE=iN66mT{!`v{mRru`SscQh5w`>yxz zz=>M>_2wRhpyP78|LxA~#9UUEfd`FTi3l)H0a4@a&3{-iu$BM-Oi$o)Hq6ca?A_ZF z(fh&X@Eu+Te5x1YlMFtRBpxby{JalI-IM?BN9}h@0O>&`=EDbo(BQiZiW@V9fjgN4 z>@~RTLqqj_d~frWMF9ikaB@9WfH|lp3Nal)qfd-KGz`Kx_v2!3$>pSk5M%W}voo(@ zf1b{Iw4*H*PsP%AUHcsa4#Y~}qrX6odze_#4`mc^D->~F{rT$`v3bwDBr{vMX_?Yb zYObK5&S7anx-=)bER)N;+|uQT-VuF4lFco}V&o_#Rpn(+=DInz6Y;QLIex6a+%)uf zE8A`Y-*-I}T^D_aE+3Qx$r<3${ELLu`lWRdJPxP#E|(d%FQb=trxH}5Al0- znqWOMq2Q9Vk$_s-s%(fZUgw$0p1trravd8{Qcn6nuWS0TrMuaB*1U%^0H2#b8dAB& zg^eeO_qQjjUd%Iv*V+5Y2mQzD8}aTujuVqFwElX&yD1d@4<>``Ei(1Qd-m`KL*~9Q zGTHf4Q6!5^i`lb8`q}kz6v(gnP3mzyAZEzMBfAv4@DpjvZ%GZnU03s=izZD7n)tYg z{wR0&LjG=9jBzHk_4|GK5PL((Z4Z_|)9^FGgW%Mpf+$Ud1~V}hvli>?-ZXaH zFKHX+wz?g!{yvecpX1u-)75tyySyLD_-fF`Bk2FoRSX>3C;jga7aBdCoFtg(K_OIP zNWKjo%0mkwTUv4+gMVH)$h%(MfAR1ya^?QQGlRp(z|gR2%C5?a78=SGr=#yKo-=Zt zr6iET-Jbir-!s7dVTcxl#8k$A*W{o^jQ`CCQwd#e52tMcP6C0bu3-ad&#drPmZr`~z)mzcd)-kW!EY z6;J>w?MI-KnNUpxZ+2S{5O;R2owGrGU9c7nf%#dyth+S3lxwi1w=NZE=^wdCS~b9*Z33X{td+fa760Bho?Hgb^IJRtoMHAX zvz*BHkE(>6T4O|9+Cj<#0M`<;u7I=qg5|Nc!Nq)}LFOh}F^#FJ^i z-nG3yz}#89qTL9`g`>p7gn==`4@yorG!CYfoedde1om!J5GdsMA-z{pdyk*TukUbUPJ%0uHHo z+K;~E@JiUn5wDDq#)fC%bcZ60bah{f`@h;o-Tw{ww%|}jh7{s>d2@GndldK&AW7Rm zMW|v(v35F$>0_#P1{ZdSW21UCC;RZ2QvTy^MfK(;DF5uAjs@D;*r+k5#F6vabt{@# zjn$vg6pN;KuqCV&P*he{-d!|yhj-9H!0s#jb#mSgTy{me&@-Y88{eqQskw6qKe0C3`0 z2}&HOXQF`?ZtKVWFF1)6;Y9t()3s=yqajIIX+w*s0&TfrrUm@gJab^-f6V)QgKS#2 z@_cb|ad7a9m4M1Kjn4>`E5j&;@~)CIV^4;hfE=vXvnLq1QAWQ@yB-GimmAh7p&4gI zYnm;ba8#eZ-oCF&LcvLe37?dGYc1jKtGzcjq1>3y7Mx;;B$Gu)BT)7`F7Gq_IyXw* z$n6jM?FHRNb`5xwY}kDp%SR_ZEf}1k+RD6}_NZB8mD*tMPGtPn@q;(-3LrDf#)=50@R6;1#75^ZBO1oDikE&2cw%6tLqO6LH*!Thyt0NtOycp{_~9I&9E<_i zVX|zBuU=kqN;_!wyCssu^HY$2tTpc^A8FYd=N+RYqoANK=GzlWz(+u0gEn=5i37D+ zj;MdedQ0`=)m@u8xNwhNjE)*r&+MraHA`$!u$6ZSC)jIN7nMUYJ=^rAk?pqwS)RT9 z_z_v1Kqh_4`*)w|mk5Sg{Q8Y5do??cj>O$m1Z#q;7e`I$^mg);>2~{VyK>3U+vV-rOlwX-zoOnSFf% zq)4o+LseR=`IlL9cm#xqVHS^fy{;mkw~T5n|J=aoo{_q~P}FnyAf7d{7~I=XI_{A3_7zEo__LEH5j&trbcr>&vAVfnx#OIIg^+CWdQd?v?~)J-_ofa7sB zb}U1IUP2#E35oY*M53M}nlXRc&4oqVeSsciFQ5-1x4i~H2Lya_2Gghhs>~V@%2YFZ z7TP@~|IY*rR#jBI2CIwtcRF5Y<3YO03ZXE|>L z{4YSt#6s+##|y{93^4)h<^a=&HuL^~<5=U5BA#ET>_eb7}=AjW}-VZE;_$yQ0S0Og_DZpV(JbJ4%!x}t2)YhFV9|G0f1FsKO;{7 z!@y2(R9@+?k}ZbQnU8lj`}+ear2)4K0L?1w4vaB~^K+q?kCspL_NJx~#Ty&*KI}PU zJW`|AsTSQ0X_+H!);pGL+b=&la`qCG+-d3W(Ho;&v|`BZrq3vF9^uvG2-YWye!Go3=$1D^U%)c|Bqi)Qt&pKR*MwUe)Hw@84&`XI*!9ySsWs$?8{KT!4S~8v`T^ z4z_R;6P{{UJX7_qbf-&3w)`;6vf(}W1`cUzXz*A)CG5Dm9vl1ks=nzPY9UgToTbYg zn5!N~M=!N{#3#hZ$Hk>8pjj>1B4%dnK+qekXIAeP{VL|LyMEy{wdRhJSdW5n)ba5# zAaat#plR>oLnJaMUS>;&{X`#S>Qd^v6y?krz`?;)RZ>Yvc$)EF3>ZinPp%C(GTtcE z%KgFtk5h0t@VJ^mN5jkefMtX zWMgP+>^}$J-nRwe1PIr*M+QkoiS?-X@%j%?aQc0jszF6lM?E|LK}JvmQq$7naRQK= z%QxrN`MFJg*L9|T`08NrQ1&z~KJjR|-qp*-#>AvXgNzHoxo}`rGzZYTt*^jTK@fbd z9Kb8t>EgmZ+t&%YY_v3M7jV43E;h#PKq{@sFRjbE-}w0TV)CnXO1IJt|1FJOc~y0z zo`X3ta?r{5|4|*edEsa}I^T#PnhJARt8xm=pv$9DF$LT|lYj|S-Jjs^FA-$>O!3Ur zd_deRXwl!_$y0+}iluIn(LBA6cMS zxNH=XXLct83;XIRIdnog1Ogx49zJ-f?*FRXB+ba|Arrd9rX6EV2$#)&wlxx zsez_#b#-9qaC)(D^q;m($aV9{IChX+o*bXA!-Z$Z?frNWCrNDY-@m5txHX{!^V;!> z`Ah%M+$VO@nk>)y7-U?+hbJc!O7mZx^bo4PI_?2Ft?oJd^e9MHlxT)_q;w%ycD}I? zNdD=+Z*yPm*_xP`=!Aqg)4A3^vF^CqJtefhIDE;)Bdoz;8TW_*3F5=o$y-2Rzmp+OkOHaJVPTPOKSF`p(G)Nx%rA}Z4&KPV z@V^@Z%^&dd+ag+O&}+`+QH=^ds{If~R9p-2AxOysa2n^jNmh-aIZjxur;^ zs6$Xwi+;eJHLGV94g{hEtpBBwQ&N^`4raw21vwCDL8#08#B&Ok&VBBITnv;AbHMuQ zUrM65X~$H;*4|>&!a3RE3Eb->Ez|_`Aa$muVSj{{cX+W9Tjgm zB>reMypc3xJI`8L4+(kiC%%&p zpI-d8+juszn4EEx?Dt0g`-Hz%j8I0kYry4wmjBrGabBf`i$ z7~V;Z4dw+dU~H85>e|NLfj@y353T`-=>S=HrW$aP(k+`HdNJF6Tx&XZDH!Am4#B`b z6qHaAk3*(3g;G`jaeD!2QdC>SJZJ`#<_G9iX+=gxK4WH(fon25NCbr=eHK>x?`;@( zU;QX;NA;Xyfg54x=jUf{&z3(%$P70fm){S5V(=+B8Qh@8&1wy*o_Yx97WaZuhOTQt zQE~BxVn(%Fiy`DpO#I^8v|iW`hHw0yHRoM)Fpz=+ODS*fmobv!YpP00V)thgD=&S{ z(zH8T10UA_g>yCs-PX&iOq0d1nP(_ll`q?QxUbdyq2d(W0f1PXf|B&7g&*X#MBUCW zBAAT2+rfO-R(?L{{iza@WQ0(o!eJnZ-S0Z)zb7mHFg_8P_n$NQ-@l+OW~7|wig2hH zel+4~iz#UY38#VR<5aItTXI=%p2pxDE1XFZn|i*4Yj?(7!*&7(-TqPAKhnXYq3Nla zIVqW01_TcVvEB438sBm2{6~e4R|^t&r{2X;;Rvg$-c;6e(eN@n?u2geyMGkDzK(q1 zcXhiG=yKc@UfgS$VhF)}60SjM2i#C_SG=%zAAbjjsh+(R3b&1Py+0*Kj&0-=5gIO! zp6?iyrH&{Lao$u+bvMSppEGU@dnfolO0W%nlS#oQloOZsetw*y&5eR;w|%bdg-mle zGn0OYd^MGf<$~8DEx*q#-6t&h!5FuKyP`SgYD>j1`X%N@8o?rt6>+hfKUu6Y0!)I; zxS8I)!{kBu%sE4<2aDGLl>wxw4+qKJs>;go6vOjjJcNZX^5@UJFXpWM$2x>u5mUB; z`pT|-OfjSW?hje4+QPXipSEc}Xbd6=PjlEJ^h#Cogq>G=&d#v)!--v+?;cPv0?vwF zJdUUa^1S3WB~>ctHf@jq3xt#uur6E!6OyQ=Z{Nrb+9}bWL$E_koSly+#P3Wm4-LT> zTub07&G9cxST>AK!4%BV#NBOX4%^zdHcrvFO#g~4hnI672pA2GeKM;BMX=@I;2&Jj z(Lnch_4nbX&`!v#t-#jiX6urKj>IR-nQ<}6RNpxEXV7Gsw&gNGNayLj0^(-4e(Vl} zGeNdd9JKwcrz1k^qcXd&fw}x>*&hJ+e&5~Q&D9&%xxEC=pN~0huYBD--o4}YyW<|y z9wuhfR=_Xh0>#b$jN<^0Y2_olZHq@;XjbdB{c9rdKBePfJm-BvTpR%`$ZEU`X5%1D zECXLTh_}GtU$K zX21{>q9PAjcX>$&rGxePomVndy@ZBLO{J*<$@S98-6o(I>t-5bb^j8z=sN{Yg4rG* z{L{-c{^iWph0Ioa=+Qc2HDobnrJr${&f+O~F7IFCT;7@$U)$D%*x`nCEAa~U4a~R4 z)79eSW_r1QXe^1^&nG(cszwm++_RQnS`|BAn#X))@bucU?!a&VC)e=SY2s>54zfqG z!-?fwBz>N|2zP9ka6oI($5~TfcyLC0&ebqd+QxY>iZNw?wDl2mwCeRzh=$-}YqBPa zH5|=t<%x-lE!j*;L-Fk5r_)$xvg1`K>y@pCg%ixjc-ix}tNqE^ZwzqcuuFInW1rmK+ zkb2^u&qUZiKCgGbkyeG%@sUqJQ6(U0cWS}pANpnK+GJ1U8srZnFwaIdkOZ`SU>pVY{b~gGUo}~LJ&wHB zMg%(^+m6J}*MIoY$ikh6)hpxM9TdE&lS@;#Din(Ug93dN_5J|Ol1BYDjnH!l2rzYY z4A>gwUKztr_Hd^{a`yMXUu>>c0dIDHkLkKHB$wtp*D8$Omq8j3^8H-u`sC`AroGv6z>6%`26F?CxA4!xQmOg#pzJQ__Zo1EGWzEcQNc27y;Fb#8iR z8@kA)(O*iZSGUUcv)B_1BnWLe1JBJe5 zP$Z;eICTO-$2jG;ur$LW)9fuP^G$*jUW4MH9Eto(!4G2sA|4H7B>S!1?Q*5!CH4%* z;%6U9oGt_X_L52$GOFGUB(75^cC`tH{nel7cC5yDfTKT(rLcEJPz^}YE;PHp&k@Dm zj3I@{%-Xh4L*kggP=oXP)oS9h-)Xs&>a$ohiO@P%qF%Xe=He_QI8xFPP2rX|*llKK zl8%9r)l)brY7v+14=Ko7Y-V;dXg6^Hm zkfQ6^StX%T^y%ArL8BDPHEKb!?uWLq|Hg>mqnVrABq@a{QC((8s2)5@vv2<lNz?aG`n1)z z69q-(<0y_m+;xT#yWoluuTFo#m>2RLQRhps`tOfst8U~D@_)sY; z#er_Nt8M=}g0=p&AOwPk9nv&z^A0Db?vF3*d15NEDnu`L`ee|BQnr&#j@qF7sc8FS z?N*+z$IRDUC;@y)C_&e5ObVZ`_cu~nwI84KJmSiTIGHDF{|9hZQZ0%LysG=wL?n$5 zq5h)6sH3MBUpUKTR5ITZeIhG~N-fz>{oCe_@eiT*rmJK(^I*0U{+c0DkkB+#4z4!@ z{84#rzC3ft1-K?2*cLeIL^jW{EMAkUD+N?8?8F5Je`3t@TP+p8-x)8GRsKta&pi$| zX;MCnC=!C06#G??;q#Cs;>DFSuq`?Mvf+E3B=>H57^Vbafvz<-7lW%~*R2H<_=ETa zUL7yGjy)GXJDZ(tI*tRD-P_Jih7A$|>N*Hb77KS&8IgD1%o`40%Dk|Lr~bioIhiJq zKVK^BjhY(oemQgts^uyTqrs4n6*x5%;Dtht2)!k0JbXe8NtQP(&s?wBgjTd#m#*)R z#C-tZ9pE2VN=mJ5_x8HTe|=uok_rvwY`gnyd_QG;KbPOuVBY@}X0pk&+pyriNy@ep zi%2M9B0!Rumnf>Mi7mEvcrxL4-T!QIil!&V8@clLkUr1&nZMqA9*_s8a2WT&hq?9jWJtSGojtIpD@No5eldGJLJkYi2sO zy!79r!R_=Y^3qj zB`Nr8NRne|YkR|2^Mgzi;4^;VYrg^j=H;3MIddsL(7eqF>KvF&H#hN<{l;F9lYg8C z8@J1^dR4^IpT@-(4n|K-Tw0f63W0NtR1ggkRa3*QBLPu^V5TvfKBfBPlDrx;jYG?@ zJM&SC8Itl|0qDNjGlue3hQjOue#zbva3?=&B!W{?yZ}8_5+k3T;{J<+b5UcZWh<*H zehBTSrUDOqD^r4LJ#=)8JfGci$yY13h)e_|F(F>-%QHF)Q~ZCa)u|XkODdN)`->UI zd3)$Ivq}gqQPKY%zzKlG6Y!=BFs%PdR58vcMCF;Ks?E7xti?lF| zvAArwN8D_K0vaEL5BnyZuuGx2 z&b(hmYLVxBymLp4m;<&k=%o`X83b5T^>f3&e*M?UYZvzXYWd>H{J{ly+3Vj8r&Vrc z`Os#EzYbD%z~gF&IY~W9sCYSK90{j(msv-mZEpM9VcU7#bKfc^#XP%0Mj0zi3n)F4wmja9p?Jb_q|HNG1f4 zp7+X_QNM$b#7|7HG-l^{4hD7Mh$pWnIt(ue=W>^En@Sc8ux;63JD; zLoMM)h4c{Rs|WO9q~ffZ?)5Jp-ZPWw8Q%`4U&z7bsJtPaCT|vK3I?=IlR|Th_tJ?K z11;nv$>F@qKK|3LOG`J)@3#sTGQ?jW{0Jt@$-h^v;ieLJ-NW}GJw0-qdhQ?m((!8f zp=IXrZv!F6`zK_JhZUlF42QDbq{Gk5QK-q$#)wQ)RZ5?u8k#b|*o6~X%-+>Xz~vac z)7g>bzWO!8(#AGoiebzyENt#A2MENJPCtw~F6b39rd0hD*curc>c$tL7WEo%h;wnt zeO8)R!b3MnDZ}hZ%1YfR>nUNPs|nNNqmDNDl=Pg8?8JX;dLG4|k9?+jj9-65C;>@L zV)l2-&+q(k4Epc#ps$e%pf>CyRux(mRh4Xc!VvgOw_W~C<+0^LjE*_m1H6%_?i$;>8x2m_^>3LTzQ@&2ZMD<6eb2kDVd#Z zB(TQDdO3!ROlq5dWSx4V!&`uiKdn)LNKc<8Cf0iBf4qvs6~Fq^W1Y{R?I3|{3Q>ze zN3Q^*=D|y_IRKFwj5jGFC)c9M%(AfLp1nOggq|2w(h7aN?{CtG#o)#l4U3;28o&R& zRgQbpOSkj8P}!G&85J2q$5W(9#%QjJidxl+1QE!L+R)1JT-`+Cq7zFIq0Ci%_FhE@`Ps-k@Hfa~?9!#VG8*T# zX4mY2$IQ%h2=(u5=}MI^Srq4e0ASEI&h@1DxEQnuKmDK?s|OlX)r%4ceioS-1nnum zYz^Ntc#mW)7Z1<=b>7=jq@0n>^Szn9b00iZwrqa8s;u5qzj|R-%UtR(B5CIeT@Z!2 zDIU`1FlhQ#S7%Tym>n-u|8~!9UZ#-A>bYGN{%dB=3|6?hLB$M3d;|?8{lS;DS-R)b zlsP7D46uq-#+ur+<B7g#QYLY!|mjO1Wf;S_ixn|AuM6D_z6f2RCK6X<=M|dxNy& zn5L0tRn8s?byTAe`R{&Md338znvH(s*3xl%a0D*l-;RjofUOx4&f&_cY7{&uo;ONp z8mOg+T`s!5Z@&(um3?}&)H-(Qm-0wXL|w=wm=iBkG=AWrD+>uJyHhIB{Hj^;Hf2xu z{jd~7KIhSy{;%$Neb?_->>w#*qzfWNm-jz{X;v<|x!H1sdVhM?`?$%yCW6#qmZd0` za5T&^~vvX1SwDBF6q;dP4(YkG&DCwW?&a|qJ((?B2({=6G6LK#1nEplUcu@s#yOV6>@m9&4ayU zdoFKmu~)2cL(;>ZQ2U8?=Z)DeKZL-lUU%%WQ@FflV#n|5FGl+jxGq?=IXqhod9TFA zIMar1L2b_GY@6c!_lMjfPR)vE_@*XO*lKDnBhb=7ZDrIUB3GED#XcaCr$!JLX-d{E)Zh zop*Fgm9Xyv0H-sD98-T95A;8er|0c+<8Hxzb(&Pwyrf+Z;7gXBi-@p z07A3l-}+b7N}i8Z;Qaj9%Fug(zPTs9t#$h0wZJ=4=&1+2r6F!1IU07o3jP_ED#XC`V%f?h{r<7jhb zi;w6f-zbqKUgd*T^@;EDv#8aki33|xYMAso4NnZZ)d4f-nk6dQ>k!8+Fh&nee06gL zF!aqXJ6%3i(}!+dTztVS)DdrbZ1z?$3utTPdH7Qdf0U)mZR7hy<-zjtN!C{7{ZpoNC1*;N^{^epSD%xn9p&VrDjoh9_2xmmJ=@EpEgoi8ttUyhxctY$}Ss$uc9K)0w@AJgH`swnV-Y=In&##kkhKrlOVtmF-Q{6nn` z8!e5*)cd2X6#^ah$@|C?+=a6Y460S8U{%jMNrN*sc!60GkLjHe|k++$! zR(~0hnVQ+IE{utT=IH6;*)Xpxm9M>Vv*tICJS!`72~*VY&R>q6`c*1;a2P6e6ySUT zfMBhfW=z!2%QmLCsuAXByO8m(%kqUG6noJj)ZgM2x8mK@;c(4OwB%hkVPI)_=y(`= zydA2y)*ta;NEz9z>oo(OXfrPhFME6Ytx-eJApoaYV7kJRHaMpQ9-RrX(*mvdK}(Ut zQ@*5aka`;;KA|wg8d9nTGW9SlB-KMM1i}J9B>mhX`ebbB__PINr5@>Id7s?7vme#- zT`+5+&%c>Q-pd^LnIi%#?(fj+4E5Ln&*E3==aN#oKTrq~7fMZqMaw~By%_APkNt-e z6r^EEMz+~dY@c~s9_oWX$ONU63?A+s{^O^DbH^5S6I`W{OfRwV~> z&)TCBb;Z<9szUDN`iXlVWH1J{rdF5jLAN*0qAKD#8d;QJNx*%36n9_rAN z4@i(Gl_1g9=aRHt9vH0dCH7&A8|4oDM;?HiHaW)lVtV=bT6HkJ@Mom~v0DK_txIXA;#o+w)QI z;BoRcYs^4QLa(Zf(K54?^o+OcYMegg#3-mUq|iuRBb!q|vrd>Tl=yXY^n|ak%LDKF z^Zf%>*V9-ta^l@b=8Lb9=>{zTNA0WHPit4QmCIC^1P#1cQy?XA70gnGjanUD1zRy? z6tb4$<(MsHzAGAM+MJX;7gTzkLQ8h=kw1kWE%kE&)JlN&DV^@OrEk_V9U;?OoQ?}l zcs?#-BC-c1Lm>=ZdC>UZi9rH%eUlLWcR{zZ1liOo7%?k{>naV2@KBds$0Iy>3idXU zjQH8Ow@P!xrq5D-$5e4h#e6|Yll)X;#u3K^Ina6nmr#l#0n^XEBnPpBEZLZzd!_7FbxbHDXkeSi3I7=tT&g9k?bp2~4{H+PTqx)pJp zWV_HB$?4#1C{kE6Woz6j0CEH%|N0SU-cUjZtlx?#H89C+f z#wkd~C~UY~yA+EG2nz@aaS8DWiSlW3WMG9O6P#WYC<`t)SijnzISTcRb#XSt@W`v_l}D2Xy^M7AwOHWX8@V`E>Q?`6$=PV6z)u!Ve- zlcTuX0@7#lMfx7u$Qfw;ROZNGH2S7@k?`1Zu7789ys^^Xe80=po z<+zF;r#de34ZkNqgWVGi0C#0UPP?aJo?pt<)kyJ&uv;7U<1?8Bb4vS`>Tgwb_pnPJ zt*rYuN|+e(mHb8cCM^fjJ#n|GjdWGPq=aaMq_vGSMc4i3`g$l%d*vwQ27(1pM+H{f z7PhL_bnULOXAZ^-rnVkUKUUsI*OU%A?!A5VI_b<|mFX$7>qACT`4(mojUH(lrA}hN z#0F`a>LeE!rtEdLeVZiN4%X5ihb*I_vXo6-U?=|KDFat|iJy}os9El$5mo7!#27Mo zD8@8&=SWeh;~Yt9l`UqB$jET@NykR_ND5Rmn~zoCpm2X;%Mjg#yDT795-0kT>@{{H<0dSFAA_i?hQF{ww^gB!LLQ!Rei zgY$!WzYbbT8`7WQzg)no8n8U@t{^GKiE~TT2_H9+D4~UDh?3lPMd0WzjC>WhdTnB5 z{$8h`Q`rZP+S06-utHvGXj`XMQxBbn&zJXdG>U^Yr`DG(dpnNFGn{I^&H;A#QQ!XZ z!%0q#G;c9Id4)0@6M{GX=a*W!flF1C9G$ShZSj$BvtNLp%Sn94RqTv$;Qh8|yOf6o z8M4kk_B%T3SMN6Us-|rbI{F^eG?uP&8nrqs#Q5rV&-a9I{w|i7oM0T@^?Nd9I-x)c zX7Wg-)f*Q^uCiR3HHM$*=-63R&1h?b6qg(2<=!1s;X1&|q(Jy3cQXhTfQJQ02#vM- z`vO^91bXD1k_@vdvt^V;o(37Gw;~)4iJKm!(||@{{b*8_h%GLzb5&wUezS?GhKd(Y z_D;Z%&m=epZzp0u^mj_BK<0~CruGBUPU5leo+X?4*_jRWbUVuKrm>TF^GQG9#t3m2 z+bqM#s#p?&9F+Yp)Bi`)d52T^|9|}0$B08J+c86umF$)5jKc@nJ6p%h-m){ZHzAI_ zWkmKk$e!7o5JLF9`(D@Y{L!V7E607m@7H)fA5Usbs|L|ZabY~o{K@dlN8M?oj8^x5 z21x~EB*VvgnD2=y+^MzAN3*uFn-q1q8EDGX)<--mB8zRp+iy|v98(ebyzrLm>@npt zp~r(?-(bOKJ1B@~)<26XRX@(SFjX4g?A#!>irI+d{kuc}Bn z{+MKZih#0=j0~yn-eL;hVQ7PkEw?iX&fM;JYl9ov`IR6g4F9w7)Vm9d6TPj%g~Jl0 zyLyMcRzSTJ9kKH(h*<{(T!5JpW1NP^mK45bN-B%Zi=QExdqy0O9HcOM0fi$dWQQ#^ zYVYe1{>`39iPtv8t80I8W4r&^XHM11(!?YlYq_h|YN`0$0rS zebX#lEd^urR8$5NjsZt3s<>NQv&76A&_3A+FaXRvB4W$xH@E^EjmL(tk{oJp-;+}y zG)k7Z?#)J(mj~t?Gd+k13GXjSHu5~~f1K^@2H9#!^dZ!agg=9^f6;H?gWQA+d%u!wZ08@?m1-R8yCPL?wtC zWcVwE<&Zbg#*xO+m^~nMp3TVSdGPeP&NQWr$-<7y>*~3CrtyMLHc}HP&a*|*6`)1& z-MHaoeFc6&SD#~(=6#uSo$Sf3n_SC8mW|2Ytb5G%haZ3Y#*veQfWw7(qkmpE-QZ>a znF6+;w|?ilPb%m#)6z5vppv$<-3)|;>FoXy@*ZtPqSE8K&z@G4mrpfIG3#P6vL}I} z3Lx6_Ss6(WOq1zFGhOXm_P59K@2>r>9f8OgHEjdhal?v=va%6_cJcPg%Gz4CDwd|y zLJXbNuxYKmVb8tY!ogHU)-i6Ui($IL*K`qwR$LdpfEiASh?qg(g(}vV)+uqLSBA;enCN($@ZAV@~Wj4sRpgmZe+%Ls^Mq~ zB7fMdb#%CjoklQ5gk;UEuC9KBsk>{AVqLR4dMWo?t{qq8h^!jd_pkE@|MDEbU0~Ge z`JCwBQgj)RUVf7J{^|lVQVWpo3bvY;-VFbgeHCpUR!vcNS&Bxzpi0!D@U0-z+x=T_t* z4>if3g-xA{8hbpC=??$=r4{ePMwq#xuC7&p5G*v;W|ym!wy% zcMVVai=VsOH#u$Egi%WH@$iTXs^M^(3z==N%*=e(05Z3pbO~Xn^t}pQBfWN!}3I>e}6Ud=;R;9m=oN! zHihxe))SSM{L1bF{(P9t{C#J$RHsU ze^Ji8)%|Et3|V8>)^C5#!rVqcino?$@hFH|a3}t=?3>3YQSBqB>|&_?Zg--pO1#*} z9}`cd^4tmLaxzm=C$!~%hZDOAo+nFY%lX6$?n$;A3O_NU~fJ!T6 z)CdM+{X``lh2da!bdH_|$C~^nY18ifrC#g>DJG0P`A1Lq8(9ck0cE|swDj_$CR(Zf|iH(y+~OR&hMs9h`g5sWS zyRp#Vy)P{I%rmG?r6Xls;dLf$&Bn~DFql*dLky@6R|V}$u9=l#$@i36^$uS=OZKs^ zU-{r3EIljYeidpK>y;%TAfQECj0vg4WrkyFCWyG*UIL;H{cYD>GuUUMH54gb!k^1^ z>dMqU_u7xJtBnP-HPksUP|wZjI+@7OP*4D&ZCk~v;V#y96xo`wO+g=u{+9#FFWqq{ zFdi~+>UOl0nNxu4zULP7&)rd9U)>Czoxr404d_hP6`-3Ykf)%c@DuOg?hCav5^CG5mUK$3Wq%7ZDm|Pj6Hicx!Mo1z8p_ zR|8FGL}g@pNZ`;8fpz=`&;-{xhBP}CTvAfR&ShlGHFm6;)B_Y}xJN_UD>>U=~PC&V(J9YgfnQ;e1Pn>;gER0+bpEgwo^ zI*I-@EN<;qcsfS_k)9yzsC!jAcHqL^8IYR{NDMg01#yw+I7$C*bLYkV>E`RFf6mrb zYLmQJNy3{<9~v`PvvPj(_;y(8B7KFapN+SqQoS+_#w=XpIOMq|V>+jgF3}^QLmkqFe4SHqLO@ z4^Sw6>dc|ZP`|)aJ*m->3$YD!B?PKp9h?q-vYp|Cv{Q3-x%UJ_;<_o{`xp~jBq(6r zg&hm7S}@vG<9g(?d`=koy-XmpVhO?q@N4y`Ci{SN!*+R`l1$w*6!$`g!W zw4{B7qzFZpQAhXe?hc%cpLhZ|mX8m3Prh*>;HS>DF=;;L zFI&TZKOk;YP8#lZsQW^q%s#(POL6wE%63OGf9|!(r}+i-Zd$LqgANs#B&o+bWkrQR zI16bQ1Rsj=s;crKs;|KeOH@XxFn*3{9eU1r{&8^LDv^T`0Tn1SimR@DVWDmLNrznq zUGpcwzuz4P-X>=}DP){bw1h!1f?tWc{XBdS#4a;v$SP%6e;UE%$cy3sy8OprRUCFs z9t0AJkd&v3V@;n4)o-K{TavDkL!LX!4B?kL_C_nRp8Y(y8xV5dA_N9uV5 zQW-lv(aW_nQgv|2a>S%th$L=v_K+WX@UCC(8v}z1JN7%_$|(qOxorAQbRwe#H%AjC6GJCHm6`|**iLElR(< zN_eh<=hTi{@~2N*TU&c)!h#1v3H_p%>j@vl&UH#OF@LhftO<_Oz;Y20ub40y!gHKV zeh<;~R=v5#fG7kEr-!tjFK$1!Xn3_~r%CPErL~BIe-byo^KI;cCNSjZZ>|eMi1hCp zWng2aq0rUW!N)QS@1L6kK7t{4Lto^(%3Tk-xN7F&nUrF^AhzOH zSL)7=N{dC)e-Maq6eITzA&M#aM?+k*UfeCou(RWPF85Uzjo;5Rsnt{1(!@9?JKn-E zS3PX(>|C6joXlO!U9F$Sm?jK10T&$Lj&Kw8&oG-hPla={-nzhKPJEU%vOLPWL%P9i z+S|f|VY~kI3k%*^&=2;~FG~mrTORfmv+8Ybe~%^!1nX)W#a=+N+B9_DJTnn{O- zd6ZWEEbnfNLV9`P0GPCSm#eW65ow(^d2=N{d3XvcPhoCuQC?9|etuC=1nLvG_o{UI zHu%6N>aYQluChRSzd5-FzQO!GXv;@NI6e!xM^!j83^tRyJG$1hoY%B3bkxb}n%wjK z05N&kWzb+0-=;7nLc8agPb-@SRF-skf;G z+^d>2%x)hK<3NIs54CaVgbAY+De>r8!&w1RR&J|RGJa7vnNBzn5Ng<+k|~gfgh;pPqT*jGGOLrj1;L3h zUq!45P6=nDw@xpmx!&e|->*+;Y^9kpTi^iS&V834xLN@bZ7B`32A8*G{vy^BGIi}W0QvJ8YUJ!BW7$9;KeK~)vlPbc@E=sp1k10!os?L zf358ZdDQ%{n>a8>3$Qo#0DQy4cln~oZJ&aU4ioZlOjl05z_mb>x{e(ZD4pmc7HTqK zQ-|Qf!PGwe{`G^n)wrqbiyr|pWY5g!C=~n-My89t>0Q4XW#*Gi=js=)n|}v7JI&Ih zl{gc}&AdI;H*XAu+z$tVF*y8~2Yo6E^rWN0Do*q1VdQJlN4SfC_W-I=4p{`&myFr}I$=fAc|L5{;Wh2QLU)7_6zld+v1L=;N|JD}$x8xuJJ#3N%QIWj z>a=KHK_H#L?*jrp?;>9;QBYEGtn;NU8boBm@H@@ zR(UOU{%4ITKYu?S$J&x!v$=uiIn^QFELj=v4HOdG$*F70%haJ`C?=P>WBRrX$WnX- z_DF~{Q|xz@oqbUZ5vy)3HJ~>ATK%=Lksr{>L9q%d*5-Re1YKnQH`fDldJ*&^B3!Fp@f_lg(#3i0h zos7lR_W7LsncdOfy0>mB=nrW%*~VVz+Jv1?69rZ>WXw_#?{Hw{1RDlgTFq}64{woc ztwUchCGqORmf$3*sY#bhgzjr;%QptR=KcLJNbKp4_w*PpIn}6;8~9=%A`&XTR;-Bg zjqaDsmcC2d;@0?|2=Q*0I~V!l5A2G|(80^o7nr8MO!Ai+y&O&6zD*{4D-@&0`Jm`? z55Z+dydt&6;-Z1B;hfHLR9+Y~DjW|NkM%LDVu&==sg+T^vl|4Kql;Q3lmIZ)l zW82tQiE1w%>++hyutAL2;FD66mT?pi69B0j$vyBQSjNlYCYYX@1`wej_$nI#0R=Vn zpvv0>Dm($2?oEQOOm&^%#w9ycIqK@l;ps}c`8Y}6?myy8`jz~`a1c)RcX*3Zy zf(32fn-_y1xzbX?vCn(F4)2$7B`Vj>af}jz?9lVi_-sBF)@4u4xj@dMa^H`uVxLYumo=!IpBivfA#8%WtyNf|B+gpP!#!_4I6Reufa~N>PLc1%V~Y%fnGM zgfg0&tqn!V`i%s220m$bZtm(TEs-O}%uM-6@@{lA_Jtr&MHElkEH?YJ=%RX%oP{!y z=!+P-RIX&DthF9;^;HM+$wHKhXu(moS;hVxu4^-MTc4m`kA0g*J;C2zZf!xE0U@m@ zE$P_uHH8%lEQEjM&cws4K7X~B>k4uJ48RZu#0o!DkATjR9w51J%xCEgrbYa20qN4x z%d^0PG+2Bfi>3AdT7dia6H@ISV#iNGDCAb$EcQ?hOWQj;!rp&k zW7&dT3@B|2pwD0R-;SWZdyK&T!h&Q@iPi2x{Z3}`7!#-dj{Jvgrblsug zC7)55<67owCr@o3Pj>eG*sK?s7#{{#k0nPCn5C>KRd36XD+=rDE8DhKzPnp=e>Nr5 zkkTi8N*cy5Nt6@L4@VlOG11r;isDxv)+qHknO6Q@k$w?de4RqUk$HIO_6{qKOf$&- zlPV>Qv=G)*Cc)4D{&(M)gwJ0E*AEH*eV^Oi?WNaGYj<}vx2lXq6HF%|daBmHgehz& zN@1rBEu1wO-R=U+(T2owlXDT1SzIVny~1f)ydT%Bn>kzIl3jWxHoU+mA$GRb}R^76u#E_hCQz@&azeXy+eH}|#S zDpkIWaV?L$JR3v-$_&$ej11Gkg5;?Y^PS}yJg|xy!z?5p&q30zBsw+i&-C?4!f<7s zfAb0;!K9;gY++$We|bjd&6_uR2J#l8-2Pl8t@@)=FFnrVL>^ z7}d}DV;Q216Dk>UuONGSX0~odWzTM&i8@saGnGTUk}syk`fD$q-`Q5KP0^B!5(i0; z-XjeeP2)()RF!BwySrUnHfr;>Kq5&YEiGP_mNB=0a;4oHgZ}MuaX4j@%;ocY&*<*z zhD5x~&c0VYSW)z1A>{6COTurZ36R>jBJxJY4Km%~ke8l^J!kFLE$uDh?#|9;HM4e9 z_xTNBBi*sUhHx2%3AYxEaq7wmE7~!k$%~Ptwf#-@ zJAMQt+0tQvDf#sl0NTNor2FQL{nQ?0LW27jusJsV&IW;HhERTUVY;M#f!HWk21eAQ zM~{rW4$k~;Hza^7|2frD2#7cJIh)kJ+jP8jHZsa)niz37n{K~MZU9k(Krn&P`lne&!2-0!V|8P|^W2*wPGIT&^Se4sQ04L<5b;m0y;)>zDTSiZMIJ zyfrpU^kWFxl?UT$)v&|+Z3DeHBZ+I!XW7A*6<73mV#k{VM+)cZa}$J^kRkKxm_0H= zdcDU)9;#mf9xjo4kL&-u=i>(D!fSUK0cvxLx;$ z{-x$22Z$Ws2f0g9Fs`Rdk6-qrc%sf%KF|}Bkf4WXGE)Q-`^_;rq_ivJ;A9kKE-49# zQ1G6M|M?jd`REyN3!~Gp*?4F7FHau;zs22!O`y>K{V@(1eyt_9a&Zl%V{Sug%XkU4l#y1045q zS>tU#4#YNIT1^%J`GhH0H&AWHMCU$;+OJdo<&W?%}LyZDg zPfyR;+4%!WGzkd_Lmp@$C|QYuJG4fdk!FVtK+-62+a&>b{6*hnbw3=KwRri` z+GdieN>isgt8L9Mm&(=t-nuq@^!Gaig3rgqlR=6P!^ORN`xgE6vS)sB*I|?Z!bZ>q z*jdYWw->%Wdk1>}nd)Ys4c!rRK>U39E*yr%O3;Nu9Z0lYAA&;oXt9+VJD{-mVVcHiK<%AvI-u%nYBW$qY~$Hl)oK6^G;o|L z7FKI4me^?nTpZZ)<*PgH^WXniSD36GlQ3*a5Mml0U>X8!LKmXb&aL`wAdITH#p~+Y zYj6WB0Jt6kYA$G7ENa^Jng`TDcVvkn&+CgJ*z*~mTS~HEC6RyNw~*ZQt<~KYZCs*{ zcsrhqv#{H!RPx^?+Bkyf7&s|2?sQNzCt;2^LidY(uvBAJl?SNh2eb8;mgcZwK$D_g zdfRQ}EfMoPj=^kddRn5%`*JR+R3s^4jH-}gn_fpx?`>!be|h8Gsy_|>{K5i2i6oS2 zJ8ITHF(JoHVfrBl(x&s-q-D&8Ku--KEXxhssBGa_G5NZv#UDkg$jZ2i{-zWtI{pV9Ml0jl(K|JdF2yk*IpFi;>L8qc&}n)|yU!Y-A)M z2&u_q+myra{M9p@u3fI5+Tu&w2mv?DSiS~usX}DT8p}VaIBQfrt-7GGC)qoCMBC+) zyql3 zP)ZnaW{LZxP0NzYwM;Go^qWzWcavc$R^XmTOUop9UTeW-P@k}oY_Gyo$X~S^4IouT zST^1g)6!-%I+|;)BkLZ|>sK+3U+v!4qJc}k6VrxLc2^-3;&bJvG0hk;Frs+W$^UbA zcl7lKYUhW15FHIZ`33WjDT@F zO{fejQJ`LfgF&;4wdE#AkKNllayHOrFDbyre9gm10Aod7f`{M>hlTeyXVVgw>nFfM zSD8HR3gRfyMuL7Wo5hKN@-?ld_i%W_iW6N7w1r|~JGHDIhjm(6TU(o%iA9)dE11*_ zdgS3tCh$}VoJ}1Loa_P>?cGkcugCG~wRVMJp+3OJzl%XK8s{V@yhuoaI>b}Y7&JUOJ z4zY@ZVp!ecsaLyi z9U;>q_eK(P6VAmqvJE8ZG_7C^NJ`UA)y%vP^LMW&Dr#X_CKJUx_z7f>-Q!qC^)KV% z``YB2&cedv;es(7Nd(;p6LWK`x) zUhyeJy%%Zk-teXZ3&Ve`3b1|EXC`dOQScd%o2iF^5zwJ%A!1brCT;qv)BuM`cEsZK zeKz{#9EF*3{_M=$!i2DFBDApvELZCg8^&l<&7tcnXS#vBG*zpTodRb`rpNC`D%|Y?U<{@F-Iw zcI5hnD%3aT96S9HnPjz<&bR!(ZRbmO!WsG4CgQ0413=D3)E^lQ9?wm^NJ>U_xrA)&<+v`pU~s+zoHR z@$!$pqxtdq>1+t(XkgoKZtIqB z_Zto zOnLD9`&Ya#KfRpccGGz0E1t{1KoRzlaq=Vq)n%ynv)K*KeS87Us!iOnt@y1>7{&dY z4GD8&d(jgM(-+4%x%~U*&vyU)-UfjefNY~-iL|Y!0{?}21V=)D+pkVS0|N^NPPGvV zjrql!ACI&D9s*3$#30&o2vh26dmIoM5& zXtgB1Y$66#Wj6+Xr2!;S>9v&Js#>~74@Y3f_s`gHNka2xvR#e`mN6=R7cI|#JmW0d zH4Go(LgVP@&~~@-uk z5SY0~URxtsKDU>IHASixe6xbYL6xt_naJR$(mM7<2WW-FaXb>)FHOGR&Y^F2yV~wx zD@x(w_UHXuzwhODfEe@AXNRsw$B`4B4U@5C&z!s{-n(uKZ2h|3iX%I{j5;Fuec=u& zUVbRZf9r&AzFxHA2flECQfm$I8hkRS1YVJmwzhlJ)YNsJV#G|N_|&x0WotHd<5v6S zWt>L0-(3yR>Ifl4cJ1bvqw8){Yk>OsUt?(H;!+FZNA5G+CYBt z^8_fgQIQ4~dL|=g;^~Dqvux}+H^>Rj7p)@vmkDg?q3prWw}4fIpDNn4q^#fvj|FSY zn#ymsx;Nq^9AdF*#YNIx11U0}57K`VW6ckwOi-HAmHM7f>Q$fKw;iTPKwHSkhT`Jk z0gr!u*K2s(@WwUn2hZ!P)22WeNAlp=@8874M9Xael}ZZt$FG^y_cLmbwPIr(7kEj) z@Swg&1~VWLI}wBq6cuTgv_Sl&V+BBk)>0%#fR7!cxwt46B29{o35BZ-P*PFt?g1O? z$FSNd;n$k=DyH&8+JDLPZcR`q^Vz)3ovm|UtL~k(Y_*sGSS*h&^goV=08VQ#tyIte zatdB{FvQBAd)M8&V94WP#xC%1Q49w+ z@6VqdqkW@uyOtEP=6y)bw%8}hN{aXl9j=+cW?f#Mbs2JP4k1lk1K;Gs6P%?=8S|)3 z0#yZw9U6C!%_pN?)7Q_W@#s;~xKS<3d6JldE20ZK?!U)mn33I`KSy)cn){oq3A$Ie zw~LRO<>6{zNRvF+I&i!OXErPN4IV=g-FeTOLShjtJS6vD#lhG@m>FddieQBGAd*GA z1Va+P2n^3OIWhgo$1nK64r5_5vwwrSjtYX$0BkPq0NX&cb_0zT&~GC0SSx6~zZ&qh zr{v^arO!FPy51Gb`mFuk52>x4gy}3}XPo$i2YsKO;z6czqj)AWGbP$?1Tbl`1Vse} zL6i#6IurgY*_pzq&pa(!svB#a00;evcDZ4@+s$F?<#6J8r=iYIP4A?@993+RW<#HXk(#*I`OpXYjH^HS5|g{GT3T)#BGcuDI62hL&Y(;c zb#einRZdZho{$5%EGP`Y(zd(1`(GWgv!?2>kfQhIjY@L}+dCJ#-`$UlKqBUo$1E=| z`+C~zo)*2?>UAm?qYQdO_Kk@>(85guL?no<*Z{Gvzjub4JX;SN9sK<606v!ZHI47V zvZ0ZoAt)F%gHs?K1kosM1uXT5Cz@chzm_^MjAcrNlouOuDe_Tpu`F!ZHGP5J4rcPUE zxTY&()tP}GrZ!2m1j>gOesiQh7o`#P;J3jX*9pFfep>JEl|y)49_bG)-+P}$=(T5# zB}x7Yr3K1_7)RQ-UuVwG-N5c{dJm;VfsK-FZL6yTWc*f8Tvk^%Yn1FCYT2IQPVUkk z3S%JH*u|z>&vuHyRj$wFo-_zHW9dLu9JK{xDS*)T1LS_pgBRctB!es&g3GUKf}c;h zUoylo=SiA`^-%-}j7i{Q!gXTQnbdz}JVweZ&k%J`=;}23oy{eU#T~D#tb7AoVH`}d zz{GKi*9vpTx9Tdw76DQ0qb~w*-`Mp9V5JzVs@0mEi1?&>S#GUtI(P}TjUV5` zis8NdEO`*Y0V!9JDc=KOr3~2Ac}@CU3H|cy(U#o?iHe2Z;^AwPv3#Est3$Uy_x{zhd#TaOG` z{gMdr$1Y!MEZ<`*WKf|Kb6wGU`=kp$SaSISBy;5IEa+6gLNMbp3ArK(;S4glYQOkq znGu1AFWwAC*S?Q8d0yeUMkJe0%t=MWU~MbK%m?BA`$5$4z z7VXbE^ef@P{&RKEFQMdBJ^bKd1a^U0=F~C-l7Hq<=Xu;33HnPRmp`Lm%LO=$eSO~S_A^8xO3>2xO?^Jlf~x}ZvxPKLPCI*1sP`$*?%AZJTl+tYu` zz}QvwDnMFs?8m&%-I_epZNujcr~Fysi(wC>^|~%OO6g zG+&O;T>051`IaVI`1S%Gg4QLrT72KOl_~16dUe(md1O$gU8>t_t_;Hl2ctf?NgRD| zfA7p{6scUcwbwOytZha&Ec-fpcr>-O5E>`0kt-F>^1bEK7xeq{YsFR@oH-89_wF&+ zhbD~Kp=u*{P7>6me~n*S(eClwXynm1+x)(SD)n7)Xz5aNCcPwc22<-odcXGG-08(z z>uimroj-F@Qp-)IB!7o%pSpTw`UF|j1sA0FbY`S}Ay+K%HUy*Uwg7Rj*Nm)HO#WI= ziud;yTAkne`rb~V=0RS>Q?4aIG9c{gvwAJtTfd{T$3_sOWsCH^6^BEyQTFB}IB|NbkL=qV~%(M^@I)mgo%RzuTfECaBNDrJ$~7L`?cTdeO@MI(Qo% z7D?x{+31(TVcVGSJs}>yCf*h^zb7m z1g|AT9lwMIeH#3Fbic7&l9@k8q|E9!&5LZb0>clrO2mM(fz~YKo2%HgYhfa*z<&RT zWli}O&(DuS564m_colFtTD!4^I?)sXtuz}(T#sf^t6<}cE=)EAdj`O~*XJUn=oL2SGA+ZGg98eM`p1$hUz6Y1o(VPqI7K}v7;k_@9j zpX-Hy_$|=H{sGY0k?@3GKpx-`CJLJ2eZ(-!n=EU~RLHS8xa@H$GM@xyn2z@Lc5*ZU z7^K*!q>b+OyX?DDqq~h4ZP{@ME3-~+2LXT?Xq|+nI7%u!7vz7x-ZutN5g@8(vDwwu z)uKBP8D2Zask}A=35e%>qE5gvI>j9xfX%daF@z7Jlr&Cyg8Oag)sDmN=#G#$7hQn> z&BPIEfS6Gh7E`K{E&h*8-Y9stNq?(Wq6vXSVRXO&Ys&lP@E`ghQr3|kW6ODMd-%X(Mea{DVO z0s>9E3P;{$3!jzUNcS# z5%9HJoZlgf(uQSgCgop_8$*+}4-b8JONxANPqQ<{MCO;5&6H_+G4h|F#)sZkTXelH zcA{6$ajzJ?!41|DS5;zQ*&*ubkCdC`*m-eYrapI}ZCS@BQ}8@iO0PZMwvIsSc=i>i z^$|%l1K1`tWr%n)TW;8{QolIN$79sI&E*`s9Yx@2^AiUg{h9-Tj%FS?RhD7#%NPb_HQ!bxZRk4=PyO zlLe4*T4ae$T&9N06WAXA3bW3CA_9hx6*p_kclleFMV4>d?}F%W0c{f`AoN@EVoMVw zN?X(B%X2)Et_~(uXG1ZC!;`pWdcIF^#f}o^{KYF-zBg6#1fwu9W(~?f3X#W(l~hw? zEx52E5>&MKOQgY!0kIyQERGj_zt^{wIp0JxyTx3f9M1^rIH_WjBlQ=MrA8&X(8vj? z(1c>c3!Ds86>t>vdCp+eT^X-q1(C{(^mJS0y&ob;m8CsCo;hft%-`PIODo@_K-Ka1 zL)mDj2hFQLiRkAXdHhpWmcuZECE3N$Ns2bypB`o_e=r@2d36srgegf4LD1{!jo#w) zCT9fuiniXNy{IqeqP@rmISjlA_UVMIEvK;uwfNMc*MUk8F#~v*H5do#W3K{5jr~SK zrP&zzSP3xYOA2E3t);-eg}65jf)N#m5H5dyQWy(PlC~{D6&t)iSx1dr5Gcc|K$Wc{ z=kdtO+E{o&-)40xaI;Z{U_clY!AXml>-iqM=9zW$Muvw`aYry_>oR7IIl#)FJoB5# z0t{Jh?kO60<2r6}EdNw;$!XyKwE(6@*C)qSkE_IHHx-=%O`8@b7Z)`+Kkc3wpv+{< z8yd$x&lbN(KO-KF_YbVU?#*iY+3ed?>b*M=4*0>F;IK&(^Jy+>kmH~X37F!EiyJVd zQASK=INv9Yv&Ev7K<@ipmu7#Yr}DW*HB=a+&+9CgP1-<;T^H=WqqM}1$v<~%++U=H z!VIQ`0O79WM^U!dVG|+RASFd`h)rSSD^92`K^!@s%uD7leRL*R%7PwkL1+2>MP}ra zCr{3F?{&m}^ELPP&km?2TQ>y#&@P* z{b8nH6A0dex-_J=HX1-qef)gIt?FhDXhK$0G-r8|en$u#GAMgCAWB391l(>rLjYKM zr89)EwRI5@!3`i^`~`*N=KS|1AFF;h{H95}W8Cf6IQmy{oL^{;{^sc}e@Od&X8hyV z(VspDyGZ!iN(f;<#Veqa6lOdkVOCHfA6n9Q%>HvJ!7COPTO|ka?4#c}CueIqs;^bR zFxk$*-qFquEafsYGY8Jy$h)hiTEHIBwFvCmzD$BmT~kw2UELTMMNM-2e5jKqeJ>Q& zar{-f>RoF~OHo6+K5#h~B63su&Apc|_)?{FXBO?d?SPlY-F4&iQeXT@ftV-dslS5T zeM~BQs_4z0O;&4yuHrGPDK~d?mWbExddY2oFWULd4`Wm7d{>Sn4U0H08!P%O5tDA? zAHQ;IY9A|F%l%28fsqDFCb9j8ke_xZ;z)@;>(sI{4e|$kat|)dUFO}Tw$Jyf zX~Q_gM=*r{;EQ*Zo+eSxvavxKC?0-yccyuqKFm=#lZYYHtDb5n3;l+jGN9ge^p=k@ z22EH}-ITHC!Jh9zrNW?cxqiW^LYnC0jXw3sK63&r6tt_pvZ)24PnmVCnME{6 zf)V>#yoVnX5-Wv0?OcfX&LC91F>x*`5qZFP zA7Vn@TQ!C(@**b{NtBc(R}`AH`&`uEZez3iR^obx4=w8a_YeLO?p%tFtw2kXW?3!| z6#*##NRlg(`mcO1OE$VaoSB&!{W)6Uds6}CHU^CiuuvpTZu}980aw>^X zR8gh@D`pwy!UcUJM}a^cy@w68gT~>)H0b{}oOXs%YnE>gFAQ&1N_~707RS)4v6K|#XDGA2;1Rmquh{~{N4qF;b-iz!Tb-sC zN&c#83IS)D_E;&DS6Y}3`R;n%hktFV*zJ40?resnGbi%PJ)c!id^RV1CEZgHU?i`O z$L={glAPFYYy1L5PF8tOLGJVME(M8P$!*)xQdZW>4+zqphX&@bDRM zfh-#7G&*mMEPA=yOxlpw_DR|)m${PTAjx}7$h*g;u6j1FgohT*&EN+idlmrs1IB73 zv{@8%RA6{YNlkwQ&hf(?HyVZ{O~t12t;U$WMu0Ld43o5d=`Ss$`@y!fG%0fzFk4nv zO<}>R5^L0#NK+$^zA1?t5T z*K#zmaYNP_T}rG!Bbdo5_b>~|2CB8qINq`;YzLd)KZ#|Rv#6$=>I(CZlB%pdl7_M* z9$mI&BMr2}Sp9L~=u`dPE^O`uDnENp0#>^Vd;h&;iqL2N?4Ao!59a6I!L7Tppk?8k z06?N%GnEUvB1EO_$AZN2wLfiW2I6lkq-YjG)9(cXn1x>1wlchRX-+h_KWCv-d3%D0 zDt>Nnsbxpoo-npxO+}7%YuT zDu#AVTwQTX1j*+~)uK`U{>Dmr@fJ1;w&Z?67Gv#l*YS&fox=|xkaq@eEiFBbb1s1D z$+y)|4{Sm`PJ0TK=$D&ay>6FUb%(i8(f{cOl!-+{{Acwojg7behMcO3xgLTwJrL7^ zZCch=p5)7d*LJn6m<%k_e<6~+$Fp*)&6G0zS2Vr1unkaBj(=?aIFix)d!?{p+0)kH zaC3EhwWmi|PcY2NG<5Y>4^yvePY+2Z2t5H${=ZWVhE(+QM~AznL#3>!IsxT~51*n^ zW1~#k-jRhd2lD{X#qZXmRwpp0xdxkL$M(A$J;(N%);jyBO-Xs`^=JsB+X=b)>$}pj z=g#aY!0!I$ySWJ}-$U&_M-Q{@VCIC|+vM;Rn-RRE?Zt){zJ6clnij?#vuc@7EO{xd z;vf$Vcq$1QWsT|Nj$kb0903ALp4(5pX)JDDbfj^!x)P@}rqiX|!I%ZG4aBir#cgFv zDR}MGO@ra9?w8432#v`akrf%{^_8behT!dA!hb|zLJ)t@^|C8#4QRl@)YcQQo=`cj zWZ8Ppe2i>qWld;o-ST32*x)P2wW^MEXT>w(d4F(P;1^C7uDWC&qv~r#Mji_@#xszw zvpwhK{T)Q_?e2E|{d)PIOhpOApe>y}(cY`0ddKz=i#&t>qr4;#{%UB*0gl@{kdXtZ znDg|nNaVU{xsNHx$18S`m-AKU7V57fLIfdQ31>%o}SGW73hmr(BUlF zEV}az14$|fh;%&#GrIGn(rFNpK@Svck*X4BiEAAF`(^{%f&%qxZjiy%7S!{Dqx_VcRiS5f??9gHJ1lr#*Ueh(a3SIP~2f* z1LNb%%P_kW+t?6v@Q?VV&+`azfthdXv7- zRIx~{^YI~2gK1Y9AOcpimVp8P5P~s|^pg_}&BnXmxP?Io3@A#ZKk<@VhL@F>IVqkk zB#{W$JIvx1TX{g+*2u6x90>bL9cJxV)BA~tiGtNd#aaRQ+8l_u?CpJQZTW~WQB7?4 zR9HQ*2BLeh%1>GpozyD+6*eD>!zeeLBiRv<;$F( zR0?fdTZETcSxfnHA3@+cF)?vd%u8&8jT7{3ayC#oI@#JrN@A&tXJ=<-9vtqvCBFPg ziBcvTL?B3Yj9s{ry?|;7AR6xG6$`0e@xU;_O%MRS6cG{epDeWIt1?G*%wxzu6;8BL`6fKHSjIm~6qGf_HSyb5=1_^ChZ`w6rpU zB(=|lCzijz&XD;8OQ`N@yen9yf8QBH@&m^)%%2|vN?yJPGEb8gL%bPYh>4vI@u@z0 z_J1^;bx>Pfw8eu55AF~G#frNYcc)M&l;RG>r3H#Za4+s&iWZj^m*Vd3ZiV8!`@J{s z@=usyn8{7fxo7Xa)^D-TP(*XW59{R!WkK5yF?-F~XRqZ6FYka>%fSI1Z~<+B%A>&Q zlpVK@7&OHVlmmJ1xL0V$Nj)qKhfdH}nvY?Pj;u<1TpuIF>M74vND!c=_=sX~+rucB zo3=axNFtz*G{_k8)_0;O=}Qxy1_o`&k>Dr(jQXdVUh{!Cbp6iLPYysq=k5Kow!OW+ zzPX_Wm@~T(A^}0kz_gm;$RPOy(3e$2k3^rGoE(m-Rm>`g^mL&?MAu#uVgQHBgM-t9 zqch;*AjF6{s;mU2WiCP(NMBjGix;eeP4t#lqPvYvfCzxE&&zN3JZNix`d zdOE3Tq-^21CizLnRC#JmL!Ep#I>fVc+wFcDboq7q1Ry6jVGLDb7Ap zY;!o4HFsf9u1?il9hVf7(l(YSkVif6i7!h_HQ)WpuArL}xq2pTQ%~N66ghxj55Hw)gfS#r3`LTGDN^UqW+sqD3dfFWk`NQw#w~fG`S5SFM|35CiOE zoDPzMOE6)|n8;XOiervuSmkX#+X{la!V}kGsWaHaqCM< z-4X)EuiidVg?*aOF3cCshz-|N$LD{agjAjwtAMsc#C6Y7uy~x-?d0{-b3nlJ!oqu% z^}0TPTEf5;WqKJP?kU97`fbZtV#v^PmOVMsPBn*2|A6zlwvqwcuoIEJM;sJJ8zGhF zbgZ{AUqc2YI9sb~NmaaCT3r2pGFzkt%%jT7w?AhmP10xMy<%%y(a6XVVa8^dK>f2| zk4Gs0QWgO!rLjFAq16K@Rh}zmi{CA+RNCvZ5WTWsPXXp>AyNSc77z`J0=^u*d_C63 z9d*A1K}%94WDg`HF#4kPCoOOheSop2Ri1{=ZkpAo*maUb8Yf}^cB21A79%n~+0<%# zTwx%6>{n3D{bwkGjB%9C0)nxVld-YW`qJ9-J3_hZFJ`_DB3RP2GQZ+Dh%kFiW9$Y% zxk<2aAs}u}1dtmJ{8c$TR7&bfr3sZ#DoCS?%!yRNXI7^EJodSI?$7)~%a*szNEgzj zO^*K?rmBT)9%Ez#@J%b`oI4{9Rl1>vh_Dc1D~_I z8H==VT9dV~C32yXT7RDY*@`1kJ-(exse6q(-b^EwG0%TOy>Mf=mG}F0a`Vkh!>{Ux zJsz>gq*RQC@v?ekybjbKaJ?weRA}WD8yS=nwG;Mt@dn*G>)gQU{+EQ=Vi_i7JQ65$ z7ceP5eD(9A$;U?Qle?Nl@n1YW1q81Z>W*tb;oy0;8l53P0uXz@r2t39C$y;9ni#W! zEkQtKyQpV?0%MOfPUe>3B#%PP1K~v>$WZkI5s2-ct3V1)YEDk<=KgXsuuTFCVHW0O ztr~{fK>lcvq6QAC`S)d1eooWBCp&XelZpsRd1nDRu z+4ZwF`+YHS5|6ghPt6$%0z={D`xk3j@=Fl!#R&+6Y|fRce?q^&4a^k zaA!^5UzM7Px^15)&so3Um)VNaOeY0(Co5aI7#OQ`!^*VD(h^EcP(UH=Ov|WHI4dT7 zFTt`Sh@Kfmnga_VL}Z)K2-8z|#p(&K;A2EC*#jyFN*wD1Vcdc3Y9*7d4K;Io-%xxk z3Mh1um99Fc@bY)J>7A(U*h|h*qC=&VnPccgXp}Q0#T+p-0V5v{KkfteM$_xj@0exm zz3dRnWA7iq6LGJ zND!7Wj=^3>A(#Id=qXv99S|DsK8)d_rw?ny?k7!3vRO6L&kt%Eu9aNlM!+1Eb*#I9kYBSET>Pqg~TPkB_Nl4%}URJEW)gT4UIO9-ymo0 zX>)>ipjR@tR1r+{IT93vyh;R_I%pIIro?(pIZs{+6B#KP`$+}Aw4!j93X>!{G-V_@I_k#b zpQ!tdJ!vSg@MmoK$N_2n`>Gkw?=ux6|NQ{diICpjndIc1JKak2Qtcps7$+a@4D$|y(n=ekHoCU zfB(72$;2~y#>iP&oHb){Le9^*0Mv}5V`EhnRm}Y&z+v6vMw>sS(;S;9GNk6BW@7?a z9(cVI!^3~W- z!n+HTgU?bR4JmwMhD0%sO&Rw_0C4i1(kj=_*voprnG)xYsR(FI!~#L}BO~#UUuRi@ zpH0opgMX5YFH&&7@9sLaAw2%*L^(0HCJr2Dk7gZq1ba<4hSL@X2gB|8kC>Dn#YDMz z-Oaxo4oqi>cmh(kZ13m0iwo%xsm{89A8|csKa}ZBBD`xCzcNaebVoillSe`HSOIAn zpeXLo0E~u`j*e#o^LlS`Jc|;T3KNR7Ol)m853I89r{rl4^ng<+wXjcVYYBy>pc1 z)iqz5f4tGLp8t|^Hv1P{y)(2>HhV8!z`3}QGt?EMwlp+(k6<2N0|vS#?h5_kasy8 zc#gU$b)@$wp3ryYZYK=#D7#7D zX`Zw$iSf1sRsH5WdX-|yjVlz@N~3n5b$hznEF$1}0(cXF z+CS+JN6-NDBba2+-D;n42q4LWC7t`D@=mVXy#6+FJ)l zN5Fo$*QLP0#*QXw=jG+(aiijAl#`G!puh~A=*P0fN|Ja)L@+^5NKgOuW%l=(jK*_E zWPQd9=O5n4xib>=#vTRcY{eYIwo8fQB#?(mF2#MW!{n_jn_yQ!Hd1kMvFKQkc^MWi z?(fG-;MDf3<*mEnzy0BOGaepfxm>qGBzC9CbjUCR3mzFb0#sTE6q*mKuh)(a4=d*= znm?T0hNl64IxG+kuRKyyRr~sHC#AKuQV@g9}z^DGj}1M-F@* zCfLrHr@rktn5N@a>9(#Y((W}qn7=UdyN)yh1Uo=Q!J3@ydw(FxxJJiB>$I4lKTBTjtNd!JtAm+<9Wh(z zwuQvk|1(iopShzGIZ>HwvhGhDr6kvpini#cTLz9H>5G1P{ zi$l(%ZP%c#JCO}H#|)h~oil!M$e_7hlPb;tlm3e6HCoz-=XpvHZ(omaOo5)lhG0y> zV0^4URmkdsTAY+=#zv4{O1&Hk%|COM;RWv8q?LfKdv0dFde!`fT#1V4nEGnytH2&9 z3AHopem^*T!xmMu_V-$Td6T~=nq)A2Wx6RBGBNMBX<2TWZvy`IMf}C|FjEZk+Bf<) zKYlKBGh`_E*w~;bnos?SgG8{#63->@4wzx(YWm5ia_Pu8^kow z_XmO%Fy4ncSQwXTiQx2d(oH}{S16&~hK~#u@ztlpZR6^*uG5*gk-!t)8Tq&%ZA{>D zqq*be7CR6KCjF7R$T$Daa%u7>5;by}IPsz}5iO^tl7ob1{)}z{&Ab);Q4w!n9A{zl zgfnZQtSsZ})MN_!0tZB;2!o$#h*@Jn%i*JDed+GuS&odyk~lm^Pip;4?+H%)Rk;zH zIBZaFjGV@LMPeGmeD|*E<$v@e-RxQ!4#nUH8m5Te9q3UvNrdIVo}lfxHQk7DdDWrE z7{rR`Z@u3zgkq9Og>vK?fAh@XTs-jG`R>IE4TeB95yCbA@_~fB(m|=un@Ejf0E7}K zIBP=6OFp7s(EyaY{TF?GebE#GT}%+j525xyE9Rrk(#dI?Ty~mY8>KXCi&o9H+<9{rW9b{4}JLR5n1n&628m@uL zD6N{LtihXWT>cEU0(XWZ0D@=Fubiu@)%`qQV+I5x1F3k32)DoHrdCc`aF&$YyhW_G zjUQYL&hW?$N(|fkhb~exEXW!z*o#MANd?<8Je)ZC?RACtWAzFH*7+x2Ut*Flg}%Sn zH^dy7;@o0X{WaR$DMOY#WUvG#38h*+g-vJ+L<+39So|?J4lwK&X#wV|)QRmDwHobn zQ4aKg1T9;0^TOpBAc;BrUHQS?*D}3fb00Yx6MO{|GJo$hwO{YV1U26+Htvh2Z$wrF zH^}eO`Y{@?r`0wC_e4fl*R!0c$N5LnAxpC8+yqDh3NakZO3x$*&}t{z2pwa$fN(VX z2-;x5p>OTGw-Wx=RctNi4fl%p_?msN6kMf`!#$Z&9*^w#J%5In`{6W@RgcN>hNEcU zHqGbFp4EpmIID-CGIK!3rw+$p#miu_8XNDxk>ol&2-+t$%8(9gRsYb5dE;h2&gd$= z5wt;eeR^(iE+sk~RfSMK>P0D5HlBF{`gIlv{#OVCX(iCT{<)1yEwKcDgB~r32v&kP_G!(2kl~hHLbX+mLgr1^N32 zOM&QnG~^#&KahTt#Rd@!IFYlPpl5iY3kDMP(H4F+@;6Vy1Gz0#+s~=zihZ%^FZGR? zrS58A+Lm%5hhqx5j`t^Q8@tFqQ@tuiR*(eMOne{{8bpHa+BW>dlaR0>5vFM}3+{lX zHgwM+rcL@#R}UrD@k?QJUtpV&Vj9=QYblg5aUr6^Rfm1)YWGeDjTu$?w|28uAnyv6LvX8I5+ZSWXc zQyfi2t>`~&O&2UthU`s_hy7lf8jm?-yJ*z^?2V~s0)zmc9G=EaD=k3QGuQZ_b2gFIV!EpfZ(s_S;en0`h1etSd z8F!QsG9k|+gE;9aRX#m`?qgq(V4$iEi*e~{p8IAjV^p5qSd}Mc8ijx@5kvRKFvOIr zKfP2tB9>5EnEQps+wuNYzw`wNrdA?3-$UkCu~re0tKIIK zXPc{=x4%~$SC+`jX4=K@XIf;b+RzgO!Gsu0gonRg^Uy8Zi>J2AZ)=ihplB0aGM4HQ zk&$hjZk(Ekiy(luq4;*t!lu}bqrpKyqAe$^d7R@;VU))|~eS;re z=gB-TinXladsU+@RRtb>1l`4z%x}5ABqhTFGc)oR)xMAv`oogb=!ZpwXgm~mF%Uqq z%AMDtq@o}O)h9u;;OmpCNi7kYCUF(7U}g#sd%c9TotJTHr7gTsVz@+smvi-!YxX&E zdv#x>3lwJ(djV zrr;?J>Hd)`^Gd$pBpXo&GlgofuP?Cn4ew(n)7{xM3GM@%-_?62wS%bXOwNndd@==A z@Nn0n=wx&+zwBe-)?e205%QWRh*hEvzSWR8ibwD#wnQ4=cd&8NmwLfOK17TY`F5u0 zp-t|`%Qtc6xzL%VjVFmz(PuOKX=9jSy@{yRU!TNbS0K5MvL!}4IH;NODPg6eh+{-` zQkkz*i`*^eE{ox%*TK8lQz3GfLFF5R7;_W!l{}>s#fPz{w>TW3$7Q^ALJxFR5*Y6o z{`~FDW?ttJ{pbCJl69)xW9#re8o_!wZoz|AIQjWVH z33`?dMzK+LIi`&%<+DWI^E|5jb(YMP6E!*;_Y04M3_^RI&0&d+><1NwSTzP&? z+{r_I#lJ7-a`>4e4N+IGiFkcBFjgNK%9%73{Db-W3*xpp92LdtoGHkIZWg&6Ud}ml zYVO&q@{SIqJBp9TFVHwS&CbT=@S_TWr$DEb6C~sOfn66h4Defq%E`+CFHryYm&&&D z;XBMd2DL0;qfTAWe|Ld6vx{V_U?1^CYI*gnG+@0!>&3x4`=JV4w{(Mp@XOiuwKN{o zOeLu|YG)vkN422OT*T0S?IyXD|I|;dCQl#VZ4J!~Opy<}@(u?1f8mh!`VF_d9iJOE z(TTDCoW5{G5C5(vI!e~Ds5%j5bQ}F{)zVSN#N|R#(CU|xRP6u17m|PMLod_4eE%|uwG)5IpOz1$>Cau* zSrJIZOnXqZ4XDcw@-RQP#_Eu zFar7baFyw)B@to%XCQ&u@Ymz;)tI;^Ae@>aAOPfyhK4m5#R@q4-Nd?B;VA5dKZG_u~i=b{%(IPb)I5OY zXO-NtiGf#-cf;f6y53T^Skkx9P}Ta4%=W}ikA@^9bLLnY?=-{cUpU8u@<+xBUbL2c zR-IY%ZuOjkhX$wOG6Ns=V|h>1&D&hd zI&C5%hMXQzlxnv~w&gFLWXZr;*R{r>kTQK78Jhqe3#U;f$fKP>YfvL|(n~F$DK93C z1^DApF>0CVf_~4-0DA)v=PV4RG%+$Y~D`oR-h*ZC8zlbU~#$40Pf}{}rF9uVhueYfPXwX^7vQCQ(d~ zAsD~L{R>douWzmq0#QFTN!fp-o!qk@E??r zGE_4K||PN&A5}U|r%@4O(m(v^RB7&|I8$8CEZBC_b4LZ%@03o30!Y zjJtk@3#|NZ*rauw7JmABp{M9tGlvN7)w%$5go3`i!|UtoLma<-fJ)!}i5y7P1f)5n zq|-lILBe}8RCDS`R^uKd^z=owLZ>w%J}`S^E6l}fgOR;~EuI>MR>M~>HfWurnUM@) zw`gunOTE&r=v9q@lskBXrjoINqklE3pWqf8Hz%1oo^2}KOSETAGo=uFV$jXxZb4qx z8_p(&bMW5-@I-RIzx>+54L2T52J}~dr2SfUSX~j5K6<#a8j2HraRbbb29fvnl23oo zBV?^vW`*D5S4OLH!Ze_2z6Rny-I7~oXLW%N=NByw8C3L;BK>j(MO!%g#}+35A_>@v zqDR8?6K!0Rr!I)I`Z*uNLAmdg-`w3!85pfRKa2Ys z_2{ccV!bRxu|=hgr_cG6j*-u&{5CQLEve$w1Qi6vu)qE zzg{dWTs$m;49v;9^Hrr4Frnr~M;`)q^aq-kv6s7_elMQqI)M^A$1TXR^sxHEhK3fz zkIa9-83q}EB8-9}BUx!sKV$lc;qr4Dw_O5(LpRtO=aj)~Y|CWJF}33HDneO4_bu8V!;r3 z3g5Xx;;M^RiKS$C`;Z-(9HdKIF@!=R{kPxXf5PJmbhiBW`68IVHVb{eQeN%Qhs0>| zy~GWkjMcYD%U{{V>vC6wrz_-Rc6z+Q$NR}wJx;;P%9 zS1a3HDPn%9Jr%X^$kjwh*8uroC}e!91f0GV05C#-Y0Zm+ zP&adcYKpaeu~Xv)t#)mG=i|3>)mu%NsS=v`qW(@bK*D%7zSN z*hv%p&8j*H^TlJvVn#s4sufoZA3_-5M0N2MJ?)oJiUt>fjyCQKlSqRuuIMAtP0*9T z^}zZpFJ*%GXbN2)~*C!8+_7=*0bwy=j1G(<4@ttLryQwYqw8BbR zh4ay2S{1Vig*edkN@VT>C5wNQdy+ET=_o38`+d$bGS3x1c22Hq-~XIh!O>I>o}!EO zF(853+-u(jr3=C}WccPwxy=b>G`>J>8XAH3@r$&Ix&M=>-uY zptSK^pMFc3;7wlIm(s5g;O}rdkP|G{8tz@4ESvZ&o}tfghum#D$02Uwh>85s7h3rn zT}({GI{kREbXU#%o4|xVos3H~ zgiK>!g@4#zMdChhQAU%s6Htej*NG_H#lnH7cjJf3QXoF6kbKJ=GR`=N2H&*a{9Bfn z_bkZY7iaAi=IY%U$1oJRHEycEQ0dTW%2CkyjK_nCA2+6RG_5Z)zqGV6HD~zUZKlC? z7%T8Sm&T;C@f?iB5|@=BIA`x2koOc~@8XY{Z*Uyz_^N zyHQ@Xh8`TlPfKBxLGsFlf~aQ&IKp0&)+>}aH=AgIboDiq6mI)UJTc_T3%~vJ8HT9s zja;}rDdwu$9QL-AB9`Ud+fmdcZ0MAi=@!sn-^t`_a80QeX=0fLmS?)#oVFqBl9^n2wF7DIGe z!P1d;%;Kh)6J;4Nc4JmEG)BVrUz2F&dq}@GB$$fxeSfzbrfA!q)(8`fUO-k!+Bizn?S7del ztEC0H)>WcVwXZ(Z|`$wLq&(MzioT1MJUN>sWMD zRNKwsQAiV{A7#yMa)6SGTZ#^3FQhufYk|iPbnLFNu>NuxNU##Z8os5W^rSL;*$sq@ zi_o-u%UZVapxoH~?um{R%(_xO7H{L`BFHz{pxTS7o>FpJ%dns(UT@**|=+S{_Jo&8Sj&&bBx z9agsH{WR=?Qhxjlr)hVe$$S0KF`->iA1(UnVJ~3qRKw8?DoEe$t44K%Z2hF_`_ETK z@R(`Mt9ki}_M7kE32ND|GE7yLRcWf5>VG>gJw7Q!nuI{MOgTPy+){J`ZA00~(rhvrM$LQ>s1{OI%z}>d@jLp$nnw791)*Li>ym0i1qb76d9SHJZVl`5NRgI&a;UT* zYz>_EOuo}zQz?js&XtCrYocN^9X}`9lWb~n-%lI+EbO}XY!a0`C+`*PXL&8|H$0z9 zJ57h46>e(YL{t4`jq|=~j>XwdJ8kUD3jce%j{Ql5xwql{g6gLhDoRfM**zTn@X@zk zJ`#dS!-g*OzU(4yML~&C{S5%4@C|(XQ8)cld)8au)`Doc+P*59kQB+?y{#ZuNN?9C zVQRdjV+;^G-<8Kc)1I)P2K2;t7w&1FxRNx877(OA-T&1P8VC-|9lJsWwa~&q5q0+z zXe6Bl)m+(nl&bFDXko|;Gr>3Xk0-d{RQSSot%E1{|5;>@D|I&r@_ zU+f`ZzBqo>h96@kd5A+z{xG6eFmDpUTXbk@#G63zMhbPi&HbnE^+2eBqk*XwfomkO z=*jv;u24N5|8r27MK%>BI6Y^SfFpFOvp`bnT_1l=XXm~C8+zRU9K(Zk=I$-8!IRCT zY6?T4>@$-ExkbCKEvNZ`oyij>!yLhzAw6o-)3fK~c0SWq^r)<|zg`pj$H_Zq8eDf? zpW+z76{1>O{5jg*!h)i=M4tb5tH&dXv;G->dkt&2vaoht>-M4*m!o}Fut3?*4dNfL zAu#xsF76Mi1S?0rua-8#L9Ya_{r5NYr_$1? zGTlU@hTB`IyG}q$tWdWS%CPI19}%ZuC#qvKk*2SF79-#KdYejm1Lkde>?6Ev{5)+c zu@6{?Pj`x`DA^(BTuFT=#=205rd7B2XE0*ac6|ogVm(bsRo+J<@UG7~nf0mU2 zyXgM%DQqS7SAUIqIvf<}zkLa_dR??}mBpUR*qE7A@y0VN>gzUcBUaNc<@Ikn{Oy>B z`K>+#hc9<~YicoTYCmkwyC%uXe4wrH+j6V$J?h%%Sl;sV#>nm|CO70?h7+@IW;?g~ z_&K85MN>w9VhWb#&5x?Ev5Ef+4*l|4J}QLTtOXGy^c=the)faGI^YU$P{;6a)HJk4 zvGvHU)_~GMG&pzskw`{@o+uEknfW)fH!&}lGmh4z;TuA5TpU<3mw9;V?K)I}7J6@QL*tA{AHEoL9zZ<~C&e(kp2=+$&) zzXXJs?C>-0DV^qiqwinVn%H91_ni1L%l^eScd{#U4DA(cHX=jtSaI}M?O`71yZ{o_ zMvXk7XEi2m15IyU+^M_|+ zEId9NogC2^F2f7`#n8FR#Pc4Cy2l}015q}EVsl1nk}PTV=}=du%y6m%#*;blcMGyIW~nf zx^o5GeK@$=napVEA)YCH-stD27yS9pkI|!sOU>T2Fb#%=dyiHx3lM`G@3x*&916PR zvaGcL=6rlwgm=H0o&@fQp2s>%h3+T6TEC`0e(`W}EVwWUGFTQ|KTgAQREtg>x1aYY z^n#g?qh3WdJ| zsUT69SpLHkw(wYzQF)NE(mX>zYf9%z?S;g_^F3IX#( zR80-m6Ams6{^aw_o!@dBocBai$LT+pb(K}3(~X$3o}2I)Iw4!psmE0_@=Rd>}LtV8^gLV54uuZR|K^2`=&lB^_nu^Z0iqEaCH^TCI zg8Q*Q>IEv-ZvW*x**iO%SX-Z8?hI|2Z6O6oBOxJ){YNXKjfi5Wc2q+GY!+HbR0JTn zYr5N%#7WX-MQrT&fp4d}i+dPEXhP)<3~jW_iV~Q3i+l|yJ`iof!NCM>$aVnedsrky z*1y-g(A<%a78wtZx<1TKoS~we8QC$ zKB#X=9M8m`>{3+HN`a0dlNyp0_HkEouG2(nv3Eis6Eu2T(=DX*`8_Z7aH*Vsnxnef z^U&|dp*>x3K+xanvQzY$0%{HvXko2gSoShgR`*ci*$ z2w`s1vXB4>ik=grg#(&8(sXLz@Vit6g#da)bOTt)jII<6%=+UhY@xRP5Pn8?-5GM_ zbrm_8JTek(^mI8#<8!_Ngh0P%A(|G5f@ik%vJ>{za{jD8n4M+$$(Ax?L-NQP0V}c^&cpS^(sEKC4VHJ}rV?y=X27pllfyX%&5F zQ2gR~dD^wSNwezxdtT@CyY?6FFC2y~e-F#6e4dUtjM}_5{vM#4B^~nod?npSnj(#> zhph2KplkcR68MP_mmIxs5~|HFijR zl=J8XUP8T(-|ln$(VXK-Q+;hMK>DfJ0s0XDJ`O0Lf3bC4CM$#WYV( zf1+2Sbo^O7vL+oywh$PUkFIQ!b}56f3pEF{1t3lb8|>wat0 zwu0MRq-v`kkEAuNWyTb-?}uNCWBq|9G^(Tw0#|SeBg03(r|XP4N0pT{{f{5?Lv#{4)fM=vw!up6N)`7cRN=AywggS3$_fX;jj*DT_@YD_ZL|L zqZeqm*jQQ?zpIedlu=<7LNngu#f4#&O1>bZ;UT$9d|0pLq=k|321|gCGgv?3s>%#! z7MIcFv`Kt>I=Dm)=B><+1oQP3XHSz5@18BEwLR~UfFzp;Y0B}R-Bgiv$e?O#8DFoH zbq^I`*$@*m$-&Gu^6j!nMkT7FKY0@53hV4ia@dhD359sBV`OhGnUcQ#|MCEGULI4f zFeB@2vGGtO?DdzFiqAf&t+ijRI+8*Hm?Et0eI9}B-|sHP?>XAhr{Kfs;XxT(A)P^! zaF4EsyaL{8EHIRJoO8mTn9nI4dy|nLghP$1mH=;)Hj3#q6<1V;#cnC-wq1$BKtJt& zR5^aC)Gg1LVIy(j{2}U zy&)VLW|?}KxbYDrSjGePpX^s!MSNeLpLU8Y>?*(j`2j$T&m8g*-)uIZCL(d~3{gaY z(P{C8GmvEBf$A3lYNXIZVxQ1+K}>VNVJt!FuQ4SFMgn1$C`N?xI^m_ZTOc*(O`}8k zt)%}2bOu{@OgZi8ARQyV&jf#uv4O+?=zVz0#ThW}1vx>F_{{-D&&>tllbXS?paBdN z5QIWjq@)&)8Wa=bBhrFAL3RKXW|~KuHeYKo)JKY^IHirLy#r6{+qKG`K&Gm60Sz2m zER}AG-i=I=*ozka#FnA2w=s``aw+`*Sp$4MzZc`8R!;{9x(L&qzWhX0A{m&m!=HoW z;V9Lqy==dmV?eSxJDabN^!Sr-`PdW$g}DV1-OO3+X?plOUd8k)qfupYQaV<; z1Ui2>z}Q|f(mrDC;@2Unf=}D=;V~0O9)@gQH-dsII1X}=amq~FVa+BU4bI7*_3Azz zf;gU;M!b5?cD2{TFx&BHJ4aiU&(~Ze*FIwu^h(DA=bd`?x|BNhLasi>Ls^(92*jqW zF1b083OPSDhHJ0_p{9ru^wG3^l`dsfRsY3#=&yWd3|D2-l)mzz z%ym5<1QmjO42%j64LzEtI1D|KZjZY1mtF;nPT2M zMJc~->Z<^aJ-~WpWS8kGV_3wY)mWVO5bL1g_eUZVaK0O&eo_M3F5D9y247(?RWwG@ z{?N*8L#K30aadnSAeWrpK$9@Oxe6r-MlYgk{!Dytb7}6w%234y<2`TV{^1j!^2VJw zt`kZ_G|l-2!pPp6d&9+sWnAT;y|LA*OmQK-Fc(##jG4het%CG#%1y?r?{V_ z+o-n0VJ6Nxiv%=3TqRF~ev6wIs!2(t1jIOKa5CVtal()*w@YsojIINmH(sxos8aSb zXthW|jj^JmV#Kb7ca&4uD}Jy79IaVfMM@$__`;`m0uqH+0UN+_i~G^;2!-ie6IB07fcwHC)FMSF%asd7#Iv*?R~{7Nfbt1t+1J&lxAaqO z@3vd{IPB0ViBXcsVKrVJ(^m(7c+1<%53kQ;umN=JGq#Eeg*K)V{EgqQA~B78F77G} z8iDER?8%ZRaLC-<+x?!AA)KtWH<@BK4`zsnESl^vei2ynxdOP;pRWwoC;=qE!2znu zWL?buf&gmysK>lBc-%r@sZUG=+H-(e$McKw2VZeemOpk(!-@L*btXn-R+P$$(1vs33VjQXfV^np**FCx{Xm z1cKevrV>_8q|r~cRC^annSOG!Q&3B_eIoU_FaK0a)fv2h^f4@mCA?I%;I6i{Ery;^ zSove0gam@tUPa~y`eFM8asoTEX%Msn91027;3)~@lmNV+&C7;NgwdK`jN2$^_u%I6 zpSrspAke2k1pjIanIGCMYhNEue&0rl`#qdArdDtxaZsW2V1n^)sK*aoBUiW1Wp(MNCbQ~0J4$amB359 z(AWztGL@bkfQfhkxYs6^Hzz&C&_EDF#MXaP0Bk=v%*-&&b$EHN1N7yk%Au=Ros#^W zDuMgN7tucJBJ!I^cKGGpg^e1Fq>`=+_`(5Iq6wyowVUum)M^I|Ss@s)gO$}5AE^Pz za^vOWy9NjlU+)hXjR3&i^t85?DyysQ$!woo#mDlQM1A+yiV5_pA)TL*5D_rpvIOB^ zPNWV%%Mi)&`|bopyy*benb4@ zdTSycvjNzF9cYJAxt*Is)o?zuJQl>F84l7B5Vxm8Kww2*NJeiRCeW3Ti2RZ{r3@tkRsL{qok@ifS>E zHB}(>))skrKM(mk{tO;c&c1F&z9_wCy^o;#Y<8P7gWtj|F-&+*OrA88WtB)5FFE=0 zkC~&NBn>OhDOcjGJD81DnnfregBmWxoEb=vdKT-|iX&0V*M%4iURg<=n1}~LZGz=N z1MA(cA<}&4{>$1}?+5;#(&8gOX3jMQ(NuZ)7$8ZajG7J#Jb;z_Wk3?;i*xY@H}h2h{K zmLh4SGlWRhR8`F_YEu>=Nb&ZO5|q^paM)H&J96eWPu$>oGX`~qJBy#se)Rvr@xF|5 zhvka~W2AS?^HQm-5>mU|-YgKsu*vEK@>j5>`)kSi^iB0-v9IsXpUdUtuFc8I&CSWl z$u0nCKfBwvc=)HQt7~{TsCDY!?(Qxz39)_GX&xMuA6~Grkq68mU5aXdwbV4#H8nNu zua@RN@DN7yDyQVU+`l&R`!DqD`P6eXM`UhlDWf>Nn$y6fY8Fh67K}P4KkVDE7BF%` zzwvu1EB)o&k&Q|Jm!@xSmoJsSR7qOwf`i9{= zY0l4}DqYt9wTe_))#j~iD4mVkF+jtjL1oeXJU)e)dhRvzErCs8e75$^E zW4&O!pZ7kQiQGZ_hAx#6LS)mj6HWXYNUmyAZm#7mHNT!0X3Brx&v3k)hyDBgxETom zA!*|{y-h>Dy9x9WMgqb<>@-4r@muUGo>G*|R;pV@3^EIyf>YUQl!r4VYnUhe=uX?1|QeV#}A|fL6d9N=z1270@w7Bj8lz)H}0zg%4 ze3hkyJ|ZKsCP!#$!wcqR`bejAn8kr&u4F75&@45HxS#zTs}ycQjQL2S)EgfkFMgN! z-^acLgb6TiZPE3bN@8AB>yY;$Qj&gAn+pmEKaoWKGOg>?od668a6ra6N8h`3gasvl zXGHB0MyI_=Q_gYnKS}?0I_x~(*R7_l2D6ITuh{4Hr7>lCxF1qpg%gjSS6(^PIjE{$ zqSB0c4Di5U5%A2Y(nTMRvbYHIu3=>GUnUMin{#6c8G_~KrBAQ`@ogIwyP2J8^1Dn0_OlvF{@v5l>)>j%Dc>n@$E#sSRzYHYK?#e*H2*ZNp17$T~y7#Oam z1oRFhHaxN*4ZUe7!Y_N%Z^61U^CU)SPMQ>5lu|!t{oxigUF@(#U%?Uv_ zKqwz%&0vEl4Pw<$pKQLnOMCbS6k#nQeAnxpL1}2XyFkYA-Y#%1um$v8ViO9?b#S=c^PIicUVD9TQB0rrnSiybt&x=RuWwy$FZRGO*wqyXe)Rt$uYMgTX4Ka5QTXbp7}LY!TRJu+JTI-M@THrlg|q1{ zBJ#?LL$ThrX&9^QSg0(;!+l{8u7Vp`&~=^nD#ZmyD*FqDgt3VV~F4A z=g(MaNGi1lGe7>f6u z*DVk^fEaam3;slUKpJe_q5$@e7c;;b78SKNHnRVNX@Q5rTOlFjZpb`bgA{Dvs675Y z`d3Hlu6cpd07H0Xg`O*yc6G5|iS@vbB(WclKfV?m1j^U~g-O`hM4)vz43Mtaz~)ql z>p-uslfvcgVU|!KBBzX3>>^+0B<(dn{cKBsF%%!oJ0Ao2-hr}Bo|jn_bJOTn>-EOp zEL#T}Esl$e*%1CUo6L$$&lS$MC~2K3-Q{JmndwS}ru^uKd1xXb2945!g!S8|BHwDy zi4mNcCN!oqeWyc5puwlI9Kh9spxqY9(L`n0dlD#S;Wekf!fip`us7{mT&F0oTC0)y zCG424FB|t-Vf(m`w;s3H7e{w5f_;vy9r2yt;`h&sB%L~HYh?}^rI(fMEtg?yPwPdZ z4+}-vKF$aIV^QqZB<|7sJh>-BHoGvOBq?fmrxf zD-;&>!Bty4_15V#2gUX7#>VT%Gc#kA?f-&ozJ3Myf>{|Enb{eovo^*NHui~wsr)f5 zEhw0QoT@qVZv;emoo+9{4*Ep4sJD&Dzst<*6TmxkR8qpqAP7Y2gTxC=V z(>?(`B}vQhq4MdnoEviJ^AR**0;ac)8>tA=Q-wVZM$0QfqN(xk=e=kOgltw6BEU=AfH_7%i z4wWC>r^OQIlCdq*^EY@}Q6Mu8VzTtoLGc_#CRkEl;*+GL63K3|Q#j8`%#P`Hh3*o0 z>XnBt!z8xrG?_vNrGojV3x+MmFr|lOVUtvNIp~rDCK~&k!TsNhsYz(g@}5%}E##Qb zF9ndlaCxc`V{m0v4;Gg|K|6^$X^9y9iZN!zadIuGX9V}}&Kb`o?2MXnk76O3K< zZi)Dx@7q}FKvFs|!~bd|{kX|x=$iXhk6}DqT@)|9Z1ze&9fpji`q2Z6p6|&YLCke8 zyF7$;tK7!TV*Bwh2;|bQWv8Wi{`u9__Rqw81yVrxW@k&nU5-oUY^)RLdH<_E<_cwA zNm|dz0b9#4v9Zyyv0xV-8w(3~kD{VuFaG{b9!ZkO!5sjZhkamdLPKEAsr5^P0#P=A zQz}V*uJhef??U+0)G1(Y0<96CLiL)tCPi`a@_CK%G`?Czzp8Xo)1mQf9UiBhNmCQ# z&k>`7BEJM(AyaXjVv0t{FibSGP!m4< z=id|a-VML1Lo=?TNBBOwLRDLTv@8B@5mjyH@8EI+SYS@OL4(T;p}$G*7$p8m%t=4( z6$0&F{D@9N38~s#w3j5TE#B4N{JPM!;37c^Sv#~#sOzw(uw{f?=JWdc-#&;wp6-a= zEgUT+jzlU@$xGn|09jSVapESDIO|_VFEQJ48~4r70OiD($RCR&++xb->@5MfNnE;9 zGZD##?k`AR;^fDPC_9THd=sBv*_L?QcE>5b)Q`IJet3+OE0jhOvisgaT-*L_td#8j z5HPy}*7D+F|Lpd5|84)jV*hOT{(d=gNH-D#13Vo{S^iys$_B1_o!8fNxtvMPo<<+5 z8XJpRi$EYK;B^S{^Ye3YIq%ODSD#LS!ya7VKmnpZ_$Xgc`VOWcx2{Kk*ZEe;W+t(g zs3bxxF7A6#(GCE%Jni}4sO*gEU*FCdcy1+WfyW7!s?Gb6L$3E?%H;{~IqXHPyk9P3 z$8esJS?`=u;JBihqlQK9nkiLN8Qf+o?`JhJMyu{?%6Pm;)qB_^(_5Z3r#6B)02)s53zrseSMtS<<; zREQifKK$l80)cFHrLicpnqSfP!agUT+uzHjpJ7kesjr$UEdBC*GZ@)M|4fT5SjZ4F zl#HdUCPI^pCmsRI7XpK+rC4INO=g@64}X6p0k#7FJG{qD6`G=YhuWcd4Cf#;Mj(*V z->Q(%qcZ*S3Xdipg{`$n5;lGKK)fyaXhqOEr3|Z5VPs~9F&WC0%k0mVavsdsISN0E~F=Qyf`ru z-@}NEIKojoSZY#%%!GnV+Y&caD99#H@z0UF}ldd!3dw*arHcs_KXPq-2zoV2y#25-`gDMU9HO?E?{Gb92))FHe6f;Z`?7 zniDUCDD>Ix(Ri0PK^gpumk|{TJ`JlDvzEaRHCCeWEMZYDq3JbI2xL~raq@kmOi|jr z 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�T25yD^fq{Yk!5AkxPD~#d&QC=)P37P} zo12@Uc;N=u=-MgG{!0DVcu+&_GXi(8*y~p<<2aCF%QY7=0yA~pB-e3A+z>GH@;loB z(z$b>0C6&ISrsaeNdWy}Y}^9S*f}{nt80=$H78G4ReKu6ZnG=Va zxJ?tTF?vi%t_$_-1IX#|@&EB9SSYi6o0`AZPTKqizym0g%69Wi?3M-;Ti8(!7eZf{ zt=B^b{*TFY&4+DAgU(ws%!@raq9IT;YzDSIk<#w{{nsWYS>w|)+49)QW!1*cwH{H) z&dT;&uqwNg@tqm6`8pm^-gJwJ!?3o4rLN2-+6QT<6UmJkd4~rCLm}glmB=(!JE4qm z%DmLvs(br#z?ru9QRa3mmvBaZgVz_Z z0OFOBnzsv!2s5{_**A#u-x|t!3ozY~S6sMPuz}{)dF$7mfh9gwC_()5?JseDgRxJ9 zcUl`auzAg6mBwzU`Oac@2GdlO{wFhgq$v-90b4bb-;p51@6 ztuV5^nU44=L|6^W^lt+~0mLCLdYlbb(R3pcx7e!j{G0{+lpUx%D(?w|SE&&-2@ltC|7{b4(!D5$C$ zQ3$^OHMv6`?0D|a*mhi*j*g;I=Nkls`Ate|ASBp;r!_x6&-gCRVWF7@5;mnrC7*!J zZ%|FD#E{Jjjn#wDLm*c6s_T3_PWuM~l9#1>ffJ@512+73a2I}Noh2d?i$26_o9+&+ z2Wzd{6*I8P2b0(c8GuzQm=)h0PTPYvrUWsefE|%UOG_d8W>K$D+x5o4%#spQmh=b3 z&+UR}D}K25XA!5-8oIRp*84B+@4cG#Z#?f^E@r#=|C6ca2j^dgNUR9dV5G2@oTTa> zB@TKxN~y)XK{L(-8~5?#s;DY)V#AF`^6>Bz+M&Y3!@(j*3KXl7f^!blm=H|Rj`#E^ zTfpE<&ObdfH_9}fIXO86GM?L`5_6LyJIek=zTtzP2LF(%PQ;S-8Duf(NRfQYfV#BR zkh=j?onY7>w|S*5 zd9nOQh7MvN)CuoIz%>>7b_wY#EIoI)*;4ycRPsB0yT{W_TM z5*hS3qn}pVWif)~lZ5-a26t*jN7TH&(!Tm|R6396D9s8Pp^x z`SvYnaGpj*^`dmvrwb|(sH!SKA_}N1WWfyzfdHgZKB8(|z7G$wQc_X|=A2%;+Z!9z z<7^4VLGcTAq*iOe&(JvJ2JoUW(^YxEdmtnP#Q2lbJ-`{xz3w1D6{Vtr(uv~Y&{AaT zEVpE$mveo-Wh80j>dKOz%&hgB!GI7r$0sLPh%S5VOcTWdwjW(N zu?!4OG>K+`fpWe^-}W#p z#f{9$6H$uo0XTee8pYXVjnJ&zj-VPFh?^s7^r zgdS>juK{^o8{UT0oPD=CEwP&De zzB73P+ZD;l^&EK;%rVKYi6FHlhOp{CGLL9LX z#tRt0U!k#}19An(+4`ma<}mSSZ6Q4?D=rr*qgc4R`-zA}-G9$-LEL@+m9sNGEUo)H zPi|sj2ktt#{KwY1g?8bW^fK4cT0CAH4&F-dsq9`Tm7*+t9p~RWA^-p0WuY$dD!Dh9tM*ui~3m( zKGJ{7VqG1s8KyLl_y~$tWwwoY!U#o}9Alfeo5c8f%?%o0kOIO+l8(|w-pTak_O?S6 z5ZiR;YkqveLTc-ClB$J6jzEq32Fy|FBM{ACGJmqQ^p83*`T`^nudP}EVNKDPGBHIK zj;klB$#o&)tUDT`8*x~t-d=oso_-hy2WiH(q?eM;u>CfCazcc(y0f;t7q+NFL%-Xv zzzXS$#s*&bh9ZSV{QKAp)%z7e91F#>_hWcto_*Fqp?^y&QIyJBs75`(Mpx}tp7nU@ zp8%oL!3_%H;qhM5;5)6J{`MJmyxJ=6LsmH|h#!7->0dYO{xMYs=6WHgE+hGX#iH=v z^laXLr)sq2YHkmprqWPBP)+b(1p&LCK?^opF?f3BIEv7>GLK>G-&JPJO=RrkBEAV| zu*D0UC9d}OF+a4kci&I;KKmO-q4Ym7K1USL;i2W!)*us$y*VTpzPqu;KhuU7$I^9~ z@BVy4mWeITgYC|p@p#0AoL!T6d}89~cgtc~*93YB`=aE{%^tgaEnZE`5(;q*W{^qV zo2TeM^3Le*OY0^mLH>|1xdIlXPp2JIF;v;CKG!3j__tB%#Om7WH}GkPA>S+@Fh3?E zie!o)5Ezjl6;NL}H3e?Gb+aA>8o(o<0gUnG$1^aU#QFJ!*VF=L?*My2_}YjTi)jis z^<3RW9v#j}01kOZD8u1NPvaKzuUF>*`|Y$eS?K9gI7|WJGVpfh(}35RlJMC}26l7^ zi>3MN9i7(iF3tY=P|S}s-H5epO|{$mge15fIXQn-nK6)UeP(Fn50+@f&m7Jga*$#D zFQevK#O8=Hu$&LFHu+~i)LLfWDYQK|HdImY#PGP_gSrf`>NyKMX*}930(0lVH;1D@ ziDLSUiT)*f>go3UkyqfE7Z69zcCWvVAMOlAu^!Kn#<g!SnE(zu}#-tlh(3 zW`9jLs{Oy`LWKm+3Zk0ic; zwY_OE3iSyHXhIZ~OiYM!OW*||HXMYaWXf)(ToPY!YPmYu=-Q3TTN=L#hsZ*S53%Ig zhw;l+c<_uu+D^F8=rZh3$wY>NANs>O!j9ISG~V4_ku5ZNFLkyrwgDTwi{x=@X@j@o_)zjcFkM2i7V7OF7WqK3mu!!??ip3QYD5gsU3{K}S z9+7c=H#x?%FN((G+yy~4j^O*ZxWi?7EI<~9KHG}EmEm~t)4$9vTD@_Ri7K%!0pI(D z$D3*pez|9F_EaJln`rHD)w{z9A~|#+@qMk2brmsFfO^EJ;j}mKW#Ja|7@`34ec;xHNJFXi{RWvm#`Cq56AMU=E9(L~iWU&mv zLc@MgHJ;ZUHt_&=RGBS5bF{u(r_T3edNAn6q5l~=Fq{UO{8hK0U^NsBi=1e*^x5EY(z6RlBmUwjUGvJU53_#nj<98ZAH{w z4#<>YbXTNWyved%yZw}QfreIDd6zUuYwM*q_Bbb$dl>UpAL7d8zWCB}qG;IWxtiK1 zFseFhxw>gT_a+aI^}iQPOG)XwoZx&@01y$APw`12<-1-QqO*S)SS}BQ@{3t{hB46o zF{<-&l(3!cgGifb!CMU)g(S}n^o+G;?`NiFyFJ`{De4rVZArHDrZ>4nJ(4(3%|C_C z(4_n$Lx(P!2}}K9&_d||1>sr#QSwmdu;>4@03pAu(Pno!vA?TVwZpN3XxxSo9QpB3 z3NANtiUHz2!-KSax=i#Gi4T^a!Iu;m9Pdpsya;?vSqmp7Icx=(2vR-tVkyr7jp~ z?q-6~_CXA=AQC8AY{n1qf=kknGN#pLmY@6SZ-|{5O+}rGmGJGdCvS_}ojrx|8!)Lm z2hj{r^bbzIx9B-j4m;XnGtKYLwKORikR{4_Sqrjk}RpQv`F#7A&#Fq~Z86s6;qsYf_G9PX=D#>ZX~6pAFY z_RF5P0VzHd=GS#-^$qo1o;#a6JHJ-TX%t>Z5WaN&z2LXEXdig~bE{ymPi+u%-U|6Z zoeTC^u~{N@AO*gxEc5AGjC?J&)WJ1Ziu@`qOnT))`tIfO4(0sm1?l}QlRGOX&k{GZ zfaezQ{G=oA+Iwus^>Rt<9eq#Iao44&pC@Y8*vu!zvx16Z;qH;KhEa0u{Zv191w!*Y zvXkdu>(a|706n)c(`plc{B^J*H<#=|-E4qN9y*PC_no10$`vWb&*iq+qeUGXzmPnm z`-?B+sH24|&3Q98s>9Vn(w1e01i4;LAJ`SR8WuIW>H)oqT9u|a6Pdoe1CQx9Vm0C{PHdC2Y=Sv z;%*%W9!pLWp^?h}s~gVi{{WHTF8&&Est9Scs1j_=PC;J@%hXh{SxE^&e;VUfH1Jorlh6@qn$SKH?a%qxOA%9!OKSjex$ zk*#25>S8-QNHlqgLvAuQ-tMaKb zqXuLDgATgeedk9sVj?1wS(tHceQoHAli^!_Q*(2pHUe%_+ns-_BSMS5hIg0cJl6SL zmC2SNmlYZ;b6C9`=@Ae03HsEHwbe(+(bIaCjP?j!K`$wS6I=WZki;}M?;@Vct#uQI zBoWI#-Ba=+o2>b<5%199rFB1e+7-DYEj?Dq5b@A_%h@XlvP&M#luivNKBd`;Fx;cF z=F$8VQ07>fn?aOV+T?i&AV(`Z1~s`ly-fhe8yg)haoSE)+IZMgX08y~k&D!;Uc7Ru zM}t%pr76S~b$uiv-|pN>a=>x;Ydd8ZYmkQ$;xzZaYd7oWl7O={^JpR7gFg7~m11C+ zKgIzt*o4~b5k2rh;aBwD#ObF5%qKG+OUZrd+ zhY3{(ogJ@@qO3ao`=P4*KT$v?4^9Be{CmEclehQR*_Q(r)FLrOaQZi=!E$l= z`r3?oJ7FX}CntvmG#Yfbf9b%rJu&t&7B|VKAOAbK6*AxsPAG5M&o6L)?;aZcliviG zE;IASKdOU+XWcZRqQC0eryyrx20pXixm>}`%Vf2lC_+7^!-*P zrljXGJGz*iEHV1`_;8;{1a40z$T8s4r-KD|C#3U2^==%P~A|_^#HU}oqi@)oH!jM5Hkoh(?4#qm0 zCts>ku#>gMDNSYIXs>$b54ofsF>CGGbWZjl903l~)irm_j@iX7M~@st%~|nrFA9&d zhbgnk*i?T2f?BUVwbJ5ZNDvVgh;m|7hy{7fheJ6}^R+bD9;0_sV$y5jwK;GZSZxWd z$+se?C@Q8t5vWYPmqyE`sj6p+FsXZvyRAUGhFXj&4+92jsExulOzC_}4M#RRszXj) z{mj>Kj(lsx3{0foykUs+`Jw{abVym-I0A(c{hSg>PEk=?D<;b81BOM( z#{%i|US{>dRYu#<^J~ke=ezmpN(uE$!b|*I#MXMVk}ZH3u(Fw)b-ir8Hkb+4?ekxS z!>}GibsQ!zDj0hogzfpSt$1-=vY9kO;$uv~~AA=~JI;5|!$FL5a}%I!Prx!?2FWI70MbRE{W>~28nYXFP7C2r|Fi%1Cy;~h?e2~s(6B26 zH7$zE9AHG0RQmQYybhVEl*N|zs@vQ)Pna$p58(# zlo{cNF24gu{iH`BW@VG3qn|xGX>|0yCHEX3yH`v__b*1wAgpD72)hUZTlf8kmFoJ(Ge`tu^I_6Z)rlzZ^*Sx?sD_J7s> zqBM5%gDDbB~J$j+82JVd#n=;`QB6i(VoM3o%wQ!Y5av4RpD%9P>3&Keb zgh#e#+phMEE(g4fclWji*FXT*z#1baQu`TbAh!&kVS{_zsL2yx-lXq#wx`^{vA|sZ zfbD(E5BK|b+1>$SZcljWn&Y0Dk2IEpj~B3EWOS><eJ!2x`p~XvQig{)|C$?fWlaLCR-2?Wyr$-hXog-z@j;ovobF8&1h=Owo#Zl(} zd%#;EU`$8=G5MothI+4l4}=lrYOxQYb%J8nc0c2{a?U+XdwXE|ng!7!ZSBjL6c;Yprkx+uZ@6_bzAcN_!Q6p0yYH1#6aPS z$;A7#AvR)s8Yqb684NJ~XupsNO{dpT=Jm@BTK9kCq+;w5+1P$~eLef`F3@k`hNdea zkAgsd?A}9l@Ax2A${^#U{JwcRg``s_tFyVL8tLts7MHzu0sJ+>pDE@BY@Sg@ynmJg zdmM7_m>$w55ajui!bRG`%ERO5dkC9G_uhtP%r2j8PkZWte0#?p=tGu3qz#iVdNHH? z?D@2GwCKZ!zs6^|9}0Axqjl@epQL|tt}6RsiyCJtU+`9OND?)J-V107P~13b(3%9xKcw@T*;5Yh`6cC6)W;_N=94e3YCt*0Dx>^U$BYJ>tN%0x^ z@S#~gr;3Z9WJI^cE25!sj;YB^57OQj@PPygRZ61;t7N~PBt`VK-f32}pPQN|lho=z z>NF?pO73ESIq%)OuBE?gGP;mf{ZtQ+NE~!|984fzZiCLUe-G{9yw32~2o2FBmQM5C zpQ~9gs`uac@sBj(L#N2 z(^bxoS_tqu?oOB(Xc`|K&Fr^Q)cl%6iqgLyIV6vhW){XNAuTP<%X`o-yf9xEpfHK~ z@`Xyyep@@o#J_u=s&pb_iZJ{8hg8H*I!KRp$G=NM6}w*bBF3 zxD~Gr!BbL64Ltu_8hCU5Q~JiGP){}HD--(@muXH#DVDwtyUq`I3I*Vhfw{BgIJVz~ z6HHn;*K~5H!@nR9b2>Y2WKO=q_gch_q!%p~2{IG|LUPhItx3k_=7-EAMb5j2`YEXQQe{!r!yySZ7sF=Vs#Nj3p+nCzJB9*nzNzV{8(B-;uxe;f&?T2HWZ_&W*%GsSHT6d)s%UA zeY7e_1Uf7!DLc9Byo0P7gdDHsO8~2xwz$`62W~^3xWo_n>HM4a7`b&BD)JO-Ub^mhIT%m`~wt z)wAX84l6Z}e)!dHost~>D_#%=21aS)>2%BOR?8=; zfb!B7GPWT+np;($+THCEX7G(96E!SU`4mXOf#+j+tDq?)jtH>+9xVUXJ_-j z2-KGYpTdJ&(Ja zKYfx@Q4z`@NYyITLUEHufr$6J!(L}_@U@vp-+EhFebFgOHwMxhagWR8jZy3Hckj^X zW6i9LgpmYrro>~)DDs2V9T_}e?uam78763k^6zw&XjOpeSjJt$K@ zS3HbTn$57niia|8=_wvz$tKC=Sb~$y!TuJ^wPyt`^KsokFfmVrft1vVp= zEZEBd$Q)o$ruGV#sOzwk(8zxf9KXnBFfdcei?odTvM`2t*;QZq-%ml!eM5^|-!cyS z>K3W4j8{JiRA^rH?~}xFnN`W)R`*B?E4a3f#jQM~`%U}bPh607cnPGH(pkp3+h*KQ zHxY^bA_Dn#&d%qioARsW>E>OXKv2RfCU$9l(Ipc5 zod3)2LRMB*AW($?*54rbi-AtKxp_V|_7M|Wf=J{V>FVBG!`06fy7|Dnx4o&{z=}S@ z`4Ph`?HArd{FePTKpn^T^z`I&qgLSDe*aG69Q>bC1ZACv3(I~VO6LC+i-f9Op$?*FQu{HehYs+8^38NGpbcy zjC(FiujXfS*9Cil{{hw@apAn(I zIj7KnHiVH(37C|{s^n`?cL3Y6=+)v>?7$=W?5fyYWK#KnVnXF`#yP){Iu%Q`)FY}t zyfLeSsK1xi!M|VL`?OcwnfQvpBd1t5x71NYv|&CT50+|CY-qaz9@N6+vhNPGfJgzIa67Z=mrzdwP; zrZorz>dNiLfRNFny?IJ;Pk{`4#u9iHr3xN8A`}XZhr?nqWfRydNx&%6^S0?|w1R&{ zIjl;kIG0pGm$?K8f+MFKG!XjfpVEP=V^zzgtg*bjRs;Ct=n+T= z52%W>fY_a*^rPQVOm(c#y;u=KGXf#md)a6_I3cP+SvwnBl5VGcb6009&U2Xb(0iuP zb6_bepjEv&^?LV+dJO33~;Nb#%raPeD>2gqMC zk0ZDSw~5Vc>Tt>3CeD9oY^E0spS#Hj(1)k*_u;aDNRZQhuLbVD{;ujp9FUCp?*zI7 zK=f1me;|)vR{ScxDgb=w<@|i0{|Sgk(B%+>I5_T|uROWy>Md=Yotg2nT-|f7ywBe=tgB#U!VVjuQ;ggGbrO+|&4y8p5g= z(oG+N&eVp-8Z@Jha;nQzd@=PRjs@BDS8fV7U{?Q{iE*{?(A>OWwO9Se=ntoiQWn1! zX%%-%F1?~ueS^2}4b#xKfPKu+7;SjUu%rrA74Hl#zBr`HDXA*Gy%iM|UVGAMA3ttyuVc%7ds(ES(s8jUr(G004zUQJBd9#XBP1H~%UnOFm651Oo9PJ>5v3O5XvZSy#Dv}>V^oN7k9=T$VDnv{!QjmzvvoP!Z$^LSn2TRBe zTe_ZVow>|V;pq3>ZfyR)VB9p&bZ~idAD`Rb)pYfTYL(W#AiI1ZsUGa_SDR}I^e}^A zzg4cPZ)~hA*Zw`7GD<;CE)lTWCw+4yO(*K=ov&@S%A{0jRWfd;NnJ+aIZA0zQbxOL zYM%dn!~V64Qv51LT=lpEHF+Mk3_nH?4@N>hWe|YW)aw042xl2&1JDaQ2_!R;DY)|; zb}7j-tt>1OOc?k!t2!0Vid42+szYG}5T+$0Vd{ZuXoR6^3ho|n*K_3t^1YRB%;`H6 zM5WW7S-$HFDGxsJC7fT_wZ5^M^Re^pS*qsJ+#TG_4Zw2<#JnCovo$;Gn;>fO`s7iM z4v|5EH)aT7WA7YgHm+H0FKA_M5)9EUO18_t9_rAVi3j?)>IdcoKUJ$WY-l9UuQQyR zFN#cVHdj(jHr8!wBv|zsgnbH!NMFfXP`!@<1E;ISD6YPt(a|F9*C##gW-es_>iKZz+DNix~ja<5ThrdQArJ7Oki=sdKro zRJKJSv9aS@>yw7|Un;AydN2y6H;3oMTjkGA-w0(q4zSy8|2+A_IC}YSS?ZrXFZ{Ty z3!{C`VG{Gt;=%5779e+iX-Q#ib^e=n&)M#L*1!CLPx{8}n)Ase zV}~RpyaigY9_ib|7CLE9e|Psh6somNELH&5o>;S!dz4ZSH(L%54JyNc33$t>uyOFY zY_tX^{M%05U9Spf1>RodtE5)O#vpM;gzCyv)gc;{98vd2MyACY1MeEv76P_VE#haF zb)XPeWoB$EE7=gS^7LtP7-y&H!j=IZo5JeTwxZIekAv2?ZrOWLgDti08(M}%kqr0` zg_v^WVg-Ysg>v?PL8A2D$G|nPo++n8OkIh=9NEKyxmWW=Qk@o%BQQE|zHPa3cFqi3%LGz@y_pFk z_GCaCFrz^ucWpx`R3W&&$&1B4pN)M`^Z+RUT4!HzH}bY4!8bLmJ}h zH&9GW3j$)RPLbGR6Rb?Cz6V>BbUHHLT&C;m6Z|YLJ&$@B#7BE8Ap!`?|3kDXok0PFnKny>}bwSF= zgRvE%f%8B!L(n<#4;d;XEA9CvJCha-4b6prbH!)Itlmr!QPSXg2!sNn1eeuzSzPSc zD=66gmv6+$Jpj@jNXb%DQyjgJZK_{TRiMTWxc`WnoPvgiiY{;^KlPKeyUpv@L(G2( z9r?7;AZ#y4j16}P+{ZI8Wrr3PQhhG+{Z)F;%gh)20h~RC3Z&)&9GHrVN)_UzLYb%> zch(-LlK# z13fQEOBpRl3ypz56RdR(%)1P5ck+|p$C}fFUk+Ra-D^k6Y>X-V>0d_k7h=-5ESpEa zy*y%Wig)WkriH{&(Q0rtFDBt(+e?kc`@?Gnw+0ZjWr+>eOyZDsEJn5KA!~QdC zqGxTtycsZkPpGfb(w`|5`?vqY;?8@~j~NoB*A%M%&EFJo8Wf-_2bc$aLnJmluJ7}G z&}3knHqQ3WRMNig(b!e1$;pT9V?~Mo{qT=gfDOpe5ia(Zr5LPFci^RhlWi9{ludxpRikH07! zZUh%FkOaMH;9#(d&cp#3J?6n*Xu&Vz0IxMLu6IWsZ7%^GtIJ)nhZNE;pi1UCQSk?( zIY7yeVVsE^VGd{>xJTi&}cLYr8-|H z@y@lV-zOoYqrWSE05t;ZAW&~q-rrwXn7pEw779r(m&QFd5Uw{7k9GMkY5qg>THn}< zPgS2Vq%^QTU>pZj@c?PT=k<>lr1OLeJ>C})0Vz6U2qs?#-f!g{fsZXhg8%WsVJX^x zI{5AK@-;=pZ=Vm#Za$Cx`s>Tfgj+v?NEk*GtK!nqzwNxK9=nmMZAxov1jp(p_2B@W+v~F)IG-^Ct zg|P!~$m|85sLWC?SH0&hYh(H4px4vs<=CEF)M0KB^5q^Ij-}8SPCe z+qu=1m9M)4AC@j&jAeh#>Eysh$mRy|8$yve4v=PY&ZVm{CtWkS+dG>X(R!mHr0OCv z&K8tz4Fya6D^HMn;O{%0>dK@|bP$meMW?VPSFm!>L6rEV*;@R!4Ypc-W5ja4c7OnK z!`oZG_tVzc*kASZHT6d8r(}#u{oKRglpF->-2ib%pTNNJ&9E*kkO>b$R9b)`bjcaa zWC=TQ-7)H^_+!Q!eZwC>Za;b(d8Z#<2|cj@ZW-v@EO(NM|CG#GNyuQsUT|-fSlM`r zktD|(nIeq1N{;QlLZ8X#-7UvIU~84M+peHB1|BXf2uqT9{q}M7fPr0V3TVK%uxW z80uAx&>|B+@-1`U%Pwjp29t40ntm$E{gTf29Mb4e50`$+Nx}ZKg-HkQIT=MFQ>eGx zQLNVL8j94J#h<|N*rSveai!cZ-O_w#Qy@+0NQ>Ie0{0~qb&<(r5=q5ExWZGj7#-j- z)9ozy)Jd01Az9v2v5Q$Gksb!}eBmGP!>cf*NN}%Yth=aRK-aAu{^uK29=O&>Yq~E^ zEljjVNh_U1zdrD|>~J*2nmwgi6oH{`QugNIPth*H6(}pTQtohp8*AH>EIROa# z0y#`a-ho)s=QdGd&ytlt^*W#Z_{$>FZ3J(@~l?}jbD8#vIg7LKk!@?^!T#jn1-beQP+dX{u;?v%{)cg2 zz_vT(`+APvr$ux)q@^LA8>i zh=`#GGs*VQ47`s~LNL5>x2;=A>_Iu(&oj5|TqhhXYo0*zpxqu}t65nzC!s%L<>0{tEg|b^H%o`gGS>Gd5gIj6o@Po3f=+mZALw zt)tT+kQEf>AK=U3exVuCRm)%(Iq>eXcVsvc8-#FGb!Js4r%wxmbR!syBPN4TxJnt4 zArEzDK%67w6Y62ph~8VJ5~SY)-i2k&Nmkp-42C}fYe6hfV>ez(W?#2%q6L3ku0y%% zab=aB&x1YLy^wmL=HcByr`sGe)yL^`V-7T@yLvEsdi`*d+t3;YMKf+T@sHH5WLAfy z?$SWQnb{aY9E2ff+{mj7-x|dT7Q^d|cIQbC^9cwhCVIsAru7yNmUJIC;D)~1gvp@l z9mgo3GaUzIww>cK=lWBoDr3Qg$#6%hOq7qF3Z)ng7)Bezy#`NjJjt$!f5UcW9=lRF zq4irs7l}G5LoR8=>C4wu9$1W@dul*-hRs>K@DJU z%LISN?X5J^9Z#@*+nwPC8JM4=hMP5adIo`@D+@snI=K=9cEJk+TkuM*3c~_Xm&vFZ z5TXLyIV~Y`*^M4GP`R9H7#gtafifsuLofJXpn=b?IeyM1|0U%bsdDwH$TSnsD3LtN z{6>=NRuWD%QZzTySKM+80%dsTjwwzvk|3+d|H-~mqpHQVA(~N2s@qQS9%*&Ea~Y1% zL0Uv%DY(wMy8++A9i;DMGUn(f^Gm|H9;?3v8K59kn+j!J;gANryak<- zh%kpD%@XDlHkG9K>bP#On`=&d;3D>8rf_3^`@oEiYJgCbF=nWFgsFqCTX)e^(7v`) zLkYjb3ToS^oNvy`4Q%R}>U3EIi_?idg&R^5s~{A9u|5+b*2~3PrU+hlNYDt@_UKS4 z;<_U@A}$H@4az)~x(jM*@`=?I{hq=PO?}g~B_QYVYH}xKsK-=O^O*fOUAz53lNEa= z+cM+TDlyuh=(OU~lZCx-F$D_>C0=w}w8wOb$vht$)IUGIQ8Y|xK=QEJUMqy$%43Xj zS5|$PkIwj1>R0TLmo|h9t8+r{*xS>ppGX&YXIgV`wDdCN>(Q~oVN#*S({-B05kGrZ zT+H-Rr(xpKH+76m*4HI^p4q=D$pgwplH}Z!0}Ud7pdO%bX}zNUA7zrMCv+LogX~hU zCXyFEpuPbnR#V$^?LAV${w8CaY6IQ`e_IxWx0=iqc?GfObJyKmm>^7k>X!i-$Z6Ka zM{*GSlXe+xE{VziBn(SEv9yiu{w%2xs6XjfX378dJ=0OI1expn8RDZ5xJ$eEbDXQ& z=a0EVukyh0qT!xT;9q??J;i6R_QeqsN1qVf_Fh335=@oE3M25d2)94Ft6@eD&G2q= zaXF_)iFMRt)9wG69J9TJt{O8_?x^fuXl$`-qJ5t5Yw(>BZ>BSwv+Br@ePj@+y3yn0 zsU`rg$xH4ITncZr7BV1&*91inluY_lt$jEMQPK`>_wq*)jvRJFaJY zGKRD<`|c6Ts5p)%1kTNL-}WC(!Z0Req6Ju4sVXDDTh~#6XnA(lDsyD6LPUxLEh|lVbH6!7z{3-uZB(eh-3zuV)1=31I|ritXL= zcw)0ke#a{Ia^Z5mC2GPDj2{!%^ZHoHkHYH?Iw$Al=@+?3ay+W7#3kZ7orkL9B?Eol zKl^oJcBtHM?Ov?LiCT%Vv+9;h_TW=M8zcK7w37^#axy~PX;=h{D3{ifY7{{{s7uxt zqNNF}i@eJoKNir@$6FH`O+UErnH?q%(ubXH({@&?&yD=eVQat?!>v(L;syd$D4Ys?<{lwJOdMN4;P}!AS8}u$1Efv***7NUhpd~77(2Q8yJ-DDPg$QaF^3ilG1Xj z;%m_Pj@CZ+zeuELO*u{XuM4uk3H-i z>V3c@%wvk36IjAA52vz->Q{&A`0fa zONeEriYcP}JgS*@piD-&IH<$64?ah*D4X+6~U4C3F#_6m#y%t48L^e8F9I9f$^z)ZssWu1*{HX9E&FJb;d ziCy`>^|iG>s7Cr~=A1EOiNIHLXtv+?;B$_je{~y6_PpjXY0c92p;1)hQ^dr01=uaJ zi$+mR)+B47_Gxo-lk*CHt2he$mb2&Ky!O99#xRey9n8%j|ByCknaGz|dS-SXwJ9AdG zzgJ-N6R5l5Tq#itmX$52KzLE$3iM3}MsSW76+kvQFRF_7*Sg;uu=2IxL^kmdvLN8^}&~vDV_r{rC$$dPek3| z(u$TpnzFlTV+1fEwMp8eAwuX7>+{TLbxQMG@uIzmZlQo;Q&maZgMI8jZ*_J}cAM(x zTFt2Q6X}bzQFctad5~Ud#g&pQ7Vo;v4Mw~lxrCqwwigCU8+ zfkxjAlH;O@m&>gtv9kHe8$yI8W)BIp**+tDA%|8jcNlxN_FkpB7%x4t3R6NPo}8=! z4Usk1n`OOID)VzAQe9bK3OfY_tM7MNcgDah%mC3O`2ffqH?4$K{}$Uq(F$2>e$C!O zVtNe!kAb|({Msh+!ZDZASD%3=hHIL(x~R9=Wc4g^)(-xXdTFfs)gK4Kec;4UGlr67 z0ePk*c~(0kX$kX(0E<@PO5dPDOqs>0I)Uh0L&hPPVPf5()$6PSl#-{|r*#K#ZoXx@ z0l0o{8|WTP05CJ!vzN-&;FKh;g%|^25FNz8V|1wSQ!c;>NEJvGob{LO)1V{@1m-Cl zRBV^fXIeT8z#cJ80hHpP`?CS1bgd*UwB6WEiez+Si)rV2zxd!~gUOlQ$?)b*p9FpI z+F94oeOv4D2Znw$j1oA$iW{I@FJn9Uz}`xv5)A3e#y(w z2i(476^2%pSlZ;`ZoYkH*L$YDb>k+1%>+dRlCA)@_5FM7kKV{CgH|t!9v$y!NZuxl zJM1;Cz2%%Rj5F^+%0Dh{H$;>1$@EK~NJd~M=@J%i?jCMM2IlR1q#;E(gL)Ym-sG_D1I;<6c^ZK_D*?hfe+y-#{Uh5!NAULzOT>av}~&$h%$+NpC`eVUt)XUOE7A1$29@0Au3k@Bb==AL+6|By^YAvg#T5 zbJ>M&{3h6<6;2MIHw9l-qOq0=S?OD!rQTTZ0zMOm;ZN?G>!xQ!m_oPu=NeU-vvf% zEOdW;;T`-#JYq^;yZ*Da(s|3}JRSTpjrK4L}F6?D?V2 zAO-RVhnz(e(Z@Zk1i@>W|9bPPh6WWwo1|NOcOU$e$Cx+K1k+p}y;U8Zk%Vde&0g&D z$b^qRnF0W^M$*!+0FVyB2}Qxta?gj-2cSt%3*>zt9*(h3ihF^97am>EejH%I+C-ru z`c0gZR8j*=8>0i55>f*$T_xL+MP6_2y%diW>M_Jqq1U>mA_Iq+4i>bK-s!t|U+Puh zE3k_0ZV`BEU{^dc`uAx-L8Ryy4unG-+PHr)N#$ut72C5Kf!Vms6gKfTshsz;;rrvx z?X)Ie(H0^C*u+m-8#^89AFfuT|nN{ext0JVWG!_QL*34*t4q7&xc=G z;ZKx=GJ}jHZ{}5B;Q-fI=X$;*UgJDG4k1lqM$l-}8t{+fVH=L{sNm{xTwstuyRPJc4S! z>*VUXif$gNCCWzKE@84>WBj3BL;LplcK2$oOLka+>AB8*r%#<}^7m`B+8$?T<3)B9nt=@*NEw+MV!kszXggHv~QOCTs8@2N&U{Ft9lw)ipf5sp+pIgt()km35Hg@q2pIXB9gu7sS$s=E@>b7MjgrL@5$6xs3 zNgR2OtxVP9kuSPtV3}UEM^PaDgNv0&ug|-r&YRoLWR>ZS7t$9mUU%1=LS~U$n6BDx z9AW-FD$Lm^c5d4n)S6(oiSrz1TjYg{qEIh#4k*t2CFAw&FF4!Gl-`VJG|Hj}k0SFk zNr8v7?pU>;?o`iqwhzyVn0N0v)VYsiHW}K;laz(rgWL&Lcw}>u@b%&hzqy~0->2G`$8{bbseUBub>9eobd9}XC!_BE zg2JCo4GAY2bNe1jn+G_sz_mjvlEHC-EfByN4^DhtI6H{-SeZIYCog_MP=NU8kq~c0 zWkMiEH@Hb<-j&_7N6ld`a%m|=wz0+;Lo)<@{4HXB8j^iv#SeUGYtnUhG^a8b>+g9DuHFClahqGCpARzx-vLnefJ@gs ztxHC&?kfF4`8#19Fp?x7j~eYk(7BSX<6+}E@Vvid+%pOQ|Ld*tRFX|7Jf13iM^7c$ zdICLU=Kwse@Yh{6wxwlBQDD+9tNUI@?04|N2V> vzBC_2Qdado45Uo{oiQoCcxD6i-=&{SrOhm#-cJB}XOJP<4ArRPlKlSw-=jeR literal 0 HcmV?d00001 diff --git a/images/tic-tac-toe/after_row_initialized.png b/images/tic-tac-toe/after_row_initialized.png new file mode 100644 index 0000000000000000000000000000000000000000..520d7007d5b10cac03389effdb970af65ac8066e GIT binary patch literal 51686 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 literal 0 HcmV?d00001 From eb69bff965ee57c5047afc4f615c10462c42566a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Sat, 10 Nov 2018 17:41:55 +0800 Subject: [PATCH 02/53] EX.Strings can be tricky sometimes --- README.md | 30 ++++++++++++++++-------------- 1 file changed, 16 insertions(+), 14 deletions(-) diff --git a/README.md b/README.md index 5c63c54..507fad7 100644 --- a/README.md +++ b/README.md @@ -25,7 +25,7 @@ So, here we go... - [Usage](#usage) - [👀 Examples](#👀-examples) - [Section: Strain your brain!](#section-strain-your-brain) - - [> Strings can be tricky sometimes *](#-strings-can-be-tricky-sometimes-) + - [> Strings can be tricky sometimes/微妙的字符串 *](#-strings-can-be-tricky-sometimes微妙的字符串-) - [> Time for some hash brownies!](#-time-for-some-hash-brownies) - [> Return return everywhere!](#-return-return-everywhere) - [> Deep down, we're all the same. *](#-deep-down-were-all-the-same-) @@ -155,14 +155,14 @@ Now, just run `wtfpython` at the command line which will open this collection in ## Section: Strain your brain! -### > Strings can be tricky sometimes * +### > Strings can be tricky sometimes/微妙的字符串 * 1\. ```py >>> a = "some_string" >>> id(a) 140420665652016 ->>> id("some" + "_" + "string") # Notice that both the ids are same. +>>> id("some" + "_" + "string") # 注意两个的id值是相同的. 140420665652016 ``` @@ -191,18 +191,20 @@ True False ``` -Makes sense, right? +很好理解, 对吧? -#### 💡 Explanation: -+ Such behavior is due to 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 point to the same string object in memory (thereby saving memory). -+ In the snippets above, strings are implicitly interned. The decision of when to implicitly intern a string is implementation dependent. There are some facts that can be used to guess if a string will be interned or not: - * All length 0 and length 1 strings are interned. - * Strings are interned at compile time (`'wtf'` will be interned but `''.join(['w', 't', 'f']` will not be interned) - * Strings that are not composed of ASCII letters, digits or underscores, are not interned. This explains why `'wtf!'` was not interned due to `!`. Cpython implementation of this rule can be found [here](https://github.com/python/cpython/blob/3.6/Objects/codeobject.c#L19) - -+ 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 compiler optimization and specifically applies to the interactive environment. -+ Constant folding is a technique for [peephole optimization](https://en.wikipedia.org/wiki/Peephole_optimization) in Python. This means the expression `'a'*20` is replaced by `'aaaaaaaaaaaaaaaaaaaa'` during compilation to reduce few clock cycles during runtime. Constant folding only occurs for strings having length less than 20. (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. +#### 💡 说明: +- 这些行为是由于 Cpython 在编译优化时, 某些情况下会尝试使用已经存在的不可变对象而不是每次都创建一个新对象. (这种行为被称作字符串的驻留[string interning]) +- 发生驻留之后, 许多变量可能指向内存中的相同字符串对象. (从而节省内存) +- 在上面的代码中, 字符串是隐式驻留的. 何时发生隐式驻留则取决于具体的实现. 这里有一些方法可以用来猜测字符串是否会被驻留: + - 所有长度为 0 和长度为 1 的字符串都被驻留. + - 字符串在编译时被实现 (`'wtf'` 将被驻留, 但是 `''.join(['w', 't', 'f']` 将不会被驻留) + - 字符串中只包含字母，数字或下划线时将会驻留. 所以 `'wtf!'` 由于包含 `!` 而未被驻留. 可以在[这里](https://github.com/python/cpython/blob/3.6/Objects/codeobject.c#L19)找到 CPython 对此规则的实现. + + + +- 当在同一行将 `a` 和 `b` 的值设置为 `"wtf!"` 的时候, Python 解释器会创建一个新对象, 然后同时引用第二个变量. 如果你在不同的行上进行赋值操作, 它就不会“知道”已经有一个 `wtf！` 对象 (因为 `"wtf!"` 不是按照上面提到的方式被隐式驻留的). 它是一种编译器优化, 特别适用于交互式环境. +- 常量折叠(constant folding) 是 Python 中的一种 [窥孔优化(peephole optimization)](https://en.wikipedia.org/wiki/Peephole_optimization) 技术. 这意味着在编译时表达式 `'a'*20` 会被替换为 `'aaaaaaaaaaaaaaaaaaaa'` 以减少运行时的时钟周期. 只有长度小于 20 的字符串才会发生常量折叠. (为啥? 想象一下由于表达式 `'a'*10**10` 而生成的 `.pyc` 文件的大小). 相关的源码实现在[这里](https://github.com/python/cpython/blob/3.6/Python/peephole.c#L288). --- From eff078c67243a71a5ef645ddadfdaef2f374eff1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Sat, 10 Nov 2018 23:22:19 +0800 Subject: [PATCH 03/53] EX.Time for some hash brownies --- README.md | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/README.md b/README.md index 507fad7..e5c4ef4 100644 --- a/README.md +++ b/README.md @@ -26,7 +26,7 @@ So, here we go... - [👀 Examples](#👀-examples) - [Section: Strain your brain!](#section-strain-your-brain) - [> Strings can be tricky sometimes/微妙的字符串 *](#-strings-can-be-tricky-sometimes微妙的字符串-) - - [> Time for some hash brownies!](#-time-for-some-hash-brownies) + - [> Time for some hash brownies!/是时候来点蛋糕了!](#-time-for-some-hash-brownies是时候来点蛋糕了) - [> Return return everywhere!](#-return-return-everywhere) - [> Deep down, we're all the same. *](#-deep-down-were-all-the-same-) - [> For what?](#-for-what) @@ -209,7 +209,8 @@ False --- -### > Time for some hash brownies! +### > Time for some hash brownies!/是时候来点蛋糕了! +* hash brownie指一种含有大麻成分的蛋糕, 所以这里是句双关 1\. ```py @@ -229,21 +230,21 @@ some_dict[5] = "Python" "Python" ``` -"Python" destroyed the existence of "JavaScript"? +"Python" 消除了 "JavaScript" 的存在? -#### 💡 Explanation +#### 💡 说明: -* Python dictionaries check for equality and compare the hash value to determine if two keys are the same. -* Immutable objects with same value always have the same hash in Python. +* Python 字典通过检查键值是否相等和比较哈希值来确定两个键是否相同. +* 具有相同值的不可变对象在Python中始终具有相同的哈希值. ```py >>> 5 == 5.0 True >>> hash(5) == hash(5.0) True ``` - **Note:** Objects with different values may also have same hash (known as hash collision). -* When the statement `some_dict[5] = "Python"` is executed, the existing value "JavaScript" is overwritten with "Python" because Python recognizes `5` and `5.0` as the same keys of the dictionary `some_dict`. -* This StackOverflow [answer](https://stackoverflow.com/a/32211042/4354153) explains beautifully the rationale behind it. + **注意:** 具有不同值的对象也可能具有相同的哈希值（哈希冲突）. +* 当执行 `some_dict[5] = "Python"` 语句时, 因为Python将 `5` 和 `5.0` 识别为 `some_dict` 的同一个键, 所以已有值 "JavaScript" 就被 "Python" 覆盖了. +* 这个 StackOverflow的 [回答](https://stackoverflow.com/a/32211042/4354153) 漂亮的解释了这背后的基本原理. --- From 12c5c259273f9670dd757c027bcc15645250c53c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Sun, 11 Nov 2018 00:36:35 +0800 Subject: [PATCH 04/53] EX.Return return everywhere --- README.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index e5c4ef4..6298d36 100644 --- a/README.md +++ b/README.md @@ -27,7 +27,7 @@ So, here we go... - [Section: Strain your brain!](#section-strain-your-brain) - [> Strings can be tricky sometimes/微妙的字符串 *](#-strings-can-be-tricky-sometimes微妙的字符串-) - [> Time for some hash brownies!/是时候来点蛋糕了!](#-time-for-some-hash-brownies是时候来点蛋糕了) - - [> Return return everywhere!](#-return-return-everywhere) + - [> Return return everywhere!/到处返回！](#-return-return-everywhere到处返回) - [> Deep down, we're all the same. *](#-deep-down-were-all-the-same-) - [> For what?](#-for-what) - [> Evaluation time discrepancy](#-evaluation-time-discrepancy) @@ -248,7 +248,7 @@ some_dict[5] = "Python" --- -### > Return return everywhere! +### > Return return everywhere!/到处返回！ ```py def some_func(): @@ -264,10 +264,10 @@ def some_func(): 'from_finally' ``` -#### 💡 Explanation: +#### 💡 说明: -- When a `return`, `break` or `continue` statement is executed in the `try` suite of a "try…finally" statement, the `finally` clause is also executed ‘on the way out. -- The return value of a function is determined by the last `return` statement executed. Since the `finally` clause always executes, a `return` statement executed in the `finally` clause will always be the last one executed. +- 当在 "try...finally" 语句的 `try` 中执行 `return`, `break` 或 `continue` 后, `finally` 子句依然会执行. +- 函数的返回值由最后执行的 `return` 语句决定. 由于 `finally` 子句一定会执行, 所以 `finally` 子句中的 `return` 将始终是最后执行的语句. --- From 0e675fda1d45538db5a40a299b3c5e76ff27725c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Mon, 12 Nov 2018 22:40:48 +0800 Subject: [PATCH 05/53] EX.Deep down, we're all the same --- README.md | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/README.md b/README.md index 6298d36..c18865d 100644 --- a/README.md +++ b/README.md @@ -28,7 +28,7 @@ So, here we go... - [> Strings can be tricky sometimes/微妙的字符串 *](#-strings-can-be-tricky-sometimes微妙的字符串-) - [> Time for some hash brownies!/是时候来点蛋糕了!](#-time-for-some-hash-brownies是时候来点蛋糕了) - [> Return return everywhere!/到处返回！](#-return-return-everywhere到处返回) - - [> Deep down, we're all the same. *](#-deep-down-were-all-the-same-) + - [> Deep down, we're all the same./本质上,我们都一样. *](#-deep-down-were-all-the-same本质上我们都一样-) - [> For what?](#-for-what) - [> Evaluation time discrepancy](#-evaluation-time-discrepancy) - [> `is` is not what it is!](#-is-is-not-what-it-is) @@ -271,7 +271,7 @@ def some_func(): --- -### > Deep down, we're all the same. * +### > Deep down, we're all the same./本质上,我们都一样. * ```py class WTF: @@ -280,22 +280,22 @@ class WTF: **Output:** ```py ->>> WTF() == WTF() # two different instances can't be equal +>>> WTF() == WTF() # 两个不同的对象应该不相等 False ->>> WTF() is WTF() # identities are also different +>>> WTF() is WTF() # 也不相同 False ->>> hash(WTF()) == hash(WTF()) # hashes _should_ be different as well +>>> hash(WTF()) == hash(WTF()) # 哈希值也应该不同 True >>> id(WTF()) == id(WTF()) True ``` -#### 💡 Explanation: +#### 💡 说明: -* When `id` was called, Python created a `WTF` class object and passed it to the `id` function. The `id` function takes its `id` (its memory location), and throws away the object. The object is destroyed. -* When we do this twice in succession, Python allocates the same memory location to this second object as well. Since (in CPython) `id` uses the memory location as the object id, the id of the two objects is the same. -* So, object's id is unique only for the lifetime of the object. After the object is destroyed, or before it is created, something else can have the same id. -* But why did the `is` operator evaluated to `False`? Let's see with this snippet. +* 当调用 `id` 函数时, Python 创建了一个 `WTF` 类的对象并传给 `id` 函数. 然后 `id` 函数获取其id值 (也就是内存地址), 然后丢弃该对象. 该对象就被销毁了. +* 当我们连续两次进行这个操作时, Python会将相同的内存地址分配给第二个对象. 因为 (在CPython中) `id` 函数使用对象的内存地址作为对象的id值, 所以两个对象的id值是相同的. +* 综上, 对象的id值仅仅在对象的生命周期内唯一. 在对象被销毁之后, 或被创建之前, 其他对象可以具有相同的id值. +* 那为什么 `is` 操作的结果为 `False` 呢? 让我们看看这段代码. ```py class WTF(object): def __init__(self): print("I") @@ -317,7 +317,7 @@ True D True ``` - As you may observe, the order in which the objects are destroyed is what made all the difference here. + 正如你所看到的, 对象销毁的顺序是造成所有不同之处的原因. --- From 247c4688bbbe5b9c7c07b391ee4cba3f6cef9ac6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Tue, 13 Nov 2018 00:17:43 +0800 Subject: [PATCH 06/53] EX.For what --- README.md | 23 ++++++++++++----------- 1 file changed, 12 insertions(+), 11 deletions(-) diff --git a/README.md b/README.md index c18865d..5cd8e3a 100644 --- a/README.md +++ b/README.md @@ -29,7 +29,7 @@ So, here we go... - [> Time for some hash brownies!/是时候来点蛋糕了!](#-time-for-some-hash-brownies是时候来点蛋糕了) - [> Return return everywhere!/到处返回！](#-return-return-everywhere到处返回) - [> Deep down, we're all the same./本质上,我们都一样. *](#-deep-down-were-all-the-same本质上我们都一样-) - - [> For what?](#-for-what) + - [> For what?/为什么?](#-for-what为什么) - [> Evaluation time discrepancy](#-evaluation-time-discrepancy) - [> `is` is not what it is!](#-is-is-not-what-it-is) - [> A tic-tac-toe where X wins in the first attempt!](#-a-tic-tac-toe-where-x-wins-in-the-first-attempt) @@ -321,7 +321,7 @@ True --- -### > For what? +### > For what?/为什么? ```py some_string = "wtf" @@ -332,18 +332,19 @@ for i, some_dict[i] in enumerate(some_string): **Output:** ```py ->>> some_dict # An indexed dict is created. +>>> some_dict # 创建了索引字典. {0: 'w', 1: 't', 2: 'f'} ``` -#### 💡 Explanation: +#### 💡 说明: -* A `for` statement is defined in the [Python grammar](https://docs.python.org/3/reference/grammar.html) as: +* [Python 语法](https://docs.python.org/3/reference/grammar.html) 中对 `for` 的定义是: ``` for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite] ``` - Where `exprlist` is the assignment target. This means that the equivalent of `{exprlist} = {next_value}` is **executed for each item** in the iterable. - An interesting example that illustrates this: + 其中 `exprlist` 指分配目标. 这意味着对可迭代对象中的**每一项都会执行**类似 `{exprlist} = {next_value}` 的操作. + + 一个有趣的例子说明了这一点: ```py for i in range(4): print(i) @@ -358,13 +359,13 @@ for i, some_dict[i] in enumerate(some_string): 3 ``` - Did you expect the loop to run just once? + 你可曾觉得这个循环只会运行一次? - **💡 Explanation:** + **💡 说明:** - - The assignment statement `i = 10` never affects the iterations of the loop because of the way for loops work in Python. Before the beginning of every iteration, the next item provided by the iterator (`range(4)` this case) is unpacked and assigned the target list variables (`i` in this case). + - 由于循环在Python中工作方式, 赋值语句 `i = 10` 并不会影响迭代循环, 在每次迭代开始之前, 迭代器(这里指 `range(4)`) 生成的下一个元素就被解包并赋值给目标列表的变量(这里指 `i`)了. -* The `enumerate(some_string)` function yields a new value `i` (A counter going up) and a character from the `some_string` in each iteration. It then sets the (just assigned) `i` key of the dictionary `some_dict` to that character. The unrolling of the loop can be simplified as: +* 在每一次的迭代中, `enumerate(some_string)` 函数就生成一个新值 `i` (计数器增加) 并从 `some_string` 中获取一个字符. 然后将字典 `some_dict` 键 `i` (刚刚分配的) 的值设为该字符. 本例中循环的展开可以简化为: ```py >>> i, some_dict[i] = (0, 'w') >>> i, some_dict[i] = (1, 't') From 3722a015e55f2abc71b280d82d4acd8977c12e3e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Tue, 13 Nov 2018 22:23:52 +0800 Subject: [PATCH 07/53] EX.Evaluation time discrepancy --- README.md | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/README.md b/README.md index 5cd8e3a..eb985bd 100644 --- a/README.md +++ b/README.md @@ -30,7 +30,7 @@ So, here we go... - [> Return return everywhere!/到处返回！](#-return-return-everywhere到处返回) - [> Deep down, we're all the same./本质上,我们都一样. *](#-deep-down-were-all-the-same本质上我们都一样-) - [> For what?/为什么?](#-for-what为什么) - - [> Evaluation time discrepancy](#-evaluation-time-discrepancy) + - [> Evaluation time discrepancy/评估时间差异](#-evaluation-time-discrepancy评估时间差异) - [> `is` is not what it is!](#-is-is-not-what-it-is) - [> A tic-tac-toe where X wins in the first attempt!](#-a-tic-tac-toe-where-x-wins-in-the-first-attempt) - [> The sticky output function](#-the-sticky-output-function) @@ -375,7 +375,7 @@ for i, some_dict[i] in enumerate(some_string): --- -### > Evaluation time discrepancy +### > Evaluation time discrepancy/评估时间差异 1\. ```py @@ -411,13 +411,13 @@ array_2[:] = [1,2,3,4,5] [1,2,3,4,5] ``` -#### 💡 Explanation +#### 💡 说明 -- In a [generator](https://wiki.python.org/moin/Generators) expression, the `in` clause is evaluated at declaration time, but the conditional clause is evaluated at runtime. -- So before runtime, `array` is re-assigned to the list `[2, 8, 22]`, and since out of `1`, `8` and `15`, only the count of `8` is greater than `0`, the generator only yields `8`. -- The differences in the output of `g1` and `g2` in the second part is due the way variables `array_1` and `array_2` are re-assigned values. -- In the first case, `array_1` is binded 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]`). +- 在[生成器](https://wiki.python.org/moin/Generators)表达式中, `in` 子句在声明时执行, 而条件子句则是在运行时执行. +- 所以在运行前, `array` 已经被重新赋值为 `[2, 8, 22]`, 因此对于之前的 `1`, `8` 和 `15`, 只有 `count(8)` 的结果是大于 `0` 的, 所以生成器只会生成 `8`. +- 第二部分中 `g1` 和 `g2` 的输出差异则是由于变量 `array_1` 和 `array_2` 被重新赋值的方式导致的. +- 在第一种情况下, `array_1` 被绑定到新对象 `[1,2,3,4,5]`, 因为 `in` 子句是在声明时被执行的， 所以它仍然引用旧对象 `[1,2,3,4]`(并没有被销毁). +- 在第二种情况下, 对 `array_2` 的切片赋值将相同的旧对象 `[1,2,3,4]` 原地更新为 `[1,2,3,4,5]`. 因此 `g2` 和 `array_2` 仍然引用同一个对象(这个对象现在已经更新为 `[1,2,3,4,5]`). --- From 5511533dda6fee6982175fafca1f4bd5692e3d9c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Tue, 13 Nov 2018 23:57:05 +0800 Subject: [PATCH 08/53] EX.is is not what it is --- README.md | 34 +++++++++++++++++----------------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/README.md b/README.md index eb985bd..18a00ed 100644 --- a/README.md +++ b/README.md @@ -31,7 +31,7 @@ So, here we go... - [> Deep down, we're all the same./本质上,我们都一样. *](#-deep-down-were-all-the-same本质上我们都一样-) - [> For what?/为什么?](#-for-what为什么) - [> Evaluation time discrepancy/评估时间差异](#-evaluation-time-discrepancy评估时间差异) - - [> `is` is not what it is!](#-is-is-not-what-it-is) + - [> `is` is not what it is!/出人意料的`is`!](#-is-is-not-what-it-is出人意料的is) - [> A tic-tac-toe where X wins in the first attempt!](#-a-tic-tac-toe-where-x-wins-in-the-first-attempt) - [> The sticky output function](#-the-sticky-output-function) - [> `is not ...` is not `is (not ...)`](#-is-not--is-not-is-not-) @@ -421,9 +421,9 @@ array_2[:] = [1,2,3,4,5] --- -### > `is` is not what it is! +### > `is` is not what it is!/出人意料的`is`! -The following is a very famous example present all over the internet. +下面是一个在互联网上非常有名的例子. ```py >>> a = 256 @@ -441,26 +441,26 @@ False True ``` -#### 💡 Explanation: +#### 💡 说明: -**The difference between `is` and `==`** +**`is` 和 `==` 的区别** -* `is` operator checks if both the operands refer to the same object (i.e., it checks if the identity of the operands matches or not). -* `==` operator compares the values of both the operands and checks if they are the same. -* So `is` is for reference equality and `==` is for value equality. An example to clear things up, +* `is` 运算符检查两个运算对象是否引用自同一对象 (即, 它检查两个预算对象是否相同). +* `==` 运算符比较两个运算对象的值是否相等. +* 因此 `is` 代表引用相同, `==` 代表值相等. 下面的例子可以很好的说明这点, ```py >>> [] == [] True - >>> [] is [] # These are two empty lists at two different memory locations. + >>> [] is [] # 这两个空列表位于不同的内存地址. False ``` -**`256` is an existing object but `257` isn't** +**`256` 是一个已经存在的对象, 而 `257` 不是** -When you start up python the numbers from `-5` to `256` will be allocated. These numbers are used a lot, so it makes sense just to have them ready. +当你启动Python 的时候, `-5` 到 `256` 的数值就已经被分配好了. 这些数字因为经常使用所以适合被提前准备好. -Quoting from https://docs.python.org/3/c-api/long.html -> The current implementation keeps an array of integer objects for all integers between -5 and 256, when you create an int in that range you just get back a reference to the existing object. So it should be possible to change the value of 1. I suspect the behavior of Python, in this case, is undefined. :-) +引用自 https://docs.python.org/3/c-api/long.html +> 当前的实现为-5到256之间的所有整数保留一个整数对象数组, 当你创建了一个该范围内的整数时, 你只需要返回现有对象的引用. 所以改变1的值是有可能的. 我怀疑这种行为在Python中是未定义行为. :-) ```py >>> id(256) @@ -481,9 +481,9 @@ Quoting from https://docs.python.org/3/c-api/long.html 140084850247344 ``` -Here the interpreter isn't smart enough while executing `y = 257` to recognize that we've already created an integer of the value `257,` and so it goes on to create another object in the memory. +这里解释器并没有智能到能在执行 `y = 257` 时意识到我们已经创建了一个整数 `257`, 所以它在内存中又新建了另一个对象. -**Both `a` and `b` refer to the same object when initialized with same value in the same line.** +**当 `a` 和 `b` 在同一行中使用相同的值初始化时，会指向同一个对象.** ```py >>> a, b = 257, 257 @@ -499,8 +499,8 @@ Here the interpreter isn't smart enough while executing `y = 257` to recognize t 140640774013488 ``` -* When a and b are set to `257` in the same line, the Python interpreter creates a new object, then references the second variable at the same time. If you do it on separate lines, it doesn't "know" that there's already `257` as an object. -* It's a compiler optimization and specifically applies to the interactive environment. When you enter two lines in a live interpreter, they're compiled separately, therefore optimized separately. If you were to try this example in a `.py` file, you would not see the same behavior, because the file is compiled all at once. +* 当 a 和 b 在同一行中被设置为 `257` 时, Python 解释器会创建一个新对象, 然后同时引用第二个变量. 如果你在不同的行上进行, 它就不会 "知道" 已经存在一个 `257` 对象了. +* 这是一种特别为交互式环境做的编译器优化. 当你在实时解释器中输入两行的时候, 他们会单独编译, 因此也会单独进行优化. 如果你在 `.py` 文件中尝试这个例子, 则不会看到相同的行为, 因为文件是一次性编译的. --- From 48f78efc887c5bfce60e504c59ea7833332c3622 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Wed, 14 Nov 2018 22:32:23 +0800 Subject: [PATCH 09/53] EX.A tic-tac-toe where X wins in the first attempt --- README.md | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/README.md b/README.md index 18a00ed..47387cd 100644 --- a/README.md +++ b/README.md @@ -32,7 +32,7 @@ So, here we go... - [> For what?/为什么?](#-for-what为什么) - [> Evaluation time discrepancy/评估时间差异](#-evaluation-time-discrepancy评估时间差异) - [> `is` is not what it is!/出人意料的`is`!](#-is-is-not-what-it-is出人意料的is) - - [> A tic-tac-toe where X wins in the first attempt!](#-a-tic-tac-toe-where-x-wins-in-the-first-attempt) + - [> A tic-tac-toe where X wins in the first attempt!/一蹴即至!](#-a-tic-tac-toe-where-x-wins-in-the-first-attempt一蹴即至) - [> The sticky output function](#-the-sticky-output-function) - [> `is not ...` is not `is (not ...)`](#-is-not--is-not-is-not-) - [> The surprising comma](#-the-surprising-comma) @@ -504,12 +504,12 @@ True --- -### > A tic-tac-toe where X wins in the first attempt! +### > A tic-tac-toe where X wins in the first attempt!/一蹴即至! ```py -# Let's initialize a row +# 我们先初始化一个变量row row = [""]*3 #row i['', '', ''] -# Let's make a board +# 并创建一个变量board board = [row]*3 ``` @@ -526,19 +526,19 @@ board = [row]*3 [['X', '', ''], ['X', '', ''], ['X', '', '']] ``` -We didn't assign 3 "X"s or did we? +我们有没有赋值过3个 "X" 呢？ -#### 💡 Explanation: +#### 💡 说明: -When we initialize `row` variable, this visualization explains what happens in the memory +当我们初始化 `row` 变量时, 下面这张图展示了内存中的情况。 ![image](/images/tic-tac-toe/after_row_initialized.png) -And when the `board` is initialized by multiplying the `row`, this is what happens inside the memory (each of the elements `board[0]`, `board[1]` and `board[2]` is a reference to the same list referred by `row`) +而当通过对 `row` 做乘法来初始化 `board` 时, 内存中的情况则如下图所示 (每个元素 `board[0]`, `board[1]` 和 `board[2]` 都和 `row` 一样引用了同一列表.) ![image](/images/tic-tac-toe/after_board_initialized.png) -We can avoid this scenario here by not using `row` variable to generate `board`. (Asked in [this](https://github.com/satwikkansal/wtfpython/issues/68) issue). +我们可以通过不使用变量 `row` 生成 `board` 来避免这种情况. ([这个](https://github.com/satwikkansal/wtfpython/issues/68)issue提出了这个需求.) ```py >>> board = [['']*3 for _ in range(3)] From cbacd3e93bea1c8d61bb900ff4464a7081a2146f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Wed, 14 Nov 2018 23:37:34 +0800 Subject: [PATCH 10/53] EX.The sticky output function --- README.md | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/README.md b/README.md index 47387cd..7030e8d 100644 --- a/README.md +++ b/README.md @@ -33,7 +33,7 @@ So, here we go... - [> Evaluation time discrepancy/评估时间差异](#-evaluation-time-discrepancy评估时间差异) - [> `is` is not what it is!/出人意料的`is`!](#-is-is-not-what-it-is出人意料的is) - [> A tic-tac-toe where X wins in the first attempt!/一蹴即至!](#-a-tic-tac-toe-where-x-wins-in-the-first-attempt一蹴即至) - - [> The sticky output function](#-the-sticky-output-function) + - [> The sticky output function/麻烦的输出](#-the-sticky-output-function麻烦的输出) - [> `is not ...` is not `is (not ...)`](#-is-not--is-not-is-not-) - [> The surprising comma](#-the-surprising-comma) - [> Backslashes at the end of string](#-backslashes-at-the-end-of-string) @@ -549,7 +549,7 @@ board = [row]*3 --- -### > The sticky output function +### > The sticky output function/麻烦的输出 ```py funcs = [] @@ -570,9 +570,10 @@ funcs_results = [func() for func in funcs] >>> funcs_results [6, 6, 6, 6, 6, 6, 6] ``` -Even when the values of `x` were different in every iteration prior to appending `some_func` to `funcs`, all the functions return 6. -//OR +即使每次在迭代中将 `some_func` 加入 `funcs` 前的 `x` 值都不相同, 所有的函数还是都返回6. + +// 再换个例子 ```py >>> powers_of_x = [lambda x: x**i for i in range(10)] @@ -580,11 +581,11 @@ Even when the values of `x` were different in every iteration prior to appending [512, 512, 512, 512, 512, 512, 512, 512, 512, 512] ``` -#### 💡 Explanation +#### 💡 说明: -- When defining a function inside a loop that uses the loop variable in its body, the loop function's closure is bound to the variable, not its value. So all of the functions use the latest value assigned to the variable for computation. +- 当在循环内部定义一个函数时, 如果该函数在其主体中使用了循环变量, 则闭包函数将与循环变量绑定, 而不是它的值. 因此, 所有的函数都是使用最后分配给变量的值来进行计算的. -- To get the desired behavior you can pass in the loop variable as a named variable to the function. **Why this works?** Because this will define the variable again within the function's scope. +- 可以通过将循环变量作为命名变量传递给函数来获得预期的结果. **为什么这样可行?** 因为这会在函数内再次定义一个局部变量. ```py funcs = [] From 778e6507461c2b35ae7791024affe7dab9cd811e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Wed, 14 Nov 2018 23:59:59 +0800 Subject: [PATCH 11/53] EX.is not ...is (not ...) --- README.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index 7030e8d..c1118e8 100644 --- a/README.md +++ b/README.md @@ -34,7 +34,7 @@ So, here we go... - [> `is` is not what it is!/出人意料的`is`!](#-is-is-not-what-it-is出人意料的is) - [> A tic-tac-toe where X wins in the first attempt!/一蹴即至!](#-a-tic-tac-toe-where-x-wins-in-the-first-attempt一蹴即至) - [> The sticky output function/麻烦的输出](#-the-sticky-output-function麻烦的输出) - - [> `is not ...` is not `is (not ...)`](#-is-not--is-not-is-not-) + - [> `is not ...` is not `is (not ...)`/`is not ...` 不是 `is (not ...)`](#-is-not--is-not-is-not-is-not--不是-is-not-) - [> The surprising comma](#-the-surprising-comma) - [> Backslashes at the end of string](#-backslashes-at-the-end-of-string) - [> not knot!](#-not-knot) @@ -604,7 +604,7 @@ funcs_results = [func() for func in funcs] --- -### > `is not ...` is not `is (not ...)` +### > `is not ...` is not `is (not ...)`/`is not ...` 不是 `is (not ...)` ```py >>> 'something' is not None @@ -613,10 +613,10 @@ True False ``` -#### 💡 Explanation +#### 💡 说明: -- `is not` is a single binary operator, and has behavior different than using `is` and `not` separated. -- `is not` evaluates to `False` if the variables on either side of the operator point to the same object and `True` otherwise. +- `is not` 是个单独的二进制运算符, 和分别使用 `is` 和 `not` 不同. +- 如果操作符两侧的变量指向同一个对象, 则 `is not` 的结果为 `False`, 否则结果为 `True`. --- From 804332247f0608d667a64f394adfbc11e799da2b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Thu, 15 Nov 2018 23:16:06 +0800 Subject: [PATCH 12/53] EX.The surprising comma --- README.md | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/README.md b/README.md index c1118e8..458c51a 100644 --- a/README.md +++ b/README.md @@ -35,7 +35,7 @@ So, here we go... - [> A tic-tac-toe where X wins in the first attempt!/一蹴即至!](#-a-tic-tac-toe-where-x-wins-in-the-first-attempt一蹴即至) - [> The sticky output function/麻烦的输出](#-the-sticky-output-function麻烦的输出) - [> `is not ...` is not `is (not ...)`/`is not ...` 不是 `is (not ...)`](#-is-not--is-not-is-not-is-not--不是-is-not-) - - [> The surprising comma](#-the-surprising-comma) + - [> The surprising comma/意外的逗号](#-the-surprising-comma意外的逗号) - [> Backslashes at the end of string](#-backslashes-at-the-end-of-string) - [> not knot!](#-not-knot) - [> Half triple-quoted strings](#-half-triple-quoted-strings) @@ -620,7 +620,7 @@ False --- -### > The surprising comma +### > The surprising comma/意外的逗号 **Output:** ```py @@ -642,12 +642,11 @@ SyntaxError: invalid syntax SyntaxError: invalid syntax ``` -#### 💡 Explanation: - -- Trailing comma is not always legal in formal parameters list of a Python function. -- In Python, the argument list is defined partially with leading commas and partially with trailing commas. This conflict causes situations where a comma is trapped in the middle, and no rule accepts it. -- **Note:** The trailing comma problem is [fixed in Python 3.6](https://bugs.python.org/issue9232). The remarks in [this](https://bugs.python.org/issue9232#msg248399) post discuss in brief different usages of trailing commas in Python. +#### 💡 说明: +- 在Python函数的形式参数列表中, 尾随逗号并不一定是合法的. +- 在Python中, 参数列表部分用前置逗号定义, 部分用尾随逗号定义. 这种冲突导致逗号被夹在中间, 没有规则定义它.(译:这一句看得我也很懵逼,只能强翻了.详细解释看下面的讨论帖会一目了然.) +- **注意:** 尾随逗号的问题已经在Python 3.6中被[修复](https://bugs.python.org/issue9232)了. 而这篇[帖子](https://bugs.python.org/issue9232#msg248399)中则简要讨论了Python中尾随逗号的不同用法. --- ### > Backslashes at the end of string From e6b45f50bdffdef936dbb5afa7a69f8477b93c70 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Fri, 16 Nov 2018 00:06:33 +0800 Subject: [PATCH 13/53] EX.Backslashes at the end of string --- README.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index 458c51a..8abbfe1 100644 --- a/README.md +++ b/README.md @@ -36,7 +36,7 @@ So, here we go... - [> The sticky output function/麻烦的输出](#-the-sticky-output-function麻烦的输出) - [> `is not ...` is not `is (not ...)`/`is not ...` 不是 `is (not ...)`](#-is-not--is-not-is-not-is-not--不是-is-not-) - [> The surprising comma/意外的逗号](#-the-surprising-comma意外的逗号) - - [> Backslashes at the end of string](#-backslashes-at-the-end-of-string) + - [> Backslashes at the end of string/字符串末尾的反斜杠](#-backslashes-at-the-end-of-string字符串末尾的反斜杠) - [> not knot!](#-not-knot) - [> Half triple-quoted strings](#-half-triple-quoted-strings) - [> Midnight time doesn't exist?](#-midnight-time-doesnt-exist) @@ -649,7 +649,7 @@ SyntaxError: invalid syntax - **注意:** 尾随逗号的问题已经在Python 3.6中被[修复](https://bugs.python.org/issue9232)了. 而这篇[帖子](https://bugs.python.org/issue9232#msg248399)中则简要讨论了Python中尾随逗号的不同用法. --- -### > Backslashes at the end of string +### > Backslashes at the end of string/字符串末尾的反斜杠 **Output:** ``` @@ -665,14 +665,14 @@ SyntaxError: invalid syntax SyntaxError: EOL while scanning string literal ``` -#### 💡 Explanation +#### 💡 说明: -- In a raw string literal, as indicated by the prefix `r`, the backslash doesn't have the special meaning. +- 在以 `r` 开头的原始字符串中, 反斜杠并没有特殊含义. ```py >>> print(repr(r"wt\"f")) 'wt\\"f' ``` -- What the interpreter actually does, though, is simply change the behavior of backslashes, so they pass themselves and the following character through. That's why backslashes don't work at the end of a raw string. +- 解释器所做的只是简单的改变了反斜杠的行为, 因此会直接放行反斜杠及后一个的字符. 这就是反斜杠在原始字符串末尾不起作用的原因. --- From 9eba4a387e0f01363d516510d1d0b32b6ea81f44 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Fri, 16 Nov 2018 22:38:53 +0800 Subject: [PATCH 14/53] EX.not knot --- README.md | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/README.md b/README.md index 8abbfe1..503c46b 100644 --- a/README.md +++ b/README.md @@ -37,7 +37,7 @@ So, here we go... - [> `is not ...` is not `is (not ...)`/`is not ...` 不是 `is (not ...)`](#-is-not--is-not-is-not-is-not--不是-is-not-) - [> The surprising comma/意外的逗号](#-the-surprising-comma意外的逗号) - [> Backslashes at the end of string/字符串末尾的反斜杠](#-backslashes-at-the-end-of-string字符串末尾的反斜杠) - - [> not knot!](#-not-knot) + - [> not knot!/别纠结!](#-not-knot别纠结) - [> Half triple-quoted strings](#-half-triple-quoted-strings) - [> Midnight time doesn't exist?](#-midnight-time-doesnt-exist) - [> What's wrong with booleans?](#-whats-wrong-with-booleans) @@ -676,7 +676,7 @@ SyntaxError: EOL while scanning string literal --- -### > not knot! +### > not knot!/别纠结! ```py x = True @@ -694,12 +694,12 @@ True SyntaxError: invalid syntax ``` -#### 💡 Explanation: +#### 💡 说明: -* Operator precedence affects how an expression is evaluated, and `==` operator has higher precedence than `not` operator in Python. -* So `not x == y` is equivalent to `not (x == y)` which is equivalent to `not (True == False)` finally evaluating to `True`. -* But `x == not y` raises a `SyntaxError` because it can be thought of being equivalent to `(x == not) y` and not `x == (not y)` which you might have expected at first sight. -* The parser expected the `not` token to be a part of the `not in` operator (because both `==` and `not in` operators have the same precedence), but after not being able to find an `in` token following the `not` token, it raises a `SyntaxError`. +* 运算符的优先级会影响表达式的求值顺序, 而在 Python 中 `==` 运算符的优先级要高于 `not` 运算符. +* 所以 `not x == y` 相当于 `not (x == y)`, 同时等价于 `not (True == False)`, 最后的运算结果就是 `True`. +* 之所以 `x == not y` 会抛一个 `SyntaxError` 异常, 是因为它会被认为等价于 `(x == not) y`, 而不是你一开始期望的 `x == (not y)`. +* 解释器期望 `not` 标记是 `not in` 操作符的一部分 (因为 `==` 和 `not in` 操作符具有相同的优先级), 但是它在 `not` 标记后面找不到 `in` 标记, 所以会抛出 `SyntaxError` 异常. --- From de3bd9c7c5b1aadf1684d49cee9870fd2a995d66 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Fri, 16 Nov 2018 23:26:17 +0800 Subject: [PATCH 15/53] EX.Half triple-quoted strings --- README.md | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index 503c46b..7e3a3b2 100644 --- a/README.md +++ b/README.md @@ -38,7 +38,7 @@ So, here we go... - [> The surprising comma/意外的逗号](#-the-surprising-comma意外的逗号) - [> Backslashes at the end of string/字符串末尾的反斜杠](#-backslashes-at-the-end-of-string字符串末尾的反斜杠) - [> not knot!/别纠结!](#-not-knot别纠结) - - [> Half triple-quoted strings](#-half-triple-quoted-strings) + - [> Half triple-quoted strings/三个引号](#-half-triple-quoted-strings三个引号) - [> Midnight time doesn't exist?](#-midnight-time-doesnt-exist) - [> What's wrong with booleans?](#-whats-wrong-with-booleans) - [> Class attributes and instance attributes](#-class-attributes-and-instance-attributes) @@ -703,7 +703,7 @@ SyntaxError: invalid syntax --- -### > Half triple-quoted strings +### > Half triple-quoted strings/三个引号 **Output:** ```py @@ -711,20 +711,20 @@ SyntaxError: invalid syntax wtfpython >>> print("wtfpython""") wtfpython ->>> # The following statements raise `SyntaxError` +>>> # 下面的语句会抛出 `SyntaxError` 异常 >>> # print('''wtfpython') >>> # print("""wtfpython") ``` -#### 💡 Explanation: -+ Python supports implicit [string literal concatenation](https://docs.python.org/2/reference/lexical_analysis.html#string-literal-concatenation), Example, +#### 💡 说明: ++ Python 提供隐式的[字符串链接](https://docs.python.org/2/reference/lexical_analysis.html#string-literal-concatenation), 例如, ``` >>> print("wtf" "python") wtfpython >>> print("wtf" "") # or "wtf""" wtf ``` -+ `'''` and `"""` are also string delimiters in Python which causes a SyntaxError because the Python interpreter was expecting a terminating triple quote as delimiter while scanning the currently encountered triple quoted string literal. ++ `'''` 和 `"""` 在 Python中也是字符串定界符, Python 解释器在先遇到三个引号的的时候会尝试再寻找三个终止引号作为定界符, 如果不存在则会导致 `SyntaxError` 异常. --- From 9753d8609e80111c89f8a18b50d1424beb75cc7e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Fri, 16 Nov 2018 23:46:30 +0800 Subject: [PATCH 16/53] EX.Midnight time doesn't exist --- README.md | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index 7e3a3b2..20cfbe8 100644 --- a/README.md +++ b/README.md @@ -39,7 +39,7 @@ So, here we go... - [> Backslashes at the end of string/字符串末尾的反斜杠](#-backslashes-at-the-end-of-string字符串末尾的反斜杠) - [> not knot!/别纠结!](#-not-knot别纠结) - [> Half triple-quoted strings/三个引号](#-half-triple-quoted-strings三个引号) - - [> Midnight time doesn't exist?](#-midnight-time-doesnt-exist) + - [> Midnight time doesn't exist?/不存在的午夜?](#-midnight-time-doesnt-exist不存在的午夜) - [> What's wrong with booleans?](#-whats-wrong-with-booleans) - [> Class attributes and instance attributes](#-class-attributes-and-instance-attributes) - [> yielding None](#-yielding-none) @@ -728,7 +728,7 @@ wtfpython --- -### > Midnight time doesn't exist? +### > Midnight time doesn't exist?/不存在的午夜? ```py from datetime import datetime @@ -750,11 +750,12 @@ if noon_time: ```sh ('Time at noon is', datetime.time(12, 0)) ``` -The midnight time is not printed. -#### 💡 Explanation: +midnight_time 并没有被输出. + +#### 💡 说明: -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." +在Python 3.5之前, 如果 `datetime.time` 对象存储的UTC的午夜时间(译: 就是 `00:00`), 那么它的布尔值会被认为是 `False`. 当使用 `if obj:` 语句来检查 `obj` 是否为 `null` 或者某些“空”值的时候, 很容易出错. --- From 8b0b4842e6297b52de67c8942ec2437bbf5dcbf4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Sat, 17 Nov 2018 13:08:03 +0800 Subject: [PATCH 17/53] EX.What's wrong with booleans --- README.md | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-) diff --git a/README.md b/README.md index 20cfbe8..b5fd8bc 100644 --- a/README.md +++ b/README.md @@ -40,7 +40,7 @@ So, here we go... - [> not knot!/别纠结!](#-not-knot别纠结) - [> Half triple-quoted strings/三个引号](#-half-triple-quoted-strings三个引号) - [> Midnight time doesn't exist?/不存在的午夜?](#-midnight-time-doesnt-exist不存在的午夜) - - [> What's wrong with booleans?](#-whats-wrong-with-booleans) + - [> What's wrong with booleans?/布尔你咋了?](#-whats-wrong-with-booleans布尔你咋了) - [> Class attributes and instance attributes](#-class-attributes-and-instance-attributes) - [> yielding None](#-yielding-none) - [> Mutating the immutable!](#-mutating-the-immutable) @@ -759,12 +759,11 @@ midnight_time 并没有被输出. --- -### > What's wrong with booleans? +### > What's wrong with booleans?/布尔你咋了? 1\. ```py -# A simple example to count the number of boolean and -# integers in an iterable of mixed data types. +# 一个简单的例子, 统计下面可迭代对象中的布尔型值的个数和整型值的个数 mixed_list = [False, 1.0, "some_string", 3, True, [], False] integers_found_so_far = 0 booleans_found_so_far = 0 @@ -808,9 +807,9 @@ another_dict[1.0] = "Python" '' ``` -#### 💡 Explanation: +#### 💡 说明: -* Booleans are a subclass of `int` +* 布尔值是 `int` 的子类 ```py >>> isinstance(True, int) True @@ -818,13 +817,13 @@ another_dict[1.0] = "Python" True ``` -* The integer value of `True` is `1` and that of `False` is `0`. +* 所以 `True` 的整数值是 `1`, 而 `False` 的整数值是 `0`. ```py >>> True == 1 == 1.0 and False == 0 == 0.0 True ``` -* See this StackOverflow [answer](https://stackoverflow.com/a/8169049/4354153) for the rationale behind it. +* 关于其背后的原理, 请看这个 StackOverflow 的[回答](https://stackoverflow.com/a/8169049/4354153). --- From 36b3c141d3a71ffd2ceec76ec21f71138fc41b5d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Sat, 17 Nov 2018 13:24:50 +0800 Subject: [PATCH 18/53] EX.Class attributes and instance attributes --- README.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index b5fd8bc..654b400 100644 --- a/README.md +++ b/README.md @@ -41,7 +41,7 @@ So, here we go... - [> Half triple-quoted strings/三个引号](#-half-triple-quoted-strings三个引号) - [> Midnight time doesn't exist?/不存在的午夜?](#-midnight-time-doesnt-exist不存在的午夜) - [> What's wrong with booleans?/布尔你咋了?](#-whats-wrong-with-booleans布尔你咋了) - - [> Class attributes and instance attributes](#-class-attributes-and-instance-attributes) + - [> Class attributes and instance attributes/类属性和实例属性](#-class-attributes-and-instance-attributes类属性和实例属性) - [> yielding None](#-yielding-none) - [> Mutating the immutable!](#-mutating-the-immutable) - [> The disappearing variable from outer scope](#-the-disappearing-variable-from-outer-scope) @@ -827,7 +827,7 @@ another_dict[1.0] = "Python" --- -### > Class attributes and instance attributes +### > Class attributes and instance attributes/类属性和实例属性 1\. ```py @@ -890,10 +890,10 @@ True True ``` -#### 💡 Explanation: +#### 💡 说明: -* Class variables and variables in class instances are internally handled as dictionaries of a class object. If a variable name is not found in the dictionary of the current class, the parent classes are searched for it. -* The `+=` operator modifies the mutable object in-place without creating a new object. So changing the attribute of one instance affects the other instances and the class attribute as well. +* 类变量和实例变量在内部是通过类对象的字典来处理(译: 就是 `__dict__` 属性). 如果在当前类的字典中找不到的话就去它的父类中寻找. +* `+=` 运算符会在原地修改可变对象, 而不是创建新对象. 因此, 修改一个实例的属性会影响其他实例和类属性. --- From 196763ed2f9a3d1fd11208d4daf056588e1a3921 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Sat, 17 Nov 2018 17:26:27 +0800 Subject: [PATCH 19/53] EX.yielding None --- README.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index 654b400..7c94e5a 100644 --- a/README.md +++ b/README.md @@ -42,7 +42,7 @@ So, here we go... - [> Midnight time doesn't exist?/不存在的午夜?](#-midnight-time-doesnt-exist不存在的午夜) - [> What's wrong with booleans?/布尔你咋了?](#-whats-wrong-with-booleans布尔你咋了) - [> Class attributes and instance attributes/类属性和实例属性](#-class-attributes-and-instance-attributes类属性和实例属性) - - [> yielding None](#-yielding-none) + - [> yielding None/生成 None](#-yielding-none生成-none) - [> Mutating the immutable!](#-mutating-the-immutable) - [> The disappearing variable from outer scope](#-the-disappearing-variable-from-outer-scope) - [> When True is actually False](#-when-true-is-actually-false) @@ -897,7 +897,7 @@ True --- -### > yielding None +### > yielding None/生成 None ```py some_iterable = ('a', 'b') @@ -920,9 +920,9 @@ def some_func(val): ['a', 'something', 'b', 'something'] ``` -#### 💡 Explanation: -- Source and explanation can be found here: https://stackoverflow.com/questions/32139885/yield-in-list-comprehensions-and-generator-expressions -- Related bug report: http://bugs.python.org/issue10544 +#### 💡 说明: +- 来源和解释可以在这里找到: https://stackoverflow.com/questions/32139885/yield-in-list-comprehensions-and-generator-expressions +- 相关错误报告: http://bugs.python.org/issue10544 --- From 042acb9e96ad098023050f055ffcaab66268fb7d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Sat, 17 Nov 2018 18:16:21 +0800 Subject: [PATCH 20/53] EX.Mutating the immutable --- README.md | 20 +++++++++++--------- 1 file changed, 11 insertions(+), 9 deletions(-) diff --git a/README.md b/README.md index 7c94e5a..e619be6 100644 --- a/README.md +++ b/README.md @@ -43,7 +43,7 @@ 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/生成 None](#-yielding-none生成-none) - - [> Mutating the immutable!](#-mutating-the-immutable) + - [> Mutating the immutable!/强人所难](#-mutating-the-immutable强人所难) - [> The disappearing variable from outer scope](#-the-disappearing-variable-from-outer-scope) - [> When True is actually False](#-when-true-is-actually-false) - [> From filled to None in one instruction...](#-from-filled-to-none-in-one-instruction) @@ -926,7 +926,7 @@ def some_func(val): --- -### > Mutating the immutable! +### > Mutating the immutable!/强人所难 ```py some_tuple = ("A", "tuple", "with", "values") @@ -937,7 +937,7 @@ 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[2].append(1000) # 这里不出现错误 >>> another_tuple ([1, 2], [3, 4], [5, 6, 1000]) >>> another_tuple[2] += [99, 999] @@ -946,16 +946,18 @@ TypeError: 'tuple' object does not support item assignment ([1, 2], [3, 4], [5, 6, 1000, 99, 999]) ``` -But I thought tuples were immutable... +我还以为元组是不可变的呢... -#### 💡 Explanation: +#### 💡 说明: + +* 引用 https://docs.python.org/2/reference/datamodel.html -* Quoting from https://docs.python.org/2/reference/datamodel.html + > 不可变序列 + 不可变序列的对象一旦创建就不能再改变. (如果对象包含对其他对象的引用，则这些其他对象可能是可变的并且可能会被修改; 但是，由不可变对象直接引用的对象集合不能更改.) - > Immutable sequences - An object of an immutable sequence type cannot change once it is created. (If the object contains references to other objects, these other objects may be mutable and may be modified; however, the collection of objects directly referenced by an immutable object cannot change.) +* `+=` 操作符在原地修改了列表. 元素赋值操作并不工作, 但是当异常抛出时, 元素已经在原地被修改了. -* `+=` operator changes the list in-place. The item assignment doesn't work, but when the exception occurs, the item has already been changed in place. +(译: 对于不可变对象, 这里指tuple, `+=` 并不是原子操作, 而是 `extend` 和 `=` 两个动作, 这里 `=` 操作虽然会抛出异常, 但 `extend` 操作已经修改成功了. 详细解释可以看[这里](https://segmentfault.com/a/1190000010767068)) --- From 9a21b266a82e60b9ff768a3fa255c58008b4c23d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Sat, 17 Nov 2018 21:51:51 +0800 Subject: [PATCH 21/53] EX.The disappearing variable from outer scope --- README.md | 22 ++++++++++++---------- 1 file changed, 12 insertions(+), 10 deletions(-) diff --git a/README.md b/README.md index e619be6..2b202e4 100644 --- a/README.md +++ b/README.md @@ -44,7 +44,7 @@ So, here we go... - [> Class attributes and instance attributes/类属性和实例属性](#-class-attributes-and-instance-attributes类属性和实例属性) - [> yielding None/生成 None](#-yielding-none生成-none) - [> Mutating the immutable!/强人所难](#-mutating-the-immutable强人所难) - - [> The disappearing variable from outer scope](#-the-disappearing-variable-from-outer-scope) + - [> The disappearing variable from outer scope/消失的外部变量](#-the-disappearing-variable-from-outer-scope消失的外部变量) - [> When True is actually False](#-when-true-is-actually-false) - [> From filled to None in one instruction...](#-from-filled-to-none-in-one-instruction) - [> Subclass relationships *](#-subclass-relationships-) @@ -961,7 +961,7 @@ TypeError: 'tuple' object does not support item assignment --- -### > The disappearing variable from outer scope +### > The disappearing variable from outer scope/消失的外部变量 ```py e = 7 @@ -983,18 +983,20 @@ except Exception as e: NameError: name 'e' is not defined ``` -#### 💡 Explanation: +#### 💡 说明: + +* 出处: https://docs.python.org/3/reference/compound_stmts.html#except -* Source: https://docs.python.org/3/reference/compound_stmts.html#except + 当使用 `as` 为目标分配异常的时候, 将在except子句的末尾清除该异常. - When an exception has been assigned using `as` target, it is cleared at the end of the except clause. This is as if + 这就好像 ```py except E as N: foo ``` - was translated into + 会被翻译成 ```py except E as N: @@ -1004,9 +1006,9 @@ NameError: name 'e' is not defined del N ``` - This means the exception must be assigned to a different name to be able to refer to it after the except clause. Exceptions are cleared because, with the traceback attached to them, they form a reference cycle with the stack frame, keeping all locals in that frame alive until the next garbage collection occurs. + 这意味着异常必须在被赋值给其他变量才能在 `except` 子句之后引用它. 而异常之所以会被清除, 则是由于上面附加的回溯信息(trackback)会和栈帧(stack frame)形成循环引用, 使得该栈帧中的所有本地变量在下一次垃圾回收发生之前都处于活动状态.(译: 也就是说不会被回收) -* 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 which have their separate inner-scopes. The example below illustrates this: +* 子句在 Python 中并没有独立的作用域. 示例中的所有内容都处于同一作用域内, 所以变量 `e` 会由于执行了 `except` 子句而被删除. 而对于有独立的内部作用域的函数来说情况就不一样了. 下面的例子说明了这一点: ```py def f(x): @@ -1029,14 +1031,14 @@ NameError: name 'e' is not defined [5, 4, 3] ``` -* In Python 2.x the variable name `e` gets assigned to `Exception()` instance, so when you try to print, it prints nothing. +* 在 Python 2.x 中, `Exception()` 实例被赋值给了变量 `e`, 所以当你尝试打印结果的时候, 它的输出为空.（译: 正常的Exception实例打印出来就是空） **Output (Python 2.x):** ```py >>> e Exception() >>> print e - # Nothing is printed! + # 没有打印任何内容! ``` --- From baa1ad6740d4afd407304ad3cb1e93c35fd8f524 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Sun, 18 Nov 2018 19:22:09 +0800 Subject: [PATCH 22/53] EX.When True is actually False --- README.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index 2b202e4..1f0c26d 100644 --- a/README.md +++ b/README.md @@ -45,7 +45,7 @@ So, here we go... - [> yielding None/生成 None](#-yielding-none生成-none) - [> Mutating the immutable!/强人所难](#-mutating-the-immutable强人所难) - [> The disappearing variable from outer scope/消失的外部变量](#-the-disappearing-variable-from-outer-scope消失的外部变量) - - [> When True is actually False](#-when-true-is-actually-false) + - [> When True is actually False/真亦假](#-when-true-is-actually-false真亦假) - [> From filled to None in one instruction...](#-from-filled-to-none-in-one-instruction) - [> Subclass relationships *](#-subclass-relationships-) - [> The mysterious key type conversion *](#-the-mysterious-key-type-conversion-) @@ -1043,7 +1043,7 @@ NameError: name 'e' is not defined --- -### > When True is actually False +### > When True is actually False/真亦假 ```py True = False @@ -1056,10 +1056,10 @@ if True == False: I've lost faith in truth! ``` -#### 💡 Explanation: +#### 💡 说明: -- Initially, Python used to have no `bool` type (people used 0 for false and non-zero value like 1 for true). Then they added `True`, `False`, and a `bool` type, but, for backward compatibility, they couldn't make `True` and `False` constants- they just were built-in variables. -- Python 3 was backward-incompatible, so it was now finally possible to fix that, and so this example won't work with Python 3.x! +- 最初, Python 并没有 `bool` 型 (人们用0表示假值, 用非零值比如1作为真值). 后来他们添加了 `True`, `False`, 和 `bool` 型, 但是, 为了向后兼容, 他们没法把 `True` 和 `False` 设置为常量, 只是设置成了内置变量. +- Python 3 由于不再需要向后兼容, 终于可以修复这个问题了, 所以这个例子无法在 Python 3.x 中执行! --- From eaad9fbf90618c6d929cf48488f79f0d59eec52a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Sun, 18 Nov 2018 19:58:45 +0800 Subject: [PATCH 23/53] EX.From filled to None in one instruction --- README.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 1f0c26d..5dfa147 100644 --- a/README.md +++ b/README.md @@ -46,7 +46,7 @@ So, here we go... - [> Mutating the immutable!/强人所难](#-mutating-the-immutable强人所难) - [> The disappearing variable from outer scope/消失的外部变量](#-the-disappearing-variable-from-outer-scope消失的外部变量) - [> When True is actually False/真亦假](#-when-true-is-actually-false真亦假) - - [> From filled to None in one instruction...](#-from-filled-to-none-in-one-instruction) + - [> From filled to None in one instruction.../从有到无...](#-from-filled-to-none-in-one-instruction从有到无) - [> Subclass relationships *](#-subclass-relationships-) - [> The mysterious key type conversion *](#-the-mysterious-key-type-conversion-) - [> Let's see if you can guess this?](#-lets-see-if-you-can-guess-this) @@ -1063,7 +1063,7 @@ I've lost faith in truth! --- -### > From filled to None in one instruction... +### > From filled to None in one instruction.../从有到无... ```py some_list = [1, 2, 3] @@ -1085,9 +1085,9 @@ None None ``` -#### 💡 Explanation +#### 💡 说明: -Most methods that modify the items of sequence/mapping objects like `list.append`, `dict.update`, `list.sort`, etc. modify the objects in-place and return `None`. The rationale behind this is to improve performance by avoiding making a copy of the object if the operation can be done in-place (Referred from [here](http://docs.python.org/2/faq/design.html#why-doesn-t-list-sort-return-the-sorted-list)) +大多数修改序列/映射对象的方法, 比如 `list.append`, `dict.update`, `list.sort` 等等. 都是原地修改对象并返回 `None`. 这样做的理由是, 如果操作可以原地完成, 就可以避免创建对象的副本来提高性能. (参考[这里](http://docs.python.org/2/faq/design.html#why-doesn-t-list-sort-return-the-sorted-list)) --- From fe29b8aa38ec6865fb95eb73f47e20becfb14546 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Sun, 18 Nov 2018 20:33:16 +0800 Subject: [PATCH 24/53] EX.Subclass relationships --- README.md | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/README.md b/README.md index 5dfa147..e8574a6 100644 --- a/README.md +++ b/README.md @@ -47,7 +47,7 @@ So, here we go... - [> The disappearing variable from outer scope/消失的外部变量](#-the-disappearing-variable-from-outer-scope消失的外部变量) - [> When True is actually False/真亦假](#-when-true-is-actually-false真亦假) - [> From filled to None in one instruction.../从有到无...](#-from-filled-to-none-in-one-instruction从有到无) - - [> Subclass relationships *](#-subclass-relationships-) + - [> Subclass relationships/子类关系 *](#-subclass-relationships子类关系-) - [> The mysterious key type conversion *](#-the-mysterious-key-type-conversion-) - [> Let's see if you can guess this?](#-lets-see-if-you-can-guess-this) - [Section: Appearances are deceptive!](#section-appearances-are-deceptive) @@ -1091,7 +1091,7 @@ None --- -### > Subclass relationships * +### > Subclass relationships/子类关系 * **Output:** ```py @@ -1104,14 +1104,14 @@ True False ``` -The Subclass relationships were expected to be transitive, right? (i.e., if `A` is a subclass of `B`, and `B` is a subclass of `C`, the `A` _should_ a subclass of `C`) +子类关系应该是可传递的, 对吧? (即, 如果 `A` 是 `B` 的子类, `B` 是 `C` 的子类, 那么 `A` _应该_ 是 `C` 的子类.) -#### 💡 Explanation: +#### 💡 说明: -* Subclass relationships are not necessarily transitive in Python. Anyone is allowed to define their own, arbitrary `__subclasscheck__` in a metaclass. -* When `issubclass(cls, Hashable)` is called, it simply looks for non-Falsey "`__hash__`" method in `cls` or anything it inherits from. -* Since `object` is hashable, but `list` is non-hashable, it breaks the transitivity relation. -* More detailed explanation can be found [here](https://www.naftaliharris.com/blog/python-subclass-intransitivity/). +* Python 中的子类关系并不必须是传递的. 任何人都可以在元类中随意定义 `__subclasscheck__`. +* 当 `issubclass(cls, Hashable)` 被调用时, 它只是在 `cls` 中寻找 "`__hash__`" 方法或继承自"`__hash__`"的方法. +* 由于 `object` is 可散列的(hashable), 但是 `list` 是不可散列的, 所以它打破了这种传递关系. +* 在[这里](https://www.naftaliharris.com/blog/python-subclass-intransitivity/)可以找到更详细的解释. --- From 7728d335da9f2b79e796e9c6f791108e8d6442dd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Sun, 18 Nov 2018 23:32:30 +0800 Subject: [PATCH 25/53] EX.The mysterious key type conversion --- README.md | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/README.md b/README.md index e8574a6..895a491 100644 --- a/README.md +++ b/README.md @@ -48,7 +48,7 @@ So, here we go... - [> When True is actually False/真亦假](#-when-true-is-actually-false真亦假) - [> From filled to None in one instruction.../从有到无...](#-from-filled-to-none-in-one-instruction从有到无) - [> Subclass relationships/子类关系 *](#-subclass-relationships子类关系-) - - [> The mysterious key type conversion *](#-the-mysterious-key-type-conversion-) + - [> The mysterious key type conversion/神秘的键型转换 *](#-the-mysterious-key-type-conversion神秘的键型转换-) - [> Let's see if you can guess this?](#-lets-see-if-you-can-guess-this) - [Section: Appearances are deceptive!](#section-appearances-are-deceptive) - [> Skipping lines?](#-skipping-lines) @@ -1115,7 +1115,7 @@ False --- -### > The mysterious key type conversion * +### > The mysterious key type conversion/神秘的键型转换 * ```py class SomeClass(str): @@ -1130,18 +1130,18 @@ some_dict = {'s':42} str >>> s = SomeClass('s') >>> some_dict[s] = 40 ->>> some_dict # expected: Two different keys-value pairs +>>> some_dict # 预期: 两个不同的键值对 {'s': 40} >>> type(list(some_dict.keys())[0]) str ``` -#### 💡 Explanation: +#### 💡 说明: -* Both the object `s` and the string `"s"` hash to the same value because `SomeClass` inherits the `__hash__` method of `str` class. -* `SomeClass("s") == "s"` evaluates to `True` because `SomeClass` also inherits `__eq__` method from `str` class. -* Since both the objects hash to the same value and are equal, they are represented by the same key in the dictionary. -* For the desired behavior, we can redefine the `__eq__` method in `SomeClass` +* 由于 `SomeClass` 会从 `str` 自动继承 `__hash__` 方法, 所以 `s` 对象和 `"s"` 字符串的哈希值是相同的. +* 而 `SomeClass("s") == "s"` 为 `True` 是因为 `SomeClass` 也继承了 `str` 类 `__eq__` 方法. +* 由于两者的哈希值相同且相等, 所以它们在字典中表示相同的键. +* 如果想要实现期望的功能, 我们可以重定义 `SomeClass` 的 `__eq__` 方法. ```py class SomeClass(str): def __eq__(self, other): @@ -1151,8 +1151,8 @@ str and super().__eq__(other) ) - # When we define a custom __eq__, Python stops automatically inheriting the - # __hash__ method, so we need to define it as well + # 当我们自定义 __eq__ 方法时, Python 不会再自动继承 __hash__ 方法 + # 所以我们也需要定义它 __hash__ = str.__hash__ some_dict = {'s':42} From 138bb5edca5a8d486b3cb2725212e7cfe0842a85 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Mon, 19 Nov 2018 00:22:16 +0800 Subject: [PATCH 26/53] EX.Let's see if you can guess this --- README.md | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/README.md b/README.md index 895a491..e07dce7 100644 --- a/README.md +++ b/README.md @@ -49,7 +49,7 @@ So, here we go... - [> From filled to None in one instruction.../从有到无...](#-from-filled-to-none-in-one-instruction从有到无) - [> Subclass relationships/子类关系 *](#-subclass-relationships子类关系-) - [> The mysterious key type conversion/神秘的键型转换 *](#-the-mysterious-key-type-conversion神秘的键型转换-) - - [> Let's see if you can guess this?](#-lets-see-if-you-can-guess-this) + - [> Let's see if you can guess this?/看看你能否猜到这一点?](#-lets-see-if-you-can-guess-this看看你能否猜到这一点) - [Section: Appearances are deceptive!](#section-appearances-are-deceptive) - [> Skipping lines?](#-skipping-lines) - [> Teleportation *](#-teleportation-) @@ -1171,7 +1171,7 @@ str --- -### > Let's see if you can guess this? +### > Let's see if you can guess this?/看看你能否猜到这一点? ```py a, b = a[b] = {}, 5 @@ -1183,24 +1183,24 @@ a, b = a[b] = {}, 5 {5: ({...}, 5)} ``` -#### 💡 Explanation: +#### 💡 说明: -* According to [Python language reference](https://docs.python.org/2/reference/simple_stmts.html#assignment-statements), assignment statements have the form +* 根据 [Python 语言参考](https://docs.python.org/2/reference/simple_stmts.html#assignment-statements), 赋值语句的形式如下 ``` (target_list "=")+ (expression_list | yield_expression) ``` - and - > An assignment statement evaluates the expression list (remember that this can be a single expression or a comma-separated list, the latter yielding a tuple) and assigns the single resulting object to each of the target lists, from left to right. -* 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`). + > 赋值语句计算表达式列表(expression list)(牢记 这可以是单个表达式或以逗号分隔的列表, 后者返回元组)并将单个结果对象从左到右分配给目标列表中的每一项. + +* `(target_list "=")+` 中的 `+` 意味着可以有**一个或多个**目标列表. 在这个例子中, 目标列表是 `a, b` 和 `a[b]` (注意表达式列表只能有一个, 在我们的例子中是 `{}, 5`). -* After the expression list is evaluated, it's value is unpacked to the target lists from **left to right**. So, in our case, first the `{}, 5` tuple is unpacked to `a, b` and we now have `a = {}` and `b = 5`. +* 表达式列表计算结束后, 将其值自动解包后**从左到右**分配给目标列表(target list). 因此, 在我们的例子中, 首先将 `{}, 5` 元祖并赋值给 `a, b`, 然后我们就可以得到 `a = {}` 且 `b = 5`. -* `a` is now assigned to `{}` which is a mutable object. +* `a` 被赋值的 `{}` 是可变对象. -* The second target list is `a[b]` (you may expect this to throw an error because both `a` and `b` have not been defined in the statements before. But remember, we just assigned `a` to `{}` and `b` to `5`). +* 第二个目标列表是 `a[b]` (你可能觉得这里会报错, 因为在之前的语句中 `a` 和 `b` 都还没有被定义. 但是别忘了, 我们刚刚将 `a` 赋值 `{}` 且将 `b` 赋值为 `5`). -* Now, we are setting the key `5` in the dictionary to the tuple `({}, 5)` creating a circular reference (the `{...}` in the output refers to the same object that `a` is already referencing). Another simpler example of circular reference could be +* 现在, 我们将通过将字典中键 `5` 的值设置为元祖 `({}, 5)` 来创建循环引用 (输出中的 `{...}` 指与 `a` 引用了相同的对象). 下面是一个更简单的循环引用的例子 ```py >>> some_list = some_list[0] = [0] >>> some_list @@ -1212,14 +1212,14 @@ a, b = a[b] = {}, 5 >>> some_list[0][0][0][0][0][0] == some_list True ``` - Similar is the case in our example (`a[b][0]` is the same object as `a`) + 我们的例子就是这种情况 (`a[b][0]` 与 `a` 是相同的对象) -* So to sum it up, you can break the example down to +* 总结一下, 你也可以把例子拆成 ```py a, b = {}, 5 a[b] = a, b ``` - And the circular reference can be justified by the fact that `a[b][0]` is the same object as `a` + 并且可以通过 `a[b][0]` 与 `a` 是相同的对象来证明是循环引用 ```py >>> a[b][0] is a True From 6e301b349456b7e970b5b0f65d810fde40af469d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Mon, 19 Nov 2018 23:27:53 +0800 Subject: [PATCH 27/53] EX.Skipping lines --- README.md | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/README.md b/README.md index e07dce7..885ae81 100644 --- a/README.md +++ b/README.md @@ -51,7 +51,7 @@ So, here we go... - [> The mysterious key type conversion/神秘的键型转换 *](#-the-mysterious-key-type-conversion神秘的键型转换-) - [> Let's see if you can guess this?/看看你能否猜到这一点?](#-lets-see-if-you-can-guess-this看看你能否猜到这一点) - [Section: Appearances are deceptive!](#section-appearances-are-deceptive) - - [> Skipping lines?](#-skipping-lines) + - [> Skipping lines?/跳过一行?](#-skipping-lines跳过一行) - [> Teleportation *](#-teleportation-) - [> Well, something is fishy...](#-well-something-is-fishy) - [Section: Watch out for the landmines!](#section-watch-out-for-the-landmines) @@ -1231,7 +1231,7 @@ a, b = a[b] = {}, 5 ## Section: Appearances are deceptive! -### > Skipping lines? +### > Skipping lines?/跳过一行? **Output:** ```py @@ -1241,29 +1241,29 @@ a, b = a[b] = {}, 5 11 ``` -Wut? +什么鬼? -**Note:** The easiest way to reproduce this is to simply copy the statements from the above snippet and paste them into your file/shell. +**注意:** 如果你想要重现的话最简单的方法是直接复制上面的代码片段到你的文件或命令行里. -#### 💡 Explanation +#### 💡 说明: -Some non-Western characters look identical to letters in the English alphabet but are considered distinct by the interpreter. +一些非西方字符虽然看起来和英语字母相同, 但会被解释器识别为不同的字母. ```py ->>> ord('е') # cyrillic 'e' (Ye) +>>> ord('е') # 西里尔语的 'e' (Ye) 1077 ->>> ord('e') # latin 'e', as used in English and typed using standard keyboard +>>> ord('e') # 拉丁语的 'e', 用于英文并使用标准键盘输入 101 >>> 'е' == 'e' False ->>> value = 42 # latin e ->>> valuе = 23 # cyrillic 'e', Python 2.x interpreter would raise a `SyntaxError` here +>>> value = 42 # 拉丁语 e +>>> valuе = 23 # 西里尔语 'e', Python 2.x 的解释器在这会抛出 `SyntaxError` 异常 >>> value 42 ``` -The built-in `ord()` function returns a character's Unicode [code point](https://en.wikipedia.org/wiki/Code_point), and different code positions of Cyrillic 'e' and Latin 'e' justify the behavior of the above example. +内置的 `ord()` 函数可以返回一个字符的 Unicode [代码点](https://en.wikipedia.org/wiki/Code_point), 这里西里尔语 'e' 和拉丁语 'e' 的代码点不同证实了上述例子. --- From 91b83671c357ad269ec70d08d6ec4184789160ca Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Tue, 20 Nov 2018 23:30:43 +0800 Subject: [PATCH 28/53] EX.Teleportation --- README.md | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/README.md b/README.md index 885ae81..0ed2631 100644 --- a/README.md +++ b/README.md @@ -52,7 +52,7 @@ So, here we go... - [> Let's see if you can guess this?/看看你能否猜到这一点?](#-lets-see-if-you-can-guess-this看看你能否猜到这一点) - [Section: Appearances are deceptive!](#section-appearances-are-deceptive) - [> Skipping lines?/跳过一行?](#-skipping-lines跳过一行) - - [> Teleportation *](#-teleportation-) + - [> Teleportation/空间移动 *](#-teleportation空间移动-) - [> Well, something is fishy...](#-well-something-is-fishy) - [Section: Watch out for the landmines!](#section-watch-out-for-the-landmines) - [> Modifying a dictionary while iterating over it](#-modifying-a-dictionary-while-iterating-over-it) @@ -1267,17 +1267,17 @@ False --- -### > Teleportation * +### > Teleportation/空间移动 * ```py import numpy as np def energy_send(x): - # Initializing a numpy array + # 初始化一个 numpy 数组 np.array([float(x)]) def energy_receive(): - # Return an empty numpy array + # 返回一个空的 numpy 数组 return np.empty((), dtype=np.float).tolist() ``` @@ -1288,12 +1288,12 @@ def energy_receive(): 123.456 ``` -Where's the Nobel Prize? +谁来给我发个诺贝尔奖? -#### 💡 Explanation: +#### 💡 说明: -* Notice that the numpy array created in the `energy_send` function is not returned, so that memory space is free to reallocate. -* `numpy.empty()` returns the next free memory slot without reinitializing it. This memory spot just happens to be the same one that was just freed (usually, but not always). +* 注意在 `energy_send` 函数中创建的 numpy 数组并没有返回, 因此内存空间被释放并可以被重新分配. +* `numpy.empty()` 直接返回下一段空闲内存，而不重新初始化. 而这个内存点恰好就是刚刚释放的那个(通常情况下, 并不绝对). --- From 9efc3b736ffb4b877dbc30a81a7e832b8f417678 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Wed, 21 Nov 2018 22:38:12 +0800 Subject: [PATCH 29/53] EX.Well, something is fishy --- README.md | 22 +++++++++++----------- mixed_tabs_and_spaces.py | 7 +++++++ 2 files changed, 18 insertions(+), 11 deletions(-) create mode 100644 mixed_tabs_and_spaces.py diff --git a/README.md b/README.md index 0ed2631..feffcc2 100644 --- a/README.md +++ b/README.md @@ -53,7 +53,7 @@ So, here we go... - [Section: Appearances are deceptive!](#section-appearances-are-deceptive) - [> Skipping lines?/跳过一行?](#-skipping-lines跳过一行) - [> Teleportation/空间移动 *](#-teleportation空间移动-) - - [> Well, something is fishy...](#-well-something-is-fishy) + - [> Well, something is fishy.../嗯, 有些可疑...](#-well-something-is-fishy嗯有些可疑) - [Section: Watch out for the landmines!](#section-watch-out-for-the-landmines) - [> Modifying a dictionary while iterating over it](#-modifying-a-dictionary-while-iterating-over-it) - [> Stubborn `del` operator *](#-stubborn-del-operator-) @@ -1297,12 +1297,12 @@ def energy_receive(): --- -### > Well, something is fishy... +### > Well, something is fishy.../嗯，有些可疑... ```py def square(x): """ - A simple function to calculate the square of a number by addition. + 一个通过加法计算平方的简单函数. """ sum_so_far = 0 for counter in range(x): @@ -1317,17 +1317,17 @@ def square(x): 10 ``` -Shouldn't that be 100? +难道不应该是100吗? -**Note:** If you're not able to reproduce this, try running the file [mixed_tabs_and_spaces.py](/mixed_tabs_and_spaces.py) via the shell. +**注意:** 如果你无法重现, 可以尝试运行这个文件[mixed_tabs_and_spaces.py](/mixed_tabs_and_spaces.py). -#### 💡 Explanation +#### 💡 说明: -* **Don't mix tabs and spaces!** The character just preceding return is a "tab", and the code is indented by multiple of "4 spaces" elsewhere in the example. -* This is how Python handles tabs: - > First, tabs are replaced (from left to right) by one to eight spaces such that the total number of characters up to and including the replacement is a multiple of eight <...> -* So the "tab" at the last line of `square` function is replaced with eight spaces, and it gets into the loop. -* Python 3 is kind enough to throw an error for such cases automatically. +* **不要混用制表符(tab)和空格(space)!** 在上面的例子中, return 的前面是"1个制表符", 而其他部分的代码前面是 "4个空格". +* Python是这么处理制表符的: + > 首先, 制表符会从左到右依次被替换成8个空格, 直到被替换后的字符总数是八的倍数 <...> +* 因此, `square` 函数最后一行的制表符会被替换成8个空格, 导致return语句进入循环语句里面. +* Python 3 很友好, 在这种情况下会自动抛出错误. **Output (Python 3.x):** ```py diff --git a/mixed_tabs_and_spaces.py b/mixed_tabs_and_spaces.py new file mode 100644 index 0000000..ec6cf40 --- /dev/null +++ b/mixed_tabs_and_spaces.py @@ -0,0 +1,7 @@ +def square(x): + sum_so_far = 0 + for _ in range(x): + sum_so_far += x + return sum_so_far # noqa: E999 # pylint: disable=mixed-indentation Python 3 will raise a TabError here + +print(square(10)) From c701ffc4d363b9a48119b1574cc48026acbcdb0c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Wed, 21 Nov 2018 23:37:51 +0800 Subject: [PATCH 30/53] EX.Modifying a dictionary while iterating over it --- README.md | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/README.md b/README.md index feffcc2..18cc5b1 100644 --- a/README.md +++ b/README.md @@ -55,7 +55,7 @@ So, here we go... - [> Teleportation/空间移动 *](#-teleportation空间移动-) - [> Well, something is fishy.../嗯, 有些可疑...](#-well-something-is-fishy嗯有些可疑) - [Section: Watch out for the landmines!](#section-watch-out-for-the-landmines) - - [> Modifying a dictionary while iterating over it](#-modifying-a-dictionary-while-iterating-over-it) + - [> Modifying a dictionary while iterating over it/迭代字典时的修改](#-modifying-a-dictionary-while-iterating-over-it迭代字典时的修改) - [> Stubborn `del` operator *](#-stubborn-del-operator-) - [> Deleting a list item while iterating](#-deleting-a-list-item-while-iterating) - [> Loop variables leaking out!](#-loop-variables-leaking-out) @@ -1341,7 +1341,7 @@ def square(x): ## Section: Watch out for the landmines! -### > Modifying a dictionary while iterating over it +### > Modifying a dictionary while iterating over it/迭代字典时的修改 ```py x = {0: None} @@ -1365,14 +1365,14 @@ for i in x: 7 ``` -Yes, it runs for exactly **eight** times and stops. +是的, 它运行了**八次**然后才停下来. -#### 💡 Explanation: +#### 💡 说明: -* Iteration over a dictionary that you edit at the same time is not supported. -* It runs eight times because that's the point at which the dictionary resizes to hold more keys (we have eight deletion entries, so a resize is needed). This is actually an implementation detail. -* How deleted keys are handled and when the resize occurs might be different for different Python implementations. -* For more information, you may refer to this StackOverflow [thread](https://stackoverflow.com/questions/44763802/bug-in-python-dict) explaining a similar example in detail. +* Python不支持对字典进行迭代的同时修改它. +* 它之所以运行8次, 是因为字典会自动扩容以容纳更多键值(我们有8次删除记录, 因此需要扩容). 这实际上是一个实现细节. (译: 应该是因为字典的初始最小值是8, 扩容会导致散列表地址发生变化而中断循环.) +* 在不同的Python实现中删除键的处理方式以及调整大小的时间可能会有所不同.(译: 就是说什么时候扩容在不同版本中可能是不同的, 在3.6及3.7的版本中到[5](https://github.com/python/cpython/blob/v3.6.1/Objects/dictobject.c#L103-L110)就会自动扩容了. 以后也有可能再次发生变化. 顺带一提,后面两次扩容会扩展为32和256. 8->32->256) +* 更多的信息, 你可以参考这个StackOverflow的[回答](https://stackoverflow.com/questions/44763802/bug-in-python-dict), 它详细的解释一个类似的例子. --- From d1d9928e47225c927a498ff543dccac006e24b30 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Thu, 22 Nov 2018 23:42:07 +0800 Subject: [PATCH 31/53] EX.Stubborn del operator --- README.md | 27 ++++++++++++++------------- 1 file changed, 14 insertions(+), 13 deletions(-) diff --git a/README.md b/README.md index 18cc5b1..10da6ca 100644 --- a/README.md +++ b/README.md @@ -56,7 +56,7 @@ So, here we go... - [> Well, something is fishy.../嗯, 有些可疑...](#-well-something-is-fishy嗯有些可疑) - [Section: Watch out for the landmines!](#section-watch-out-for-the-landmines) - [> Modifying a dictionary while iterating over it/迭代字典时的修改](#-modifying-a-dictionary-while-iterating-over-it迭代字典时的修改) - - [> Stubborn `del` operator *](#-stubborn-del-operator-) + - [> Stubborn `del` operator/坚强的 `del` *](#-stubborn-del-operator坚强的-del-) - [> Deleting a list item while iterating](#-deleting-a-list-item-while-iterating) - [> Loop variables leaking out!](#-loop-variables-leaking-out) - [> Beware of default mutable arguments!](#-beware-of-default-mutable-arguments) @@ -1376,7 +1376,7 @@ for i in x: --- -### > Stubborn `del` operator * +### > Stubborn `del` operator/坚强的 `del` * ```py class SomeClass: @@ -1389,33 +1389,34 @@ class SomeClass: ```py >>> x = SomeClass() >>> y = x ->>> del x # this should print "Deleted!" +>>> del x # 这里应该会输出 "Deleted!" >>> del y Deleted! ``` -Phew, deleted at last. You might have guessed what saved from `__del__` being called in our first attempt to delete `x`. Let's add more twist to the example. +唷, 终于删除了. 你可能已经猜到了在我们第一次尝试删除 `x` 时是什么让 `__del__` 免于被调用的. 那让我们给这个例子增加点难度. 2\. ```py >>> x = SomeClass() >>> y = x >>> del x ->>> y # check if y exists +>>> y # 检查一下y是否存在 <__main__.SomeClass instance at 0x7f98a1a67fc8> ->>> del y # Like previously, this should print "Deleted!" ->>> globals() # oh, it didn't. Let's check all our global variables and confirm +>>> del y # 像之前一样, 这里应该会输出 "Deleted!" +>>> globals() # 好吧, 并没有. 让我们看一下所有的全局变量 Deleted! {'__builtins__': , 'SomeClass': , '__package__': None, '__name__': '__main__', '__doc__': None} ``` -Okay, now it's deleted :confused: +好了，现在它被删除了 :confused: -#### 💡 Explanation: -+ `del x` doesn’t directly call `x.__del__()`. -+ Whenever `del x` is encountered, Python decrements the reference count for `x` by one, and `x.__del__()` when x’s reference count reaches zero. -+ In the second output snippet, `y.__del__()` was not called because the previous statement (`>>> y`) in the interactive interpreter created another reference to the same object, thus preventing the reference count to reach zero when `del y` was encountered. -+ Calling `globals` caused the existing reference to be destroyed and hence we can see "Deleted!" being printed (finally!). +#### 💡 说明: ++ `del x` 并不会立刻调用 `x.__del__()`. ++ 每当遇到 `del x`, Python 会将 `x` 的引用数减1, 当 `x` 的引用数减到0时就会调用 `x.__del__()`. ++ 在第二个例子中, `y.__del__()` 之所以未被调用, 是因为前一条语句 (`>>> y`) 对同一对象创建了另一个引用, 从而防止在执行 `del y` 后对象的引用数变为0. ++ 调用 `globals` 导致引用被销毁, 因此我们可以看到 "Deleted!" 终于被输出了. ++ (译: 这其实是 Python 交互解释器的特性, 它会自动让 `_` 保存上一个表达式输出的值, 详细可以看[这里](https://www.cnblogs.com/leisurelylicht/p/diao-pi-de-kong-zhi-tai.html).) --- From a889b1b3d58cd907dc1cadf850b5438ea531bc84 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Sat, 24 Nov 2018 23:27:32 +0800 Subject: [PATCH 32/53] EX.Deleting a list item while iterating --- README.md | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/README.md b/README.md index 10da6ca..5571437 100644 --- a/README.md +++ b/README.md @@ -57,7 +57,7 @@ So, here we go... - [Section: Watch out for the landmines!](#section-watch-out-for-the-landmines) - [> Modifying a dictionary while iterating over it/迭代字典时的修改](#-modifying-a-dictionary-while-iterating-over-it迭代字典时的修改) - [> Stubborn `del` operator/坚强的 `del` *](#-stubborn-del-operator坚强的-del-) - - [> Deleting a list item while iterating](#-deleting-a-list-item-while-iterating) + - [> Deleting a list item while iterating/迭代列表时删除元素](#-deleting-a-list-item-while-iterating迭代列表时删除元素) - [> Loop variables leaking out!](#-loop-variables-leaking-out) - [> Beware of default mutable arguments!](#-beware-of-default-mutable-arguments) - [> Catching the Exceptions](#-catching-the-exceptions) @@ -1420,7 +1420,7 @@ Deleted! --- -### > Deleting a list item while iterating +### > Deleting a list item while iterating/迭代列表时删除元素 ```py list_1 = [1, 2, 3, 4] @@ -1453,30 +1453,30 @@ for idx, item in enumerate(list_4): [2, 4] ``` -Can you guess why the output is `[2, 4]`? +你能猜到为什么输出是 `[2, 4]` 吗? -#### 💡 Explanation: +#### 💡 说明: -* It's never a good idea to change the object you're iterating over. The correct way to do so is to iterate over a copy of the object instead, and `list_3[:]` does just that. +* 在迭代时修改对象是一个很愚蠢的主意. 正确的做法是迭代对象的副本, `list_3[:]` 就是这么做的. ```py >>> some_list = [1, 2, 3, 4] >>> id(some_list) 139798789457608 - >>> id(some_list[:]) # Notice that python creates new object for sliced list. + >>> id(some_list[:]) # 注意python为切片列表创建了新对象. 139798779601192 ``` -**Difference between `del`, `remove`, and `pop`:** -* `del var_name` just removes the binding of the `var_name` from the local or global namespace (That's why the `list_1` is unaffected). -* `remove` removes the first matching value, not a specific index, raises `ValueError` if the value is not found. -* `pop` removes the element at a specific index and returns it, raises `IndexError` if an invalid index is specified. +**`del`, `remove` 和 `pop` 的不同:** +* `del var_name` 只是从本地或全局命名空间中删除了 `var_name` (这就是为什么 `list_1` 没有受到影响). +* `remove` 会删除第一个匹配到的指定值, 而不是特定的索引, 如果找不到值则抛出 `ValueError` 异常. +* `pop` 则会删除指定索引处的元素并返回它, 如果指定了无效的索引则抛出 `IndexError` 异常. -**Why the output is `[2, 4]`?** -- The list iteration is done index by index, and when we remove `1` from `list_2` or `list_4`, the contents of the lists are now `[2, 3, 4]`. The remaining elements are shifted down, i.e., `2` is at index 0, and `3` is at index 1. Since the next iteration is going to look at index 1 (which is the `3`), the `2` gets skipped entirely. A similar thing will happen with every alternate element in the list sequence. +**为什么输出是 `[2, 4]`?** +- 列表迭代是按索引进行的, 所以当我们从 `list_2` 或 `list_4` 中删除 `1` 时, 列表的内容就变成了 `[2, 3, 4]`. 剩余元素会依次位移, 也就是说, `2` 的索引会变为 0, `3` 会变为 1. 由于下一次迭代将获取索引为 1 的元素 (即 `3`), 因此 `2` 将被彻底的跳过. 类似的情况会交替发生在列表中的每个元素上. -* Refer to this StackOverflow [thread](https://stackoverflow.com/questions/45946228/what-happens-when-you-try-to-delete-a-list-element-while-iterating-over-it) explaining the example -* See also this nice StackOverflow [thread](https://stackoverflow.com/questions/45877614/how-to-change-all-the-dictionary-keys-in-a-for-loop-with-d-items) for a similar example related to dictionaries in Python. +* 参考这个StackOverflow的[回答](https://stackoverflow.com/questions/45946228/what-happens-when-you-try-to-delete-a-list-element-while-iterating-over-it)来解释这个例子 +* 关于Python中字典的类似例子, 可以参考这个Stackoverflow的[回答](https://stackoverflow.com/questions/45877614/how-to-change-all-the-dictionary-keys-in-a-for-loop-with-d-items). --- From 5d997d23a0712bf899bd3a42bae1aa43806ee658 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Sun, 25 Nov 2018 16:26:27 +0800 Subject: [PATCH 33/53] EX.Loop variables leaking out --- README.md | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/README.md b/README.md index 5571437..f776030 100644 --- a/README.md +++ b/README.md @@ -58,7 +58,7 @@ So, here we go... - [> Modifying a dictionary while iterating over it/迭代字典时的修改](#-modifying-a-dictionary-while-iterating-over-it迭代字典时的修改) - [> Stubborn `del` operator/坚强的 `del` *](#-stubborn-del-operator坚强的-del-) - [> Deleting a list item while iterating/迭代列表时删除元素](#-deleting-a-list-item-while-iterating迭代列表时删除元素) - - [> Loop variables leaking out!](#-loop-variables-leaking-out) + - [> 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) @@ -1480,7 +1480,7 @@ for idx, item in enumerate(list_4): --- -### > Loop variables leaking out! +### > Loop variables leaking out!/循环变量泄漏! 1\. ```py @@ -1496,11 +1496,11 @@ print(x, ': x in global') 6 : x in global ``` -But `x` was never defined outside the scope of for loop... +但是 `x` 从未在循环外被定义... 2\. ```py -# This time let's initialize x first +# 这次我们先初始化x x = -1 for x in range(7): if x == 6: @@ -1533,13 +1533,13 @@ print(x, ': x in global') 1 : x in global ``` -#### 💡 Explanation: +#### 💡 说明: -- In Python, for-loops use the scope they exist in and leave their defined loop-variable behind. This also applies if we explicitly defined the for-loop variable in the global namespace before. In this case, it will rebind the existing variable. +- 在 Python 中, for 循环使用所在作用域并在结束后保留定义的循环变量. 如果我们曾在全局命名空间中定义过循环变量. 在这种情况下, 它会重新绑定现有变量. -- 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) documentation: +- Python 2.x 和 Python 3.x 解释器在列表推导式示例中的输出差异, 在文档 [What’s New In Python 3.0](https://docs.python.org/3/whatsnew/3.0.html) 中可以找到相关的解释: - > "List comprehensions no longer support the syntactic form `[... for var in item1, item2, ...]`. Use `[... for var in (item1, item2, ...)]` instead. Also, note that list comprehensions have different semantics: they are closer to syntactic sugar for a generator expression inside a `list()` constructor, and in particular the loop control variables are no longer leaked into the surrounding scope." + > "列表推导不再支持句法形式 `[... for var in item1, item2, ...]`. 取而代之的是 `[... for var in (item1, item2, ...)]`. 另外, 注意列表推导具有不同的语义: 它们更接近于 `list()` 构造函数中生成器表达式的语法糖(译: 这一句我也不是很明白), 特别是循环控制变量不再泄漏到周围的作用域中." --- From 63bc525b634e00216284b0e85e9045f066ea7388 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Sun, 25 Nov 2018 17:14:25 +0800 Subject: [PATCH 34/53] EX.Beware of default mutable arguments --- README.md | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index f776030..8b340f5 100644 --- a/README.md +++ b/README.md @@ -59,7 +59,7 @@ So, here we go... - [> Stubborn `del` operator/坚强的 `del` *](#-stubborn-del-operator坚强的-del-) - [> Deleting a list item while iterating/迭代列表时删除元素](#-deleting-a-list-item-while-iterating迭代列表时删除元素) - [> Loop variables leaking out!/循环变量泄漏!](#-loop-variables-leaking-out循环变量泄漏) - - [> Beware of default mutable arguments!](#-beware-of-default-mutable-arguments) + - [> Beware of default mutable arguments!/当心默认的可变参数!](#-beware-of-default-mutable-arguments当心默认的可变参数) - [> Catching the Exceptions](#-catching-the-exceptions) - [> Same operands, different story!](#-same-operands-different-story) - [> The out of scope variable](#-the-out-of-scope-variable) @@ -1543,7 +1543,7 @@ print(x, ': x in global') --- -### > Beware of default mutable arguments! +### > Beware of default mutable arguments!/当心默认的可变参数! ```py def some_func(default_arg=[]): @@ -1563,9 +1563,9 @@ def some_func(default_arg=[]): ['some_string', 'some_string', 'some_string'] ``` -#### 💡 Explanation: +#### 💡 说明: -- The default mutable arguments of functions in Python aren't really initialized every time you call the function. Instead, the recently assigned value to them is used as the default value. When we explicitly passed `[]` to `some_func` as the argument, the default value of the `default_arg` variable was not used, so the function returned as expected. +- Python中函数的默认可变参数并不是每次调用该函数时都会被初始化. 相反, 它们会使用最近分配的值作为默认值. 当我们明确的将 `[]` 作为参数传递给 `some_func` 的时候, 就不会使用 `default_arg` 的默认值, 所以函数会返回我们所期望的结果. ```py def some_func(default_arg=[]): @@ -1575,7 +1575,7 @@ def some_func(default_arg=[]): **Output:** ```py - >>> some_func.__defaults__ #This will show the default argument values for the function + >>> some_func.__defaults__ # 这里会显示函数的默认参数的值 ([],) >>> some_func() >>> some_func.__defaults__ @@ -1588,7 +1588,7 @@ def some_func(default_arg=[]): (['some_string', 'some_string'],) ``` -- A common practice to avoid bugs due to mutable arguments is to assign `None` as the default value and later check if any value is passed to the function corresponding to that argument. Example: +- 避免可变参数导致的错误的常见做法是将 `None` 指定为参数的默认值, 然后检查是否有值传给对应的参数. 例: ```py def some_func(default_arg=None): From bde42e4fc0639f4d4596b436d468120f0115c14c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Sun, 25 Nov 2018 17:51:13 +0800 Subject: [PATCH 35/53] EX.Catching the Exceptions --- README.md | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/README.md b/README.md index 8b340f5..aa4650e 100644 --- a/README.md +++ b/README.md @@ -60,7 +60,7 @@ So, here we go... - [> Deleting a list item while iterating/迭代列表时删除元素](#-deleting-a-list-item-while-iterating迭代列表时删除元素) - [> Loop variables leaking out!/循环变量泄漏!](#-loop-variables-leaking-out循环变量泄漏) - [> Beware of default mutable arguments!/当心默认的可变参数!](#-beware-of-default-mutable-arguments当心默认的可变参数) - - [> Catching the Exceptions](#-catching-the-exceptions) + - [> Catching the Exceptions/捕获异常](#-catching-the-exceptions捕获异常) - [> Same operands, different story!](#-same-operands-different-story) - [> The out of scope variable](#-the-out-of-scope-variable) - [> Be careful with chained operations](#-be-careful-with-chained-operations) @@ -1600,18 +1600,18 @@ def some_func(default_arg=[]): --- -### > Catching the Exceptions +### > Catching the Exceptions/捕获异常 ```py some_list = [1, 2, 3] try: - # This should raise an ``IndexError`` + # 这里会抛出异常 ``IndexError`` print(some_list[4]) except IndexError, ValueError: print("Caught!") try: - # This should raise a ``ValueError`` + # 这里会抛出异常 ``ValueError`` some_list.remove(4) except IndexError, ValueError: print("Caught again!") @@ -1632,13 +1632,13 @@ ValueError: list.remove(x): x not in list SyntaxError: invalid syntax ``` -#### 💡 Explanation +#### 💡 说明: -* To add multiple Exceptions to the except clause, you need to pass them as parenthesized tuple as the first argument. The second argument is an optional name, which when supplied will bind the Exception instance that has been raised. Example, +* 如果你想要同时捕获多个不同类型的异常时, 你需要将它们用括号包成一个元组作为第一个参数传递. 第二个参数是可选名称, 如果你提供, 它将与被捕获的异常实例绑定. 例, ```py some_list = [1, 2, 3] try: - # This should raise a ``ValueError`` + # 这里会抛出异常 ``ValueError`` some_list.remove(4) except (IndexError, ValueError), e: print("Caught again!") @@ -1657,7 +1657,7 @@ SyntaxError: invalid syntax IndentationError: unindent does not match any outer indentation level ``` -* Separating the exception from the variable with a comma is deprecated and does not work in Python 3; the correct way is to use `as`. Example, +* 在 Python 3 中, 用逗号区分异常与可选名称是无效的; 正确的做法是使用 `as` 关键字. 例, ```py some_list = [1, 2, 3] try: From 07d3f3db803a52fb009aec2bb053c864515cfd06 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Sun, 25 Nov 2018 18:09:11 +0800 Subject: [PATCH 36/53] EX.Same operands, different story --- README.md | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index aa4650e..40d1f09 100644 --- a/README.md +++ b/README.md @@ -61,7 +61,7 @@ So, here we go... - [> 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) + - [> Same operands, different story!/同人不同命!](#-same-operands-different-story同人不同命) - [> The out of scope variable](#-the-out-of-scope-variable) - [> Be careful with chained operations](#-be-careful-with-chained-operations) - [> Name resolution ignoring class scope](#-name-resolution-ignoring-class-scope) @@ -1675,7 +1675,7 @@ SyntaxError: invalid syntax --- -### > Same operands, different story! +### > Same operands, different story!/同人不同命! 1\. ```py @@ -1707,13 +1707,13 @@ a += [5, 6, 7, 8] [1, 2, 3, 4, 5, 6, 7, 8] ``` -#### 💡 Explanation: +#### 💡 说明: -* `a += b` doesn't always behave the same way as `a = a + b`. Classes *may* implement the *`op=`* operators differently, and lists do this. +* `a += b` 并不总是与 `a = a + b` 表现相同. 类实现 *`op=`* 运算符的方式 *也许* 是不同的, 列表就是这样做的. -* The expression `a = a + [5,6,7,8]` generates a new list and sets `a`'s reference to that new list, leaving `b` unchanged. +* 表达式 `a = a + [5,6,7,8]` 会生成一个新列表, 并让 `a` 引用这个新列表, 同时保持 `b` 不变. -* The expression `a += [5,6,7,8]` is actually mapped to an "extend" function that operates on the list such that `a` and `b` still point to the same list that has been modified in-place. +* 表达式 `a += [5,6,7,8]` 实际上是使用的是 "extend" 函数, 所以 `a` 和 `b` 仍然指向已被修改的同一列表. --- From b145d7aa8144754adb546bd2d7c8b7ad80df6e70 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Sun, 25 Nov 2018 18:24:06 +0800 Subject: [PATCH 37/53] EX.The out of scope variable --- README.md | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index 40d1f09..68c93d0 100644 --- a/README.md +++ b/README.md @@ -62,7 +62,7 @@ So, here we go... - [> Beware of default mutable arguments!/当心默认的可变参数!](#-beware-of-default-mutable-arguments当心默认的可变参数) - [> Catching the Exceptions/捕获异常](#-catching-the-exceptions捕获异常) - [> Same operands, different story!/同人不同命!](#-same-operands-different-story同人不同命) - - [> The out of scope variable](#-the-out-of-scope-variable) + - [> The out of scope variable/外部作用域变量](#-the-out-of-scope-variable外部作用域变量) - [> Be careful with chained operations](#-be-careful-with-chained-operations) - [> Name resolution ignoring class scope](#-name-resolution-ignoring-class-scope) - [> Needle in a Haystack](#-needle-in-a-haystack) @@ -1717,7 +1717,7 @@ a += [5, 6, 7, 8] --- -### > The out of scope variable +### > The out of scope variable/外部作用域变量 ```py a = 1 @@ -1737,10 +1737,10 @@ def another_func(): UnboundLocalError: local variable 'a' referenced before assignment ``` -#### 💡 Explanation: -* When you make an assignment to a variable in scope, it becomes local to that scope. So `a` becomes local to the scope of `another_func`, but it has not been initialized previously in the same scope which throws an error. -* Read [this](http://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. -* To modify the outer scope variable `a` in `another_func`, use `global` keyword. +#### 💡 说明: +* 当你在作用域中对变量进行赋值时, 变量会变成该作用域内的局部变量. 因此 `a` 会变成 `another_func` 函数作用域中的局部变量, 但它在函数作用域中并没有被初始化, 所以会引发错误. +* 可以阅读[这个](http://sebastianraschka.com/Articles/2014_python_scope_and_namespaces.html)简短却很棒的指南, 了解更多关于 Python 中命名空间和作用域的工作原理. +* 想要在 `another_func` 中修改外部作用域变量 `a` 的话, 可以使用 `global` 关键字. ```py def another_func() global a From 2887b7b8210a713d242b0af7c4a532a0239d7542 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Sun, 25 Nov 2018 22:02:02 +0800 Subject: [PATCH 38/53] EX.The out of scope variable --- README.md | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/README.md b/README.md index 68c93d0..92c3696 100644 --- a/README.md +++ b/README.md @@ -63,7 +63,7 @@ So, here we go... - [> Catching the Exceptions/捕获异常](#-catching-the-exceptions捕获异常) - [> Same operands, different story!/同人不同命!](#-same-operands-different-story同人不同命) - [> The out of scope variable/外部作用域变量](#-the-out-of-scope-variable外部作用域变量) - - [> Be careful with chained operations](#-be-careful-with-chained-operations) + - [> Be careful with chained operations/小心链式操作](#-be-careful-with-chained-operations小心链式操作) - [> Name resolution ignoring class scope](#-name-resolution-ignoring-class-scope) - [> Needle in a Haystack](#-needle-in-a-haystack) - [Section: The Hidden treasures!](#section-the-hidden-treasures) @@ -1756,14 +1756,14 @@ UnboundLocalError: local variable 'a' referenced before assignment --- -### > Be careful with chained operations +### > Be careful with chained operations/小心链式操作 ```py ->>> (False == False) in [False] # makes sense +>>> (False == False) in [False] # 可以理解 False ->>> False == (False in [False]) # makes sense +>>> False == (False in [False]) # 可以理解 False ->>> False == False in [False] # now what? +>>> False == False in [False] # 为毛? True >>> True is False == False @@ -1779,25 +1779,25 @@ False False ``` -#### 💡 Explanation: +#### 💡 说明: -As per https://docs.python.org/2/reference/expressions.html#not-in +根据 https://docs.python.org/2/reference/expressions.html#not-in -> Formally, if a, b, c, ..., y, z are expressions and op1, op2, ..., opN are comparison operators, then a op1 b op2 c ... y opN z is equivalent to a op1 b and b op2 c and ... y opN z, except that each expression is evaluated at most once. +> 形式上, 如果 a, b, c, ..., y, z 是表达式, 而 op1, op2, ..., opN 是比较运算符, 那么除了每个表达式最多只出现一次以外 a op1 b op2 c ... y opN z 就等于 a op1 b and b op2 c and ... y opN z. -While such behavior might seem silly to you in the above examples, it's fantastic with stuff like `a == b == c` and `0 <= x <= 100`. +虽然上面的例子似乎很愚蠢, 但是像 `a == b == c` 或 `0 <= x <= 100` 就很棒了. -* `False is False is False` is equivalent to `(False is False) and (False is False)` -* `True is False == False` is equivalent to `True is False and False == False` and since the first part of the statement (`True is False`) evaluates to `False`, the overall expression evaluates to `False`. -* `1 > 0 < 1` is equivalent to `1 > 0 and 0 < 1` which evaluates to `True`. -* The expression `(1 > 0) < 1` is equivalent to `True < 1` and +* `False is False is False` 相当于 `(False is False) and (False is False)` +* `True is False == False` 相当于 `True is False and False == False`, 由于语句的第一部分 (`True is False`) 等于 `False`, 因此整个表达式的结果为 `False`. +* `1 > 0 < 1` 相当于 `1 > 0 and 0 < 1`, 所以最终结果为 `True`. +* 表达式 `(1 > 0) < 1` 相当于 `True < 1` 且 ```py >>> int(True) 1 - >>> True + 1 #not relevant for this example, but just for fun + >>> True + 1 # 与这个例子无关，只是好玩 2 ``` - So, `1 < 1` evaluates to `False` + 所以, `1 < 1` 等于 `False` --- From c2fb6e7ac51cab13bcfadeec8bb343b30f6962df Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Sun, 25 Nov 2018 22:12:48 +0800 Subject: [PATCH 39/53] EX.Name resolution ignoring class scope --- README.md | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index 92c3696..887f924 100644 --- a/README.md +++ b/README.md @@ -64,7 +64,7 @@ So, here we go... - [> Same operands, different story!/同人不同命!](#-same-operands-different-story同人不同命) - [> The out of scope variable/外部作用域变量](#-the-out-of-scope-variable外部作用域变量) - [> Be careful with chained operations/小心链式操作](#-be-careful-with-chained-operations小心链式操作) - - [> Name resolution ignoring class scope](#-name-resolution-ignoring-class-scope) + - [> Name resolution ignoring class scope/忽略类作用域的名称解析](#-name-resolution-ignoring-class-scope忽略类作用域的名称解析) - [> Needle in a Haystack](#-needle-in-a-haystack) - [Section: The Hidden treasures!](#section-the-hidden-treasures) - [> Okay Python, Can you make me fly? *](#-okay-python-can-you-make-me-fly-) @@ -1801,7 +1801,7 @@ False --- -### > Name resolution ignoring class scope +### > Name resolution ignoring class scope/忽略类作用域的名称解析 1\. ```py @@ -1837,10 +1837,10 @@ class SomeClass: 5 ``` -#### 💡 Explanation -- Scopes nested inside class definition ignore names bound at the class level. -- A generator expression has its own scope. -- Starting from Python 3.X, list comprehensions also have their own scope. +#### 💡 说明: +- 类定义中嵌套的作用域会忽略类内的名称绑定. +- 生成器表达式有它自己的作用域. +- 从 Python 3.X 开始, 列表推导式也有自己的作用域. --- From 314bc2093fdbd537e7e0024ba9820aafe227929e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Sun, 25 Nov 2018 22:45:25 +0800 Subject: [PATCH 40/53] EX.Needle in a Haystack --- README.md | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/README.md b/README.md index 887f924..8bcadd3 100644 --- a/README.md +++ b/README.md @@ -65,7 +65,7 @@ So, here we go... - [> The out of scope variable/外部作用域变量](#-the-out-of-scope-variable外部作用域变量) - [> Be careful with chained operations/小心链式操作](#-be-careful-with-chained-operations小心链式操作) - [> Name resolution ignoring class scope/忽略类作用域的名称解析](#-name-resolution-ignoring-class-scope忽略类作用域的名称解析) - - [> Needle in a Haystack](#-needle-in-a-haystack) + - [> Needle in a Haystack/大海捞针](#-needle-in-a-haystack大海捞针) - [Section: The Hidden treasures!](#section-the-hidden-treasures) - [> Okay Python, Can you make me fly? *](#-okay-python-can-you-make-me-fly-) - [> `goto`, but why? *](#-goto-but-why-) @@ -1844,7 +1844,7 @@ class SomeClass: --- -### > Needle in a Haystack +### > Needle in a Haystack/大海捞针 1\. ```py @@ -1853,11 +1853,11 @@ x, y = (0, 1) if True else None, None **Output:** ``` ->>> x, y # expected (0, 1) +>>> x, y # 期望的结果是 (0, 1) ((0, 1), None) ``` -Almost every Python programmer has faced a similar situation. +几乎每个 Python 程序员都遇到过类似的情况. 2\. ```py @@ -1883,10 +1883,10 @@ e tuple() ``` -#### 💡 Explanation: -* For 1, the correct statement for expected behavior is `x, y = (0, 1) if True else (None, None)`. -* For 2, the correct statement for expected behavior is `t = ('one',)` or `t = 'one',` (missing comma) otherwise the interpreter considers `t` to be a `str` and iterates over it character by character. -* `()` is a special token and denotes empty `tuple`. +#### 💡 说明: +* 对于 1, 正确的语句是 `x, y = (0, 1) if True else (None, None)`. +* 对于 2, 正确的语句是 `t = ('one',)` 或者 `t = 'one',` (缺少逗号) 否则解释器会认为 `t` 是一个字符串, 并逐个字符对其进行迭代. +* `()` 是一个特殊的标记，表示空元组. --- From cd47d9e8cc21fd1fe8190551d8eda8347c8febd3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Sun, 25 Nov 2018 23:47:01 +0800 Subject: [PATCH 41/53] EX.Okay Python, Can you make me fly --- README.md | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/README.md b/README.md index 8bcadd3..77ec051 100644 --- a/README.md +++ b/README.md @@ -67,7 +67,7 @@ So, here we go... - [> Name resolution ignoring class scope/忽略类作用域的名称解析](#-name-resolution-ignoring-class-scope忽略类作用域的名称解析) - [> Needle in a Haystack/大海捞针](#-needle-in-a-haystack大海捞针) - [Section: The Hidden treasures!](#section-the-hidden-treasures) - - [> Okay Python, Can you make me fly? *](#-okay-python-can-you-make-me-fly-) + - [> Okay Python, Can you make me fly?/Python, 可否带我飞? *](#-okay-python-can-you-make-me-flypython-可否带我飞-) - [> `goto`, but why? *](#-goto-but-why-) - [> Brace yourself! *](#-brace-yourself-) - [> Let's meet Friendly Language Uncle For Life *](#-lets-meet-friendly-language-uncle-for-life-) @@ -1897,21 +1897,21 @@ tuple() This section contains few of the lesser-known interesting things about Python that most beginners like me are unaware of (well, not anymore). -### > Okay Python, Can you make me fly? * +### > Okay Python, Can you make me fly?/Python, 可否带我飞? * -Well, here you go +好, 去吧. ```py import antigravity ``` **Output:** -Sshh.. It's a super secret. +嘘.. 这是个超级秘密. -#### 💡 Explanation: -+ `antigravity` module is one of the few easter eggs released by Python developers. -+ `import antigravity` opens up a web browser pointing to the [classic XKCD comic](http://xkcd.com/353/) about Python. -+ Well, there's more to it. There's **another easter egg inside the easter egg**. If you look at the [code](https://github.com/python/cpython/blob/master/Lib/antigravity.py#L7-L17), there's a function defined that purports to implement the [XKCD's geohashing algorithm](https://xkcd.com/426/). +#### 💡 说明: ++ `antigravity` 模块是 Python 开发人员发布的少数复活节彩蛋之一. ++ `import antigravity` 会打开一个 Python 的[经典 XKCD 漫画](http://xkcd.com/353/)页面. ++ 不止如此. 这个**复活节彩蛋里还有一个复活节彩蛋**. 如果你看一下[代码](https://github.com/python/cpython/blob/master/Lib/antigravity.py#L7-L17), 就会发现还有一个函数实现了 [XKCD's geohashing 算法](https://xkcd.com/426/). --- From d6e00398b893fa203046354382b377afbdc81245 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Mon, 26 Nov 2018 23:25:02 +0800 Subject: [PATCH 42/53] EX.goto, but why --- README.md | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/README.md b/README.md index 77ec051..ca08273 100644 --- a/README.md +++ b/README.md @@ -68,7 +68,7 @@ So, here we go... - [> Needle in a Haystack/大海捞针](#-needle-in-a-haystack大海捞针) - [Section: The Hidden treasures!](#section-the-hidden-treasures) - [> Okay Python, Can you make me fly?/Python, 可否带我飞? *](#-okay-python-can-you-make-me-flypython-可否带我飞-) - - [> `goto`, but why? *](#-goto-but-why-) + - [> `goto`, but why?/`goto`, 但为什么? *](#-goto-but-whygoto-但为什么-) - [> Brace yourself! *](#-brace-yourself-) - [> 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-) @@ -1915,7 +1915,7 @@ import antigravity --- -### > `goto`, but why? * +### > `goto`, but why?/`goto`, 但为什么? * ```py from goto import goto, label @@ -1924,7 +1924,7 @@ for i in range(9): for k in range(9): print("I'm trapped, please rescue!") if k == 2: - goto .breakout # breaking out from a deeply nested loop + goto .breakout # 从多重循环中跳出 label .breakout print("Freedom!") ``` @@ -1936,10 +1936,10 @@ I'm trapped, please rescue! Freedom! ``` -#### 💡 Explanation: -- A working version of `goto` in Python was [announced](https://mail.python.org/pipermail/python-announce-list/2004-April/002982.html) as an April Fool's joke on 1st April 2004. -- Current versions of Python do not have this module. -- Although it works, but please don't use it. Here's the [reason](https://docs.python.org/3/faq/design.html#why-is-there-no-goto) to why `goto` is not present in Python. +#### 💡 说明: +- 2004年4月1日, Python [宣布](https://mail.python.org/pipermail/python-announce-list/2004-April/002982.html) 加入一个可用的 `goto` 作为愚人节礼物. +- 当前版本的 Python 并没有这个模块. +- 就算可以用, 也请不要使用它. 这里是为什么Python中没有 `goto` 的[原因](https://docs.python.org/3/faq/design.html#why-is-there-no-goto). --- From c1d5f8bab127cd9421a3a5f49aa96ce8dda2cc8f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9A=AE=E6=99=A8?= <362864550@qq.com> Date: Mon, 26 Nov 2018 23:42:47 +0800 Subject: [PATCH 43/53] EX.Brace yourself --- README.md | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/README.md b/README.md index ca08273..964b55b 100644 --- a/README.md +++ b/README.md @@ -69,7 +69,7 @@ So, here we go... - [Section: The Hidden treasures!](#section-the-hidden-treasures) - [> Okay Python, Can you make me fly?/Python, 可否带我飞? *](#-okay-python-can-you-make-me-flypython-可否带我飞-) - [> `goto`, but why?/`goto`, 但为什么? *](#-goto-but-whygoto-但为什么-) - - [> Brace yourself! *](#-brace-yourself-) + - [> Brace yourself!/做好思想准备 *](#-brace-yourself做好思想准备-) - [> 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) @@ -1943,9 +1943,9 @@ Freedom! --- -### > Brace yourself! * +### > 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, +如果你不喜欢在Python中使用空格来表示作用域, 你可以导入 C 风格的 {}, ```py from __future__ import braces @@ -1958,11 +1958,11 @@ from __future__ import braces SyntaxError: not a chance ``` -Braces? No way! If you think that's disappointing, use Java. +想用大括号? 没门! 觉得不爽, 请去用java. -#### 💡 Explanation: -+ The `__future__` module is normally used to provide features from future versions of Python. The "future" here is however ironic. -+ This is an easter egg concerned with the community's feelings on this issue. +#### 💡 说明: ++ 通常 `__future__` 会提供 Python 未来版本的功能. 然而，这里的 “未来” 是一个讽刺. ++ 这是一个表达社区对此类问题态度的复活节彩蛋. --- From 3b9facea56ad0dc78e1def1cd7c5de43ec5cf708 Mon Sep 17 00:00:00 2001 From: ducheng Date: Tue, 27 Nov 2018 11:20:28 +0800 Subject: [PATCH 44/53] EX.Let's meet Friendly Language Uncle For Life --- README.md | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/README.md b/README.md index 964b55b..11188b8 100644 --- a/README.md +++ b/README.md @@ -70,7 +70,7 @@ So, here we go... - [> Okay Python, Can you make me fly?/Python, 可否带我飞? *](#-okay-python-can-you-make-me-flypython-可否带我飞-) - [> `goto`, but why?/`goto`, 但为什么? *](#-goto-but-whygoto-但为什么-) - [> Brace yourself!/做好思想准备 *](#-brace-yourself做好思想准备-) - - [> Let's meet Friendly Language Uncle For Life *](#-lets-meet-friendly-language-uncle-for-life-) + - [> 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) - [> Inpinity *](#-inpinity-) @@ -1966,12 +1966,12 @@ SyntaxError: not a chance --- -### > Let's meet Friendly Language Uncle For Life * +### > Let's meet Friendly Language Uncle For Life/让生活更友好 * **Output (Python 3.x)** ```py >>> from __future__ import barry_as_FLUFL ->>> "Ruby" != "Python" # there's no doubt about it +>>> "Ruby" != "Python" # 这里没什么疑问 File "some_file.py", line 1 "Ruby" != "Python" ^ @@ -1981,14 +1981,14 @@ SyntaxError: invalid syntax True ``` -There we go. - -#### 💡 Explanation: -- This is relevant to [PEP-401](https://www.python.org/dev/peps/pep-0401/) released on April 1, 2009 (now you know, what it means). -- Quoting from the PEP-401 - > 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/). +这就对了. +#### 💡 说明: +- 相关的 [PEP-401](https://www.python.org/dev/peps/pep-0401/) 发布于 2009年4月1日 (所以你现在知道这意味着什么了吧). +- 引用 PEP-401 + > 意识到 Python 3.0 里的 != 运算符是一个会引起手指疼痛的恐怖错误, FLUFL 将 <> 运算符恢复为唯一写法. +- Uncle Barry 在 PEP 中还分享了其他东西; 你可以在[这里](https://www.python.org/dev/peps/pep-0401/)获得他们. +- (译: 虽然文档中没写，但应该是只能在交互解释器中使用.) --- ### > Even Python understands that love is complicated * From 6810b67530d8cc3e7fe7f7ce5cb793c5abbae672 Mon Sep 17 00:00:00 2001 From: ducheng Date: Tue, 27 Nov 2018 14:35:23 +0800 Subject: [PATCH 45/53] EX.Even Python understands that love is complicated --- README.md | 38 +++++++++++++++++++++++++++++--------- 1 file changed, 29 insertions(+), 9 deletions(-) diff --git a/README.md b/README.md index 11188b8..8e40945 100644 --- a/README.md +++ b/README.md @@ -71,7 +71,7 @@ So, here we go... - [> `goto`, but why?/`goto`, 但为什么? *](#-goto-but-whygoto-但为什么-) - [> Brace yourself!/做好思想准备 *](#-brace-yourself做好思想准备-) - [> 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-) + - [> Even Python understands that love is complicated/连Python也知道爱是难言的 *](#-even-python-understands-that-love-is-complicated连Python也知道爱是难言的-) - [> Yes, it exists!](#-yes-it-exists) - [> Inpinity *](#-inpinity-) - [> Mangling time! *](#-mangling-time-) @@ -1991,40 +1991,59 @@ True - (译: 虽然文档中没写，但应该是只能在交互解释器中使用.) --- -### > Even Python understands that love is complicated * +### > Even Python understands that love is complicated/连Python也知道爱是难言的 * ```py import this ``` -Wait, what's **this**? `this` is love :heart: +等等, **this** 是什么? `this` 是爱 :heart: **Output:** ``` The Zen of Python, by Tim Peters Beautiful is better than ugly. +优美胜于丑陋（Python 以编写优美的代码为目标） 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. +除非你确定需要这样做（精准地捕获异常，不写 except:pass 风格的代码） 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. +虽然这并不容易，因为你不是 Python 之父（这里的 Dutch 是指 Guido ） Now is better than never. +现在行动好过永远不行动 Although never is often better than *right* now. +尽管不行动要好过鲁莽行动 If the implementation is hard to explain, it's a bad idea. +如果你无法向人描述你的方案，那肯定不是一个好方案； If the implementation is easy to explain, it may be a good idea. +如果你能轻松向人描述你的方案，那也许会是一个好方案（方案测评标准） Namespaces are one honking great idea -- let's do more of those! +命名空间是一种绝妙的理念，我们应当多加利用（倡导与号召） ``` -It's the Zen of Python! +这是 Python 之禅! ```py >>> love = this @@ -2036,15 +2055,16 @@ False False >>> love is not True or False True ->>> love is not True or False; love is love # Love is complicated +>>> love is not True or False; love is love # 爱是难言的 True ``` -#### 💡 Explanation: +#### 💡 说明: -* `this` module in Python is an easter egg for The Zen Of Python ([PEP 20](https://www.python.org/dev/peps/pep-0020)). -* And if you think that's already interesting enough, check out the implementation of [this.py](https://hg.python.org/cpython/file/c3896275c0f6/Lib/this.py). Interestingly, the code for the Zen violates itself (and that's probably the only place where this happens). -* Regarding the statement `love is not True or False; love is love`, ironic but it's self-explanatory. +* `this` 模块是关于 Python 之禅的复活节彩蛋 ([PEP 20](https://www.python.org/dev/peps/pep-0020)). +* 如果你认为这已经够有趣的了, 可以看看 [this.py](https://hg.python.org/cpython/file/c3896275c0f6/Lib/this.py) 的实现. 有趣的是, Python 之禅的实现代码违反了他自己 (这可能是唯一会发生这种情况的地方). +* +至于 `love is not True or False; love is love`, 意外却又不言而喻. --- From 3f7a692cf901dc1993fe1a95728d687d073aec6b Mon Sep 17 00:00:00 2001 From: ducheng Date: Tue, 27 Nov 2018 14:49:03 +0800 Subject: [PATCH 46/53] EX.Yes, it exists --- README.md | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/README.md b/README.md index 8e40945..27bab9e 100644 --- a/README.md +++ b/README.md @@ -72,7 +72,7 @@ So, here we go... - [> Brace yourself!/做好思想准备 *](#-brace-yourself做好思想准备-) - [> Let's meet Friendly Language Uncle For Life/让生活更友好 *](#-lets-meet-friendly-language-uncle-for-life让生活更友好-) - [> Even Python understands that love is complicated/连Python也知道爱是难言的 *](#-even-python-understands-that-love-is-complicated连Python也知道爱是难言的-) - - [> Yes, it exists!](#-yes-it-exists) + - [> Yes, it exists!/是的, 它存在!](#-yes-it-exists是的-它存在) - [> Inpinity *](#-inpinity-) - [> Mangling time! *](#-mangling-time-) - [Section: Miscellaneous](#section-miscellaneous) @@ -2068,9 +2068,9 @@ True --- -### > Yes, it exists! +### > Yes, it exists!/是的, 它存在! -**The `else` clause for loops.** One typical example might be: +**循环的 `else`.** 一个典型的例子: ```py def does_exists_num(l, to_find): @@ -2091,7 +2091,7 @@ Exists! Does not exist ``` -**The `else` clause in exception handling.** An example, +**异常的 `else` .** 例, ```py try: @@ -2107,9 +2107,9 @@ else: Try block executed successfully... ``` -#### 💡 Explanation: -- The `else` clause after a loop is executed only when there's no explicit `break` after all the iterations. -- `else` clause after try block is also called "completion clause" as reaching the `else` clause in a `try` statement means that the try block actually completed successfully. +#### 💡 说明: +- 循环后的 `else` 子句只会在循环没有触发 `break` 语句, 正常结束的情况下才会执行. +- try 之后的 `else` 子句也被称为 "完成子句", 因为在 `try` 语句中到达 `else` 子句意味着try块实际上已成功完成. --- From 4edb207a743b33974ed6d1096e63ac7def935386 Mon Sep 17 00:00:00 2001 From: ducheng Date: Tue, 27 Nov 2018 14:59:17 +0800 Subject: [PATCH 47/53] EX.Inpinity --- README.md | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index 27bab9e..0d9055c 100644 --- a/README.md +++ b/README.md @@ -73,7 +73,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/连Python也知道爱是难言的 *](#-even-python-understands-that-love-is-complicated连Python也知道爱是难言的-) - [> Yes, it exists!/是的, 它存在!](#-yes-it-exists是的-它存在) - - [> Inpinity *](#-inpinity-) + - [> Inpinity/无限 *](#-inpinity无限-) - [> Mangling time! *](#-mangling-time-) - [Section: Miscellaneous](#section-miscellaneous) - [> `+=` is faster](#--is-faster) @@ -2113,9 +2113,9 @@ Try block executed successfully... --- -### > Inpinity * +### > Inpinity/无限 * -The spelling is intended. Please, don't submit a patch for this. +英文拼写是有意的, 请不要为此提交补丁.(译: 我并不理解这里故意拼错的意义) **Output (Python 3.x):** ```py @@ -2126,9 +2126,9 @@ The spelling is intended. Please, don't submit a patch for this. -314159 ``` -#### 💡 Explanation: -- Hash of infinity is 10⁵ x π. -- Interestingly, the hash of `float('-inf')` is "-10⁵ x π" in Python 3, whereas "-10⁵ x e" in Python 2. +#### 💡 说明: +- infinity 的哈希值是 10⁵ x π. +- 有意思的是, `float('-inf')` 的哈希值在 Python 3 中是 "-10⁵ x π" , 而在 Python 2 中是 "-10⁵ x e". --- From fe65a1ac95f45d85999934c0d5e133e1a1875d6e Mon Sep 17 00:00:00 2001 From: ducheng Date: Tue, 27 Nov 2018 16:09:40 +0800 Subject: [PATCH 48/53] EX.Mangling time --- README.md | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/README.md b/README.md index 0d9055c..9f9c261 100644 --- a/README.md +++ b/README.md @@ -74,7 +74,7 @@ So, here we go... - [> Even Python understands that love is complicated/连Python也知道爱是难言的 *](#-even-python-understands-that-love-is-complicated连Python也知道爱是难言的-) - [> Yes, it exists!/是的, 它存在!](#-yes-it-exists是的-它存在) - [> Inpinity/无限 *](#-inpinity无限-) - - [> Mangling time! *](#-mangling-time-) + - [> Mangling time!修饰时间! *](#-mangling-time修饰时间-) - [Section: Miscellaneous](#section-miscellaneous) - [> `+=` is faster](#--is-faster) - [> Let's make a giant string!](#-lets-make-a-giant-string) @@ -2132,7 +2132,7 @@ Try block executed successfully... --- -### > Mangling time! * +### > Mangling time!/修饰时间! * ```py class Yo(object): @@ -2151,13 +2151,13 @@ AttributeError: 'Yo' object has no attribute '__honey' True ``` -Why did `Yo()._Yo__honey` work? Only Indian readers would understand. +为什么 `Yo()._Yo__honey` 能运行? 只有印度人理解.(译: 这又是什么梗?) -#### 💡 Explanation: +#### 💡 说明: -* [Name Mangling](https://en.wikipedia.org/wiki/Name_mangling) is used to avoid naming collisions between different namespaces. -* In Python, the interpreter modifies (mangles) the class member names starting with `__` (double underscore) and not ending with more than one trailing underscore by adding `_NameOfTheClass` in front. -* So, to access `__honey` attribute, we are required to append `_Yo` to the front which would prevent conflicts with the same name attribute defined in any other class. +* [名字修饰](https://en.wikipedia.org/wiki/Name_mangling) 用于避免不同命名空间之间名称冲突. +* 在 Python 中, 解释器会通过给类中以 `__` (双下划线)开头且结尾最多只有一个下划线的类成员名称加上`_NameOfTheClass` 来修饰(mangles)名称. +* 所以, 要访问 `__honey` 对象,我们需要加上 `_Yo` 以防止与其他类中定义的相同名称的属性发生冲突. --- From e395b08653c0cfa132b98faa41183a82fb05667b Mon Sep 17 00:00:00 2001 From: ducheng Date: Tue, 27 Nov 2018 16:18:44 +0800 Subject: [PATCH 49/53] EX.+= is faster --- README.md | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index 9f9c261..83876b6 100644 --- a/README.md +++ b/README.md @@ -76,7 +76,7 @@ So, here we go... - [> Inpinity/无限 *](#-inpinity无限-) - [> Mangling time!修饰时间! *](#-mangling-time修饰时间-) - [Section: Miscellaneous](#section-miscellaneous) - - [> `+=` is faster](#--is-faster) + - [> `+=` is faster/更快的 `+=` ](#--is-faster更快的-) - [> Let's make a giant string!](#-lets-make-a-giant-string) - [> Explicit typecast of strings](#-explicit-typecast-of-strings) - [> Minor Ones](#-minor-ones) @@ -2166,19 +2166,19 @@ True ## Section: Miscellaneous -### > `+=` is faster +### > `+=` is faster/更快的 `+=` ```py -# using "+", three strings: +# 用 "+" 连接三个字符串: >>> timeit.timeit("s1 = s1 + s2 + s3", setup="s1 = ' ' * 100000; s2 = ' ' * 100000; s3 = ' ' * 100000", number=100) 0.25748300552368164 -# using "+=", three strings: +# 用 "+=" 连接三个字符串: >>> timeit.timeit("s1 += s2 + s3", setup="s1 = ' ' * 100000; s2 = ' ' * 100000; s3 = ' ' * 100000", number=100) 0.012188911437988281 ``` -#### 💡 Explanation: -+ `+=` is faster than `+` for concatenating more than two strings because the first string (example, `s1` for `s1 += s2 + s3`) is not destroyed while calculating the complete string. +#### 💡 说明: ++ 连接两个以上的字符串时 `+=` 比 `+` 更快, 因为在计算过程中第一个字符串 (例如, `s1 += s2 + s3` 中的 `s1`) 不会被销毁.(译: 就是 `+=` 执行的是追加操作，少了一个销毁新建的动作.) --- From 1b9c1568d725e9502a15a6b6a5c397534e75766a Mon Sep 17 00:00:00 2001 From: ducheng Date: Tue, 27 Nov 2018 17:13:48 +0800 Subject: [PATCH 50/53] EX.Let's make a giant string --- README.md | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/README.md b/README.md index 83876b6..2498dc3 100644 --- a/README.md +++ b/README.md @@ -77,7 +77,7 @@ So, here we go... - [> Mangling time!修饰时间! *](#-mangling-time修饰时间-) - [Section: Miscellaneous](#section-miscellaneous) - [> `+=` is faster/更快的 `+=` ](#--is-faster更快的-) - - [> Let's make a giant string!](#-lets-make-a-giant-string) + - [> Let's make a giant string!/来做个巨大的字符串吧!](#-lets-make-a-giant-string来做个巨大的字符串吧) - [> Explicit typecast of strings](#-explicit-typecast-of-strings) - [> Minor Ones](#-minor-ones) - [Contributing](#contributing) @@ -2182,7 +2182,7 @@ True --- -### > Let's make a giant string! +### > Let's make a giant string!/来做个巨大的字符串吧！ ```py def add_string_with_plus(iters): @@ -2229,28 +2229,28 @@ def convert_list_to_string(l, iters): 10000 loops, best of 3: 80 µs per loop ``` -Let's increase the number of iterations by a factor of 10. +让我们将迭代次数增加10倍. ```py ->>> timeit(add_string_with_plus(100000)) # Linear increase in execution time +>>> timeit(add_string_with_plus(100000)) # 执行时间线性增加 100 loops, best of 3: 9.75 ms per loop ->>> timeit(add_bytes_with_plus(100000)) # Quadratic increase +>>> timeit(add_bytes_with_plus(100000)) # 二次增加 1000 loops, best of 3: 974 ms per loop ->>> timeit(add_string_with_format(100000)) # Linear increase +>>> timeit(add_string_with_format(100000)) # 线性增加 100 loops, best of 3: 5.25 ms per loop ->>> timeit(add_string_with_join(100000)) # Linear increase +>>> timeit(add_string_with_join(100000)) # 线性增加 100 loops, best of 3: 9.85 ms per loop >>> l = ["xyz"]*100000 ->>> timeit(convert_list_to_string(l, 100000)) # Linear increase +>>> timeit(convert_list_to_string(l, 100000)) # 线性增加 1000 loops, best of 3: 723 µs per loop ``` -#### 💡 Explanation -- You can read more about [timeit](https://docs.python.org/3/library/timeit.html) from here. It is generally used to measure the execution time of snippets. -- Don't use `+` for generating long strings — In Python, `str` is immutable, so the left and right strings have to be copied into the new string for every pair of concatenations. If you concatenate four strings of length 10, you'll be copying (10+10) + ((10+10)+10) + (((10+10)+10)+10) = 90 characters instead of just 40 characters. Things get quadratically worse as the number and size of the string increases (justified with the execution times of `add_bytes_with_plus` function) -- Therefore, it's advised to use `.format.` or `%` syntax (however, they are slightly slower than `+` for short strings). -- Or better, if already you've contents available in the form of an iterable object, then use `''.join(iterable_object)` which is much faster. -- `add_string_with_plus` didn't show a quadratic increase in execution time unlike `add_bytes_with_plus` because of the `+=` optimizations discussed in the previous example. Had the statement been `s = s + "x" + "y" + "z"` instead of `s += "xyz"`, the increase would have been quadratic. +#### 💡 说明: +- 你可以在这获得更多 [timeit](https://docs.python.org/3/library/timeit.html) 的相关信息. 它通常用于衡量代码片段的执行时间. +- 不要用 `+` 去生成过长的字符串, 在 Python 中, `str` 是不可变得, 所以在每次连接中你都要把左右两个字符串复制到新的字符串中. 如果你连接四个长度为10的字符串, 你需要拷贝 (10+10) + ((10+10)+10) + (((10+10)+10)+10) = 90 个字符而不是 40 个字符. 随着字符串的数量和大小的增加, 情况会变得越发的糟糕 (就像`add_bytes_with_plus` 函数的执行时间一样) +- 因此, 更建议使用 `.format.` 或 `%` 语法 (但是, 对于短字符串, 它们比 `+` 稍慢一点). +- 又或者, 如果你所需的内容已经以可迭代对象的形式提供了, 使用 `''.join(可迭代对象)` 要快多了. +- `add_string_with_plus` 的执行时间没有像 `add_bytes_with_plus` 一样出现二次增加是因为解释器会如同上一个列子所讨论的一样优化 `+=`. 用 `s = s + "x" + "y" + "z"` 替代 `s += "xyz"` 的话, 执行时间就会二次增加了. ```py def add_string_with_plus(iters): s = "" @@ -2260,7 +2260,7 @@ Let's increase the number of iterations by a factor of 10. >>> timeit(add_string_with_plus(10000)) 100 loops, best of 3: 9.87 ms per loop - >>> timeit(add_string_with_plus(100000)) # Quadratic increase in execution time + >>> timeit(add_string_with_plus(100000)) # 执行时间二次增加 1 loops, best of 3: 1.09 s per loop ``` From d952c0b82f1ea5e947b2afcd5b0f05de136266a7 Mon Sep 17 00:00:00 2001 From: ducheng Date: Tue, 27 Nov 2018 17:19:03 +0800 Subject: [PATCH 51/53] EX.Let's make a giant string --- README.md | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index 2498dc3..ead74cc 100644 --- a/README.md +++ b/README.md @@ -78,7 +78,7 @@ So, here we go... - [Section: Miscellaneous](#section-miscellaneous) - [> `+=` is faster/更快的 `+=` ](#--is-faster更快的-) - [> Let's make a giant string!/来做个巨大的字符串吧!](#-lets-make-a-giant-string来做个巨大的字符串吧) - - [> Explicit typecast of strings](#-explicit-typecast-of-strings) + - [> Explicit typecast of strings/字符串的显式类型转换](#-explicit-typecast-of-strings字符串的显式类型转换) - [> Minor Ones](#-minor-ones) - [Contributing](#contributing) - [Acknowledgements](#acknowledgements) @@ -2266,12 +2266,12 @@ def convert_list_to_string(l, iters): --- -### > Explicit typecast of strings +### > Explicit typecast of strings/字符串的显式类型转换 ```py a = float('inf') b = float('nan') -c = float('-iNf') #These strings are case-insensitive +c = float('-iNf') # 这些字符串不区分大小写 d = float('nan') ``` @@ -2289,7 +2289,7 @@ ValueError: could not convert string to float: some_other_string True >>> None == None # None==None True ->>> b == d #but nan!=nan +>>> b == d #但是 nan!=nan False >>> 50/a 0.0 @@ -2299,9 +2299,9 @@ nan nan ``` -#### 💡 Explanation: +#### 💡 说明: -`'inf'` and `'nan'` are special strings (case-insensitive), which when explicitly typecasted to `float` type, are used to represent mathematical "infinity" and "not a number" respectively. +`'inf'` 和 `'nan'` 是特殊的字符串(不区分大小写), 当显示转换成 `float` 型时, 它们分别用于表示数学意义上的 "无穷大" 和 "非数字". --- From db1a0fb18db5cfef58f6f4f00383c32c703478d0 Mon Sep 17 00:00:00 2001 From: ducheng Date: Tue, 27 Nov 2018 19:05:21 +0800 Subject: [PATCH 52/53] EX.Minor Ones --- README.md | 40 ++++++++++++++++++++-------------------- 1 file changed, 20 insertions(+), 20 deletions(-) diff --git a/README.md b/README.md index ead74cc..9644b9c 100644 --- a/README.md +++ b/README.md @@ -79,7 +79,7 @@ So, here we go... - [> `+=` is faster/更快的 `+=` ](#--is-faster更快的-) - [> Let's make a giant string!/来做个巨大的字符串吧!](#-lets-make-a-giant-string来做个巨大的字符串吧) - [> Explicit typecast of strings/字符串的显式类型转换](#-explicit-typecast-of-strings字符串的显式类型转换) - - [> Minor Ones](#-minor-ones) + - [> Minor Ones/小知识点](#-minor-ones小知识点) - [Contributing](#contributing) - [Acknowledgements](#acknowledgements) - [🎓 License](#🎓-license) @@ -2305,19 +2305,19 @@ nan --- -### > Minor Ones +### > Minor Ones/小知识点 -* `join()` is a string operation instead of list operation. (sort of counter-intuitive at first usage) +* `join()` 是一个字符串操作而不是列表操作. (第一次接触会觉得有点违反直觉) - **💡 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. + **💡 说明:** + 如果 `join()` 是字符串方法 那么它就可以处理任何可迭代的对象(列表，元组，迭代器). 如果它是列表方法, 则必须在每种类型中单独实现. 另外, 在 `list` 对象的通用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 a semantically correct statement as strings are [sequences](https://docs.python.org/3/glossary.html#term-sequence)(iterables supporting element access using integer indices) in Python. - + `3 --0-- 5 == 8` and `--5 == 5` are both semantically correct statements and evaluate to `True`. +* 看着奇怪但能正确运行的语句: + + `[] = ()` 语句在语义上是正确的 (解包一个空的 `tuple` 并赋值给 `list`) + + `'a'[0][0][0][0][0]` 在语义上也是正确的, 因为在 Python 中字符串同时也是[序列](https://docs.python.org/3/glossary.html#term-sequence)(可迭代对象支持使用整数索引访问元素). + + `3 --0-- 5 == 8` 和 `--5 == 5` 在语义上都是正确的, 且结果等于 `True`.(译: 这个我也不懂) -* Given that `a` is a number, `++a` and `--a` are both valid Python statements but don't behave the same way as compared with similar statements in languages like C, C++ or Java. +* 鉴于 `a` 是一个数组, `++a` 和 `--a` 都是有效的 Python 语句, 但其效果与 C, C++ 或 Java 等不一样. ```py >>> a = 5 >>> a @@ -2328,12 +2328,12 @@ nan 5 ``` - **💡 Explanation:** - + There is no `++` operator in Python grammar. It is actually two `+` operators. - + `++a` parses as `+(+a)` which translates to `a`. Similarly, the output of the statement `--a` can be justified. - + This StackOverflow [thread](https://stackoverflow.com/questions/3654830/why-are-there-no-and-operators-in-python) discusses the rationale behind the absence of increment and decrement operators in Python. + **💡 说明:** + + python 里没有 `++` 操作符. 这其实是两个 `+` 操作符. + + `++a` 被解析为 `+(+a)` 最后等于 `a`. `--a` 同理. + + 这个 StackOverflow [回答](https://stackoverflow.com/questions/3654830/why-are-there-no-and-operators-in-python) 讨论了为什么 Python 中缺少增量和减量运算符. -* 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!): +* Python 使用 2个字节存储函数中的本地变量. 理论上, 这意味着函数中只能定义65536个变量. 但是，Python 内置了一个方便的解决方案，可用于存储超过2^16个变量名. 下面的代码演示了当定义了超过65536个局部变量时堆栈中发生的情况 (警告: 这段代码会打印大约2^18行文本, 请做好准备!): ```py import dis exec(""" @@ -2346,18 +2346,18 @@ nan 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/2/library/multiprocessing.html) module. +* 你的 *Python 代码* 并不会多线程同时运行 (是的, 你没听错!). 虽然你觉得会产生多个线程并让它们同时执行你的代码, 但是, 由于 [全局解释锁](https://wiki.python.org/moin/GlobalInterpreterLock)的存在, 你所做的只是让你的线程依次在同一个核心上执行. Python 多线程适用于IO密集型的任务, 但如果想要并行处理CPU密集型的任务, 你应该会想使用 [multiprocessing](https://docs.python.org/2/library/multiprocessing.html) 模块. -* List slicing with out of the bounds indices throws no errors +* 列表切片超出索引边界而不引发任何错误 ```py >>> some_list = [1, 2, 3, 4, 5] >>> some_list[111:] [] ``` -* `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](http://chris.improbable.org/2014/8/25/adventures-in-unicode-digits/) related to this behavior of Python. +* `int('١٢٣٤٥٦٧٨٩')` 在 Python 3 中会返回 `123456789`. 在 Python 中, 十进制字符包括数字字符, 以及可用于形成十进制数字的所有字符, 例如: U+0660, ARABIC-INDIC DIGIT ZERO. 这有一个关于此的 [有趣故事](http://chris.improbable.org/2014/8/25/adventures-in-unicode-digits/). -* `'abc'.count('') == 4`. Here's an approximate implementation of `count` method, which would make the things more clear +* `'abc'.count('') == 4`. 这有一个 `count` 方法的相近实现, 能更好的说明问题 ```py def count(s, sub): result = 0 @@ -2365,7 +2365,7 @@ nan result += (s[i:i + len(sub)] == sub) return result ``` - The behavior is due to the matching of empty substring(`''`) with slices of length 0 in the original string. + 这个行为是由于空子串(`''`)与原始字符串中长度为0的切片相匹配导致的. --- From fe637c46a29fabe9674c9d6774594ccdc18880f4 Mon Sep 17 00:00:00 2001 From: ducheng Date: Wed, 28 Nov 2018 15:43:44 +0800 Subject: [PATCH 53/53] All Others --- README.md | 144 +++++++++++++++++++++++++++--------------------------- 1 file changed, 73 insertions(+), 71 deletions(-) diff --git a/README.md b/README.md index 9644b9c..253a15a 100644 --- a/README.md +++ b/README.md @@ -1,30 +1,30 @@

What the f*ck Python! 🐍

-

An interesting collection of surprising snippets and lesser-known Python features.

+

一些有趣且鲜为人知的 Python 特性.

[![WTFPL 2.0][license-image]][license-url] [![Commit id][commit-image]][commit-url] -Python, being a beautifully designed high-level and interpreter-based programming language, provides us with many features for the programmer's comfort. But sometimes, the outcomes of a Python snippet may not seem obvious to a regular user at first sight. +Python, 是一个设计优美的解释型高级语言, 它提供了很多能让程序员感到舒适的功能特性. 但有的时候, Python 的一些输出结果对于初学者来说似乎并不是那么一目了然. -Here is a fun project to collect such tricky & counter-intuitive examples and lesser-known features in Python, attempting to discuss what exactly is happening under the hood! +这个有趣的项目意在收集 Python 中那些难以理解和反人类直觉的例子以及鲜为人知的功能特性, 并尝试讨论这些现象背后真正的原理! -While some of the examples you see below may not be WTFs in the truest sense, but they'll reveal some of the interesting parts of Python that you might be unaware of. I find it a nice way to learn the internals of a programming language, and I think you'll find them interesting as well! +虽然下面的有些例子并不一定会让你觉得 WTFs, 但它们依然有可能会告诉你一些你所不知道的 Python 有趣特性. 我觉得这是一种学习编程语言内部原理的好办法, 而且我相信你也会从中获得乐趣! -If you're an experienced Python programmer, you can take it as a challenge to get most of them right in first attempt. You may be already familiar with some of these examples, and I might be able to revive sweet old memories of yours being bitten by these gotchas :sweat_smile: +如果您是一位经验比较丰富的 Python 程序员, 你可以尝试挑战看是否能一次就找到例子的正确答案. 你可能对其中的一些例子已经比较熟悉了, 那这也许能唤起你当年踩这些坑时的甜蜜回忆 :sweat_smile: -If you're a returning reader, you can learn about the new modifications [here](https://github.com/satwikkansal/wtfpython/releases/). +如果你不是第一次读了, 你可以在[这里](https://github.com/satwikkansal/wtfpython/releases/)获取变动内容. -So, here we go... +那么, 让我们开始吧... -# Table of Contents +# Table of Contents/目录 -- [Table of Contents](#table-of-contents) -- [Structure of the Examples](#structure-of-the-examples) -- [Usage](#usage) -- [👀 Examples](#👀-examples) - - [Section: Strain your brain!](#section-strain-your-brain) +- [Table of Contents/目录](#table-of-contents目录) +- [Structure of the Examples/示例结构](#structure-of-the-examples示例结构) +- [Usage/用法](#usage用法) +- [👀 Examples/示例](#👀-examples示例) + - [Section: Strain your brain!/大脑运动!](#section-strain-your-brain大脑运动) - [> Strings can be tricky sometimes/微妙的字符串 *](#-strings-can-be-tricky-sometimes微妙的字符串-) - [> Time for some hash brownies!/是时候来点蛋糕了!](#-time-for-some-hash-brownies是时候来点蛋糕了) - [> Return return everywhere!/到处返回！](#-return-return-everywhere到处返回) @@ -50,11 +50,11 @@ So, here we go... - [> Subclass relationships/子类关系 *](#-subclass-relationships子类关系-) - [> The mysterious key type conversion/神秘的键型转换 *](#-the-mysterious-key-type-conversion神秘的键型转换-) - [> Let's see if you can guess this?/看看你能否猜到这一点?](#-lets-see-if-you-can-guess-this看看你能否猜到这一点) - - [Section: Appearances are deceptive!](#section-appearances-are-deceptive) + - [Section: Appearances are deceptive!/外表是靠不住的!](#section-appearances-are-deceptive外表是靠不住的) - [> Skipping lines?/跳过一行?](#-skipping-lines跳过一行) - [> Teleportation/空间移动 *](#-teleportation空间移动-) - [> Well, something is fishy.../嗯, 有些可疑...](#-well-something-is-fishy嗯有些可疑) - - [Section: Watch out for the landmines!](#section-watch-out-for-the-landmines) + - [Section: Watch out for the landmines!/小心地雷!](#section-watch-out-for-the-landmines小心地雷) - [> Modifying a dictionary while iterating over it/迭代字典时的修改](#-modifying-a-dictionary-while-iterating-over-it迭代字典时的修改) - [> Stubborn `del` operator/坚强的 `del` *](#-stubborn-del-operator坚强的-del-) - [> Deleting a list item while iterating/迭代列表时删除元素](#-deleting-a-list-item-while-iterating迭代列表时删除元素) @@ -66,7 +66,7 @@ So, here we go... - [> Be careful with chained operations/小心链式操作](#-be-careful-with-chained-operations小心链式操作) - [> Name resolution ignoring class scope/忽略类作用域的名称解析](#-name-resolution-ignoring-class-scope忽略类作用域的名称解析) - [> Needle in a Haystack/大海捞针](#-needle-in-a-haystack大海捞针) - - [Section: The Hidden treasures!](#section-the-hidden-treasures) + - [Section: The Hidden treasures!/隐藏的宝藏!](#section-the-hidden-treasures隐藏的宝藏) - [> Okay Python, Can you make me fly?/Python, 可否带我飞? *](#-okay-python-can-you-make-me-flypython-可否带我飞-) - [> `goto`, but why?/`goto`, 但为什么? *](#-goto-but-whygoto-但为什么-) - [> Brace yourself!/做好思想准备 *](#-brace-yourself做好思想准备-) @@ -75,85 +75,85 @@ So, here we go... - [> Yes, it exists!/是的, 它存在!](#-yes-it-exists是的-它存在) - [> Inpinity/无限 *](#-inpinity无限-) - [> Mangling time!修饰时间! *](#-mangling-time修饰时间-) - - [Section: Miscellaneous](#section-miscellaneous) + - [Section: Miscellaneous/杂项](#section-miscellaneous杂项) - [> `+=` is faster/更快的 `+=` ](#--is-faster更快的-) - [> Let's make a giant string!/来做个巨大的字符串吧!](#-lets-make-a-giant-string来做个巨大的字符串吧) - [> Explicit typecast of strings/字符串的显式类型转换](#-explicit-typecast-of-strings字符串的显式类型转换) - [> Minor Ones/小知识点](#-minor-ones小知识点) -- [Contributing](#contributing) -- [Acknowledgements](#acknowledgements) -- [🎓 License](#🎓-license) - - [Help](#help) - - [Want to surprise your geeky pythonist friends?](#want-to-surprise-your-geeky-pythonist-friends) - - [Need a pdf version?](#need-a-pdf-version) - - [Follow Commit](#follow-commit) +- [Contributing/贡献](#contributing贡献) +- [Acknowledgements/致谢](#acknowledgements/致谢) +- [🎓 License/许可](#🎓-license许可) + - [Help/帮助](#help帮助) + - [Want to surprise your geeky pythonist friends?/想给你的极客朋友一个惊喜?](#want-to-surprise-your-geeky-pythonist-friends想给你的极客朋友一个惊喜) + - [Need a pdf version?/需要来一份pdf版的?](#need-a-pdf-version需要来一份pdf版的) + - [Follow Commit/追踪Commit](#follow-commit追踪Commit) -# Structure of the Examples +# Structure of the Examples/示例结构 -All the examples are structured like below: +所有示例的结构都如下所示: -> ### > Some fancy Title * -> The asterisk at the end of the title indicates the example was not present in the first release and has been recently added. +> ### > 一个精选的标题 * +> 标题末尾的星号表示该示例在第一版中不存在，是最近添加的. > > ```py -> # Setting up the code. -> # Preparation for the magic... +> # 准备代码. +> # 释放魔法... > ``` > > **Output (Python version):** > ```py -> >>> triggering_statement -> Probably unexpected output +> >>> 触发语句 +> 出乎意料的输出结果 > ``` -> (Optional): One line describing the unexpected output. +> (可选): 对意外输出结果的简短描述. > > -> #### 💡 Explanation: +> #### 💡 说明: > -> * Brief explanation of what's happening and why is it happening. +> * 简要说明发生了什么以及为什么会发生. > ```py -> Setting up examples for clarification (if necessary) +> 如有必要, 举例说明 > ``` > **Output:** > ```py -> >>> trigger # some example that makes it easy to unveil the magic -> # some justified output +> >>> 触发语句 # 一些让魔法变得容易理解的例子 +> # 一些正常的输入 > ``` -**Note:** All the examples are tested on Python 3.5.2 interactive interpreter, and they should work for all the Python versions unless explicitly specified in the description. +**注意:** 所有的示例都在 Python 3.5.2 版本的交互解释器上测试过, 如果不特别说明应该适用于所有 Python 版本. -# Usage +# Usage/用法 -A nice way to get the most out of these examples, in my opinion, will be just to read the examples chronologically, and for every example: -- Carefully read the initial code for setting up the example. If you're an experienced Python programmer, most of the times you will successfully anticipate what's going to happen next. -- Read the output snippets and, - + Check if the outputs are the same as you'd expect. - + Make sure if you know the exact reason behind the output being the way it is. - - If no, take a deep breath, and read the explanation (and if you still don't understand, shout out! and create an issue [here](https://github.com/satwikkansal/wtfPython)). - - If yes, give a gentle pat on your back, and you may skip to the next example. +我个人建议, 最好依次阅读下面的示例, 并对每个示例: +- 仔细阅读设置例子最开始的代码. 如果您是一位经验丰富的 Python 程序员, 那么大多数时候您都能成功预期到后面的结果. +- 阅读输出结果, + + 确认结果是否如你所料. + + 确认你是否知道这背后的原理. + - 如果不知道, 深呼吸然后阅读说明 (如果你还是看不明白, 别沉默! 可以在[这](https://github.com/satwikkansal/wtfPython)提个 issue). + - 如果知道, 给自己点奖励, 然后去看下一个例子. -PS: You can also read WTFpython at the command line. There's a pypi package and an npm package (supports colored formatting) for the same. +PS: 你也可以在命令行阅读 WTFpython. 我们有 pypi 包 和 npm 包(支持代码高亮).(译: 这两个都是英文版的) -To install the npm package [`wtfpython`](https://www.npmjs.com/package/wtfpython) +安装 npm 包 [`wtfpython`](https://www.npmjs.com/package/wtfpython) ```sh $ npm install -g wtfpython ``` -Alternatively, to install the pypi package [`wtfpython`](https://pypi.python.org/pypi/wtfpython) +或者, 安装 pypi 包 [`wtfpython`](https://pypi.python.org/pypi/wtfpython) ```sh $ pip install wtfpython -U ``` -Now, just run `wtfpython` at the command line which will open this collection in your selected `$PAGER`. +现在, 在命令行中运行 `wtfpython`, 你就可以开始浏览了. --- -# 👀 Examples +# 👀 Examples/示例 -## Section: Strain your brain! +## Section: Strain your brain!/大脑运动! ### > Strings can be tricky sometimes/微妙的字符串 * @@ -1229,7 +1229,7 @@ a, b = a[b] = {}, 5 --- -## Section: Appearances are deceptive! +## Section: Appearances are deceptive!/外表是靠不住的! ### > Skipping lines?/跳过一行? @@ -1338,7 +1338,7 @@ def square(x): --- -## Section: Watch out for the landmines! +## Section: Watch out for the landmines!/小心地雷! ### > Modifying a dictionary while iterating over it/迭代字典时的修改 @@ -1893,7 +1893,7 @@ tuple() --- -## Section: The Hidden treasures! +## Section: The Hidden treasures!/隐藏的宝藏! This section contains few of the lesser-known interesting things about Python that most beginners like me are unaware of (well, not anymore). @@ -2163,7 +2163,7 @@ True --- -## Section: Miscellaneous +## Section: Miscellaneous/杂项 ### > `+=` is faster/更快的 `+=` @@ -2369,17 +2369,17 @@ nan --- -# Contributing +# Contributing/贡献 -All patches are Welcome! Please see [CONTRIBUTING.md](/CONTRIBUTING.md) for further details. +欢迎各种补丁! 详情请看[CONTRIBUTING.md](https://github.com/satwikkansal/wtfpython/blob/master/CONTRIBUTING.md).(译: 这是给原库提贡献的要求模版) -For discussions, you can either create a new [issue](https://github.com/satwikkansal/wtfpython/issues/new) or ping on the Gitter [channel](https://gitter.im/wtfpython/Lobby) +你可以通过新建 [issue](https://github.com/satwikkansal/wtfpython/issues/new) 或者在上 [Gitter](https://gitter.im/wtfpython/Lobby) 与我们进行讨论. -# Acknowledgements +# Acknowledgements/致谢 -The idea and design for this collection were initially inspired by Denys Dovhan's awesome project [wtfjs](https://github.com/denysdovhan/wtfjs). The overwhelming support by the community gave it the shape it is in right now. +这个系列最初的想法和设计灵感来自于 Denys Dovhan 的项目 [wtfjs](https://github.com/denysdovhan/wtfjs). 社区的强大支持让它成长为现在的模样. -#### Some nice Links! +#### 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 @@ -2388,7 +2388,7 @@ The idea and design for this collection were initially inspired by Denys Dovhan' * https://www.python.org/doc/humor/ * https://www.satwikkansal.xyz/archives/posts/python/My-Python-archives/ -# 🎓 License +# 🎓 License/许可 [![CC 4.0][license-image]][license-url] @@ -2397,22 +2397,24 @@ The idea and design for this collection were initially inspired by Denys Dovhan' [license-url]: http://www.wtfpl.net [license-image]: https://img.shields.io/badge/License-WTFPL%202.0-lightgrey.svg?style=flat-square -## Help +## Help/帮助 -If you have any wtfs, ideas or suggestions, please share. +如果您有任何想法或建议，欢迎分享. -## Want to surprise your geeky pythonist friends? +## Want to surprise your geeky pythonist friends?/想给你的极客朋友一个惊喜? -You can recommend wtfpython to your friends on Twitter and Linkedin by using these quick links, +您可以使用这些快链向 Twitter 和 Linkedin 上的朋友推荐 wtfpython, [Twitter](https://twitter.com/intent/tweet?url=https://github.com/satwikkansal/wtfpython&hastags=python,wtfpython) | [Linkedin](https://www.linkedin.com/shareArticle?url=https://github.com/satwikkansal&title=What%20the%20f*ck%20Python!&summary=An%20interesting%20collection%20of%20subtle%20and%20tricky%20Python%20snippets.) -## Need a pdf version? +## Need a pdf version?/需要来一份pdf版的? -I've received a few requests for the pdf version of wtfpython. You can add your details [here](https://satwikkansal.xyz/wtfpython-pdf/) to get the pdf as soon as it is finished. +我收到一些想要pdf版本的需求. 你可以快速在[这](https://satwikkansal.xyz/wtfpython-pdf/)获得. -## Follow Commit +## Follow Commit/追踪Commit + +这是中文版 fork 时所处的原库 Commit, 当原库更新时我会跟随更新. [![Commit id][commit-image]][commit-url]