fix(guide): simplify directory structure

guide/russian/python/data-structures/dictionaries/index.md

@@ -0,0 +1,130 @@
+---
+title: The Python Dict
+localeTitle: Диктатор Питона
+---
+Словарь (aka «dict») в python - это встроенный тип данных, который можно использовать для хранения пар **`key-value`** . Это позволяет вам обращаться с **`dict`** как с _базой данных_ для хранения и организации данных.
+
+Особенность словарей в том, как они реализованы. Хэш-табличная структура упрощает проверку существование - это означает, что мы можем легко определить, присутствует ли в словаре конкретный ключ без необходимости изучения каждый элемент. Интерпретатор Python может просто перейти к ключу местоположения и проверить, есть ли ключ.
+
+Словари могут использовать практически любые произвольные типы данных, такие как строки, целые числа и т. Д. Для ключей. Однако значения, которые не являются хешируемыми, то есть значения, содержащие списки, словари или другие изменяемые типы (которые сравниваются по значению, а не по идентификатору объекта), могут не использоваться в качестве ключей. Числовые типы, используемые для ключей, подчиняются нормальным правилам для числового сравнения: если два числа сравниваются равными (например, `1` и `1.0` ), то они могут использоваться взаимозаменяемо для индексации одной и той же словарной записи. (Обратите внимание, однако, что, поскольку компьютеры хранят числа с плавающей запятой в качестве приближений, как правило, неразумно использовать их в качестве словарных ключей.)
+
+Одним из важнейших требований словаря является то, что ключи **должны** быть уникальными.  
+Чтобы создать пустой словарь, просто используйте пару фигурных скобок:
+
+```python
+    >>> teams = {} 
+    >>> type(teams) 
+    >>> <class 'dict'> 
+```
+
+  
+Чтобы создать непустой словарь с некоторыми начальными значениями, поместите разделенный запятыми список пар ключ-значение:
+
+```python
+    >>> teams = {'barcelona': 1875, 'chelsea': 1910} 
+    >>> teams 
+    {'barcelona': 1875, 'chelsea': 1910} 
+```
+
+Легко добавить пары ключ-значение в существующий словарь:
+
+```python
+    >>> teams['santos'] = 1787 
+    >>> teams 
+    {'chelsea': 1910, 'barcelona': 1875, 'santos': 1787} # Notice the order - Dictionaries are unordered ! 
+    >>> # extracting value - Just provide the key 
+    ... 
+    >>> teams['barcelona'] 
+    1875 
+```
+
+  
+**`del`** используется для удаления пары ключ-значение из dict. В сценариях, где ключ, который уже используется, снова используется для хранения значений, старое значение, связанное с этим ключом, полностью теряется. Кроме того, имейте в виду, что это ошибка для извлечения значения с использованием несуществующего ключа.
+
+```python
+    >>> del teams['santos'] 
+    >>> teams 
+    {'chelsea': 1910, 'barcelona': 1875} 
+    >>> teams['chelsea'] = 2017 # overwriting 
+    >>> teams 
+    {'chelsea': 2017, 'barcelona': 1875} 
+```
+
+  
+**`in`** ключевом слове может быть использована для проверки , существует ли ключ в Словаре или нет:
+
+```python
+    >>> 'sanots' in teams 
+    False 
+    >>> 'barcelona' in teams 
+    True 
+    >>> 'chelsea' not in teams 
+    False 
+```
+
+  
+**`keys`** - это встроенный _метод,_ который можно использовать для получения ключей данного словаря. Чтобы извлечь ключи, присутствующие в списках dict:
+
+```python
+    >>> club_names = list(teams.keys()) 
+    >>> club_names 
+    ['chelsea', 'barcelona'] 
+```
+
+  
+Еще один способ создания словаря - использовать метод **`dict()`** :
+
+```python
+    >>> players = dict( [('messi','argentina'), ('ronaldo','portugal'), ('kaka','brazil')] ) # sequence of key-value pair is passed 
+    >>> players 
+    {'ronaldo': 'portugal', 'kaka': 'brazil', 'messi': 'argentina'} 
+    >>> 
+    >>> # If keys are simple strings, it's quite easier to specify pairs using keyword arguments 
+    ... 
+    >>> dict( totti = 38, zidane = 43 ) 
+    {'zidane': 43, 'totti': 38} 
+```
+
+Понимание Dict также может быть использовано для создания словарей из произвольных выражений ключа и значения:
+
+```python
+    >>> {x: x**2 for x in (2, 4, 6)} 
+    {2: 4, 4: 16, 6: 36} 
+```
+
+**Цикл в словаре**  
+Чтобы просто перебрать ключи в словаре, а не клавиши и значения:
+
+```python
+    >>> d = {'x': 1, 'y': 2, 'z': 3} 
+    >>> for key in d: 
+    ...     print(key) # do something 
+    ... 
+    x 
+    y 
+    z 
+```
+
+Чтобы перебрать оба ключа и значения, вы можете использовать следующее:  
+Для Python 2.x:
+
+```python
+    >>> for key, item in d.iteritems(): 
+    ...     print items 
+    ... 
+    1 
+    2 
+    3 
+```
+
+Используйте **`items()`** для Python 3.x:
+
+```python
+    >>> for key, item in d.items(): 
+    ...     print(key, items) 
+    ... 
+    x 1 
+    y 2 
+    z 3 
+
+```

guide/russian/python/data-structures/floating-point-numbers/index.md

@@ -0,0 +1,118 @@
+---
+title: Python Floating Point Numbers
+localeTitle: Числа с плавающей запятой Python
+---
+Некоторая общая информация о числах с плавающей запятой и о том, как они работают на Python, можно найти [здесь](https://docs.python.org/3/tutorial/floatingpoint.html) .
+
+Почти все реализации Python соответствуют спецификации IEEE 754: стандарт для двоичной арифметики с плавающей запятой. Более подробная информация содержится на сайте [IEEE](http://grouper.ieee.org/groups/754/) .
+
+Объекты Float могут быть созданы с использованием [литералов](https://docs.python.org/3/reference/lexical_analysis.html#floating-point-literals) с [плавающей запятой](https://docs.python.org/3/reference/lexical_analysis.html#floating-point-literals) :
+```
+>>> 3.14 
+ 3.14 
+ >>> 314\.    # Trailing zero(s) not required. 
+ 314.0 
+ >>> .314    # Leading zero(s) not required. 
+ 0.314 
+ >>> 3e0 
+ 3.0 
+ >>> 3E0     # 'e' or 'E' can be used. 
+ 3.0 
+ >>> 3e1     # Positive value after e moves the decimal to the right. 
+ 30.0 
+ >>> 3e-1    # Negative value after e moves the decimal to the left. 
+ 0.3 
+ >>> 3.14e+2 # '+' not required but can be used for exponent part. 
+ 314.0 
+```
+
+Числовые литералы не содержат знак, однако создания негативных объектов с плавающей точкой можно предваряя с одноместный `-` (минус) оператором без пробела перед буквальным
+```
+>>> -3.141592653589793 
+ -3.141592653589793 
+ >>> type(-3.141592653589793) 
+ <class 'float'> 
+```
+
+Аналогично, позитивные объекты с плавающей запятой могут иметь префикс унарного `+ (` плюс) оператора без пробела перед литералом. Обычно `+` опущен:
+```
+>>> +3.141592653589793 
+ 3.141592653589793 
+```
+
+Обратите внимание, что начальный и конечный ноль (ы) действительны для литералов с плавающей запятой
+```
+>>> 0.0 
+ 0.0 
+ >>> 00.00 
+ 0.0 
+ >>> 00100.00100 
+ 100.001 
+ >>> 001e0010      # Same as 1e10 
+ 10000000000.0 
+```
+
+Конструктор [`float`](https://docs.python.org/3/library/functions.html#float) - это еще один способ создания `float` объектов.
+
+При необходимости предпочтительнее `float` объекты с плавающей точкой с литералами с плавающей запятой:
+```
+>>> a = 3.14         # Prefer floating point literal when possible. 
+ >>> type(a) 
+ <class 'float'> 
+ >>> b = int(3.14)    # Works but unnecessary. 
+ >>> type(b) 
+ <class 'float'> 
+```
+
+Однако конструктор float позволяет создавать объекты float из других типов номеров:
+```
+>>> a = 4 
+ >>> type(a) 
+ <class 'int'> 
+ >>> print(a) 
+ 4 
+ >>> b = float(4) 
+ >>> type(b) 
+ <class 'float'> 
+ >>> print(b) 
+ 4.0 
+ >>> float(400000000000000000000000000000000) 
+ 4e+32 
+ >>> float(.00000000000000000000000000000004) 
+ 4e-32 
+ >>> float(True) 
+ 1.0 
+ >>> float(False) 
+ 0.0 
+```
+
+Конструктор `float` также будет создавать объекты `float` из строк, которые представляют числовые литералы:
+```
+>>> float('1') 
+ 1.0 
+ >>> float('.1') 
+ 0.1 
+ >>> float('3.') 
+ 3.0 
+ >>> float('1e-3') 
+ 0.001 
+ >>> float('3.14') 
+ 3.14 
+ >>> float('-.15e-2') 
+ -0.0015 
+```
+
+Конструктор `float` также может использоваться для создания числового представления `NaN` (Not a Number), отрицательной `infinity` и `infinity` (строки примечаний для них нечувствительны к регистру):
+```
+>>> float('nan') 
+ nan 
+ >>> float('inf') 
+ inf 
+ >>> float('-inf') 
+ -inf 
+ >>> float('infinity') 
+ inf 
+ >>> float('-infinity') 
+ -inf 
+
+```

guide/russian/python/data-structures/index.md

@@ -0,0 +1,18 @@
+---
+title: The Python Data Structures
+localeTitle: Структуры данных Python
+---
+Структура данных - это особый способ организации данных на компьютере, чтобы он мог эффективно использоваться. Python поставляется с надежным набором встроенных структур данных. Некоторые из наиболее часто используемых:
+
+*   Списки
+*   Кортеж
+*   Словари
+
+В основном структуры данных можно разделить на две категории:
+
+*   Mutable: - Измененная структура данных - это структура, состояние которой может быть изменено после ее создания. Списки Python и словари изменяемы.
+*   Неизменяемость: - неизменяемая структура данных не может быть изменена. Пример: - После создания кортежа мы не можем обновить значения внутри него.
+
+## Справка:
+
+[Структуры данных Python](https://docs.python.org/3.7/tutorial/datastructures.html)

guide/russian/python/data-structures/integers/index.md

@@ -0,0 +1,165 @@
+---
+title: Python Integers
+localeTitle: Цепочки Python
+---
+Теоретическая область для целых чисел в python является отрицательной бесконечностью до бесконечности. На практике целочисленные значения ограничены объемом доступной памяти.
+
+В Python 2 существует различие между **`int`** , числами, которые соответствуют 32 или 64-битным _C длинным_ и **`long`** номерам, ограниченным доступной памятью. Python 3 объединил два типа в **`int`** , больше информации в [PEP 237](https://www.python.org/dev/peps/pep-0237/) .
+
+**создание `int` с использованием целочисленных литералов**
+
+[Целочисленные литеры](https://docs.python.org/3/reference/lexical_analysis.html#integer-literals)
+
+_Целочисленные объекты_ могут быть созданы с использованием целочисленных литералов. Безсердечные числа без десятичных знаков являются целыми литералами:
+```
+>>> 1234567890           # Unadorned numbers are integer literals 
+ 1234567890 
+ >>> type(1234567890) 
+ <class 'int'> 
+```
+
+Числовые литералы не содержат знак, однако создания отрицательных _целых объектов_ можно предваряя с одноместный `-` (минус) оператором без пробела перед буквальным:
+```
+>>> -1234567890 
+ -1234567890 
+ >>> type(-1234567890) 
+ <class 'int'> 
+```
+
+Аналогично, положительные целые объекты могут быть созданы путем префикса унарного `+` (плюс) оператора без пробела перед цифрами. Обычно `+` омрачивается:
+```
+>>> +1234 
+ 1234 
+```
+
+Бинарные (base 2, prefix: `0b` или `0B` ), восьмеричные (base 8, prefix: `0o` или `0O` ) и шестнадцатеричные (базовые 16, префикс: `0x` или `0X` ) целые числа также могут быть созданы с использованием целочисленных литералов:
+```
+>>> 0b1, 0b10, 0b11 
+ (1, 2, 3) 
+ >>> 0o1, 0o10, 0o11 
+ (1, 8, 9) 
+ >>> 0x1, 0x10, 0x11 
+ (1, 16, 17) 
+```
+
+Обратите внимание, что ведущие 0 для ненулевых целых литералов **не допускаются** :
+```
+>>> 0     # Zero by itself is okay. 
+ 0 
+ >>> 01    # Leading zero(s) cause SyntaxError. 
+  File "<stdin>", line 1 
+    01 
+     ^ 
+ SyntaxError: invalid token 
+```
+
+`int` [конструктор](https://docs.python.org/3/library/functions.html#int) еще один способ создать _целые объекты._
+```
+class int(x=0) 
+ class int(x, base=10) 
+```
+
+При необходимости предпочтительнее создавать _целые объекты_ с целыми литералами:
+```
+>>> a = 1         # Prefer integer literal when possible. 
+ >>> type(a) 
+ <class 'int'> 
+ >>> b = int(1)    # Works but unnecessary. 
+ >>> type(b) 
+ <class 'int'> 
+```
+
+Однако конструктор позволяет создавать _целые объекты_ из других типов номеров:
+```
+>>> a = 1.123 
+ >>> type(a) 
+ <class 'float'> 
+ >>> print(a) 
+ 1.123 
+ >>> b = int(1.123) 
+ >>> type(b) 
+ <class 'int'> 
+ >>> print(b) 
+ 1 
+```
+
+Использование конструктора `int` для чисел с плавающей запятой усекает число до нуля:
+```
+>>> int(-1.23) 
+ -1 
+ >>> int(1.23) 
+ 1 
+```
+
+Встроенные `boolean` константы являются экземплярами класса `bool` и являются подклассами класса `int` , что делает их своего рода числовым типом:
+```
+>>> type(True) 
+ <class 'bool'> 
+ >>> issubclass(bool, int) 
+ True 
+```
+
+Если это не имеет смысла для вас, не беспокойтесь. Теперь просто помните, что вызов конструктора int с `boolean` объектами будет возвращать _целые объекты_ :
+```
+>>> int(True) 
+ 1 
+ >>> int(False) 
+ 0 
+```
+
+Конструктор `int` также будет делать _целые объекты_ из строк:
+```
+>>> a = "10" 
+ >>> type(a) 
+ <class 'str'> 
+ >>> b = int("10") 
+ >>> type(b) 
+ <class 'int'> 
+```
+
+_Строки_ для конструктора `int` должны представлять целочисленный литерал:
+
+Второй параметр конструктора `int` - это указать базу (по умолчанию: 10). Допустимые значения: 0 и 2-36.
+
+Если явная база предоставляется, первым аргументом должна быть строка.
+```
+>>> int("111", 2) 
+ 7 
+ >>> int(111, 2) 
+ Traceback (most recent call last): 
+  File "<stdin>", line 1, in <module> 
+ TypeError: int() can't convert non-string with explicit base 
+```
+
+Строка, используемая для конструктора `int` с явной базой, должна быть допустимым целым литералом для этой базы:
+```
+>>> int('11', 2) 
+ 3 
+ >>> int('12', 2) 
+ Traceback (most recent call last): 
+  File "<stdin>", line 1, in <module> 
+ ValueError: invalid literal for int() with base 2: '12' 
+```
+
+Можно использовать как префиксные, так и не префиксные строки целых литералов, однако, если они используются, префикс должен соответствовать предоставленной базе.
+```
+>>> int('1101', 2) 
+ 13 
+ >>> int('0b1101', 2) 
+ 13 
+ >>> int('0x1101', 2) 
+ Traceback (most recent call last): 
+  File "<stdin>", line 1, in <module> 
+ ValueError: invalid literal for int() with base 2: '0x1101' 
+```
+
+Если используется префиксная строка и база 0, созданный целочисленный объект будет использовать базу, указанную префиксом. Если префикс не используется, то основание предполагается 10
+```
+>>> int('100', 0) 
+ 100 
+ >>> int('0b100', 0) 
+ 4 
+ >>> int('0o100', 0) 
+ 64 
+
+```

guide/russian/python/data-structures/objects/index.md

@@ -0,0 +1,116 @@
+---
+title: The Python Objects
+localeTitle: Объекты Python
+---
+> В Python все является _объектом_ .
+
+_Объекты_ представляют собой логическую группировку атрибутов. Атрибуты - это данные и / или функции. Когда объект создается в Python, он создается с _идентификатором_ , _типом_ и _значением_ .
+
+В других языках _примитивы_ - это _значения_ , которые не имеют _свойств_ (атрибутов). Например, в javascript `undefined` , `null` , `boolean` , `string` , `number` и `symbol` (new в ECMAScript 2015) являются примитивами.
+
+В Python нет примитивов. `None` , _логические значения_ , _строки_ , _числа_ и даже _функции_ - это все _объекты,_ независимо от того, как они создаются.
+
+Мы можем продемонстрировать это, используя некоторые встроенные функции:
+
+*   [`id`](https://docs.python.org/3/library/functions.html#id)
+*   [`type`](https://docs.python.org/3/library/functions.html#type)
+*   [`dir`](https://docs.python.org/3/library/functions.html#dir)
+*   [`issubclass`](https://docs.python.org/3/library/functions.html#issubclass)
+
+Встроенные константы `None` , `True` и `False` являются _объектами_ :
+
+Мы тестируем объект `None` здесь.
+
+```python
+>>> id(None) 
+ 4550218168 
+ >>> type(None) 
+ <class 'NoneType'> 
+ >>> dir(None) 
+ [__bool__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__'] 
+ >>> issubclass(type(None), object) 
+ True 
+```
+
+Затем, давайте проверим `True` .
+
+```python
+>>> id(True) 
+ 4550117616 
+ >>> type(True) 
+ <class 'bool'> 
+ >>> dir(True) 
+ ['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes'] 
+ >>> issubclass(type(True), object) 
+ True 
+```
+
+Нет причин оставлять `False` !
+
+```python
+>>> id(False) 
+ 4550117584 
+ >>> type(False) 
+ <class 'bool'> 
+ >>> dir(False) 
+ ['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes'] 
+ >>> issubclass(type(False), object) 
+ True 
+```
+
+_Строки_ , даже если они созданы строковыми литералами, также являются _объектами_ .
+
+```python
+>>> id("Hello campers!") 
+ 4570186864 
+ >>> type('Hello campers!') 
+ <class 'str'> 
+ >>> dir("Hello campers!") 
+ ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill'] 
+ >>> issubclass(type('Hello campers!'), object) 
+ True 
+```
+
+То же самое с _числами_
+
+```python
+>>> id(42) 
+ 4550495728 
+ >>> type(42) 
+ <class 'int'> 
+ >>> dir(42) 
+ ['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes'] 
+ >>> issubclass(type(42), object) 
+ True 
+```
+
+## Функции - это объекты слишком
+
+> В Python функции являются объектами первого класса.
+
+_Функции_ в Python также являются _объектами_ , созданными с _идентификатором_ , _типом_ и _значением_ . Они также могут быть переданы в другие _функции_ :
+
+```python
+>>> id(dir) 
+ 4568035688 
+ >>> type(dir) 
+ <class 'builtin_function_or_method'> 
+ >>> dir(dir) 
+ ['__call__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__text_signature__'] 
+ >>> issubclass(type(dir), object) 
+ True 
+```
+
+Также возможно связать функции с именем и вызвать связанную функцию, используя это имя:
+
+```python
+>>> a = dir 
+ >>> print(a) 
+ <built-in function dir> 
+ >>> a(a) 
+ ['__call__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__text_signature__'] 
+```
+
+Ресурсы:
+
+*   [Нажмите здесь,](https://www.jeffknupp.com/blog/2014/06/18/improve-your-python-python-classes-and-object-oriented-programming/) чтобы узнать больше.

guide/russian/python/data-structures/ranges/index.md

@@ -0,0 +1,87 @@
+---
+title: The Python Range
+localeTitle: Диапазон Python
+---
+## Диапазоны Python
+
+Вместо того, чтобы быть функцией, диапазон фактически является [неизменным типом последовательности](https://docs.python.org/3/library/stdtypes.html#immutable-sequence-types) и обычно используется для циклического цикла определенного цикла для циклов.
+
+**Создание:**
+
+`ranges` создаются с использованием конструктора `range` . Параметры для конструктора:
+
+*   `start` : Включить первое значение диапазона (необязательно целое, по умолчанию - 0).
+*   `stop` : Исключительное значение остановки, диапазон останавливается, когда это значение или больше будет предоставлено (требуется целое число).
+*   `step` : сумма добавлена ​​к текущему значению, чтобы получить следующее значение (необязательное целое, по умолчанию - 1).
+
+```python
+>>> range(10)          # Only the stop parameter is required. 
+ range(0, 10) 
+ >>> range(0, 10)       # Default for start parameter is 0. 
+ range(0, 10) 
+ >>> range(0, 10, 1)    # Default for step is 1\. Start parameter is required if 
+ step is needed. 
+ range(0, 10) 
+```
+
+**Примеры:**
+
+Поскольку `ranges` являются итерабельными, они могут быть переданы в конструкторы `list` и `tuple` для создания этих типов последовательностей. Используя этот факт, мы можем представить несколько примеров:
+
+```python
+>>> list(range(10))     # range as argument for list constructor. 
+ [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
+ >>> tuple(range(10))    # range as argument for tuple constructor. 
+ (0, 1, 2, 3, 4, 5, 6, 7, 8, 9) 
+```
+
+`ranges` нулевой длины:
+
+```python
+>>> list(range(10, 0))        # start greater than stop with postive step. 
+ [] 
+ >>> list(range(10, 10))       # start equal to stop with postive step. 
+ [] 
+ >>> list(range(10, 10, -1))   # start equal to stop with negative step. 
+ [] 
+ >>> list(range(0, 10, -1))    # start less than stop with negative step. 
+ [] 
+```
+
+`ranges` с шаговыми аргументами:
+
+```python
+>>> list(range(0, 10, 2))       # next value would be 10, stops at 8. 
+ [0, 2, 4, 6, 8] 
+ >>> list(range(0, 10, 3))       # next value would be 12, stops at 9. 
+ [0, 3, 6, 9] 
+ >>> list(range(0, 10, 4))       # next value would be 12, stops at 8. 
+ [0, 4, 8] 
+ >>> list(range(10, 0, -1))      # negative step makes decreasing ranges. 
+ [10, 9, 8, 7, 6, 5, 4, 3, 2, 1] 
+ >>> list(range(-5, -30, -3))    # negative integers are valid arguments. 
+ [-5, -8, -11, -14, -17, -20, -23, -26, -29] 
+```
+
+**Выгоды:**
+
+Преимущество использования `range` заключается в том, что независимо от того, насколько велика указанная область, для хранения `range` требуется только небольшой объем памяти, значения для начала, остановки и шага. Отдельные значения `ranges` рассчитываются на итерации.
+
+```python
+>>> import sys 
+ >>> a_range = range(1000000) 
+ >>> a_list = list(a_range) 
+ >>> a_tuple = tuple(a_range) 
+ >>> sys.getsizeof(a_range) 
+ 48 
+ >>> sys.getsizeof(a_list) 
+ 9000112 
+ >>> sys.getsizeof(a_tuple) 
+ 8000048 
+```
+
+### Больше информации:
+
+[Python Doc - Диапазоны](https://docs.python.org/3/library/stdtypes.html#ranges)
+
+**TODO: `ranges` методов выполняются и не реализуются**

guide/russian/python/data-structures/scopes/index.md

@@ -0,0 +1,13 @@
+---
+title: The Python Scopes
+localeTitle: Области Python
+---
+**TODO: ПРИМЕЧАНИЕ.**
+
+*   Это относится к кодовому блоку и информации о отступе.
+*   Это также связано с переменными, поскольку поиск и привязка имени связаны с областями.
+
+**TODO: СОДЕРЖАНИЕ**
+
+*   `global`
+*   `nonlocal`

guide/russian/python/data-structures/strings/index.md

@@ -0,0 +1,36 @@
+---
+title: The Python Strings
+localeTitle: Строки Python
+---
+Python позволяет `str` объектам или _строкам_ выражаться несколькими способами:
+
+*   Одиночные кавычки: `'Single quote strings can have "double" quotes inside.'`
+    
+*   Двойные кавычки: `"Double quote strings can have 'single' quotes inside."` двойными кавычками `"Double quote strings can have 'single' quotes inside."`
+    
+*   Тройной котировки:
+    
+    ```
+    """Triple quoted strings can span multiple lines. 
+     Unescaped "double" and 'single' quotes in triple quoted strings are retained.""" 
+     
+     '''Triple quoted strings can be 'single'or "double" quotes. 
+     Unescaped newlines are also retained.''' 
+    
+    ```
+    
+*   Неизменяемость: вы не можете напрямую редактировать / изменять строку Python после ее создания. Например, если вы попытаетесь напрямую переназначить / изменить первую букву в строке, возникает ошибка.
+    
+    ```
+    >>> foo = "my string" 
+     >>> foo[0] = "a" 
+     Traceback (most recent call last): 
+            File "<stdin>", line 1, in <module> 
+     TypeError: 'str' object does not support item assignment 
+    
+    ```
+    
+
+## Справка:
+
+[Тип текстовой последовательности _str_](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)

guide/russian/python/data-structures/tuples/index.md

@@ -0,0 +1,196 @@
+---
+title: The Tuples
+localeTitle: Кортежи
+---
+## Кортежи
+
+Кортеж представляет собой последовательность объектов Python. Кортежи неизменяемы, что означает, что они не могут быть изменены после создания, в отличие от списков.
+
+**Создание:**
+
+Пустой `tuple` создается с помощью пары круглых скобок `()` :
+
+```shell
+    >>> empty_tuple = () 
+    >>> print(empty_tuple) 
+    () 
+    >>> type(empty_tuple) 
+    <class 'tuple'> 
+    >>> len(empty_tuple) 
+    0 
+```
+
+`tuple` с элементами создается путем разделения элементов запятыми (окружающие круглые скобки, `()` , являются необязательными с исключениями):
+
+```shell
+    >>> tuple_1 = 1, 2, 3       # Create tuple without round brackets. 
+    >>> print(tuple_1) 
+    (1, 2, 3) 
+    >>> type(tuple_1) 
+    <class 'tuple'> 
+    >>> len(tuple_1) 
+    3 
+    >>> tuple_2 = (1, 2, 3)     # Create tuple with round brackets. 
+    >>> print(tuple_2) 
+    (1, 2, 3) 
+    >>> tuple_3 = 1, 2, 3,      # Trailing comma is optional. 
+    >>> print(tuple_3) 
+    (1, 2, 3) 
+    >>> tuple_4 = (1, 2, 3,)    # Trailing comma in round brackets is also optional. 
+    >>> print(tuple_4) 
+    (1, 2, 3) 
+```
+
+`tuple` с одним элементом должен иметь конечную запятую (с круглыми скобками или без них):
+
+```shell
+    >>> not_tuple = (2)    # No trailing comma makes this not a tuple. 
+    >>> print(not_tuple) 
+    2 
+    >>> type(not_tuple) 
+    <class 'int'> 
+    >>> a_tuple = (2,)     # Single element tuple. Requires trailing comma. 
+    >>> print(a_tuple) 
+    (2,) 
+    >>> type(a_tuple) 
+    <class 'tuple'> 
+    >>> len(a_tuple) 
+    1 
+    >>> also_tuple = 2,    # Round brackets omitted. Requires trailing comma. 
+    >>> print(also_tuple) 
+    (2,) 
+    >>> type(also_tuple) 
+    <class 'tuple'> 
+```
+
+Круглые скобки требуются в случаях двусмысленности (если кортеж является частью большего выражения):
+
+> Обратите внимание, что на самом деле это запятая, которая делает кортеж, а не круглые скобки. Скобки являются необязательными, за исключением случая пустого кортежа, или когда они необходимы, чтобы избежать синтаксической двусмысленности. Например, `f(a, b, c)` является вызовом функции с тремя аргументами, тогда как `f((a, b, c))` является вызовом функции с 3-кортежем в качестве единственного аргумента.
+
+```shell
+    >>> print(1,2,3,4,)          # Calls print with 4 arguments: 1, 2, 3, and 4 
+    1 2 3 4 
+    >>> print((1,2,3,4,))        # Calls print with 1 argument: (1, 2, 3, 4,) 
+    (1, 2, 3, 4) 
+    >>> 1, 2, 3 == (1, 2, 3)     # Equivalent to 1, 2, (3 == (1, 2, 3)) 
+    (1, 2, False) 
+    >>> (1, 2, 3) == (1, 2, 3)   # Use surrounding round brackets when ambiguous. 
+    True 
+```
+
+`tuple` также может быть создан с помощью конструктора `tuple` :
+
+```shell
+    >>> empty_tuple = tuple() 
+    >>> print(empty_tuple) 
+    () 
+    >>> tuple_from_list = tuple([1,2,3,4]) 
+    >>> print(tuple_from_list) 
+    (1, 2, 3, 4) 
+    >>> tuple_from_string = tuple("Hello campers!") 
+    >>> print(tuple_from_string) 
+    ('H', 'e', 'l', 'l', 'o', ' ', 'c', 'a', 'm', 'p', 'e', 'r', 's', '!') 
+    >>> a_tuple = 1, 2, 3 
+    >>> b_tuple = tuple(a_tuple)    # If the constructor is called with a tuple for 
+    the iterable, 
+    >>> a_tuple is b_tuple          # the tuple argument is returned. 
+    True 
+```
+
+**Доступ к элементам `tuple` :**
+
+Доступ к элементам `tuples` осуществляется и индексируется так же, как и `lists` .
+
+```shell
+    >>> my_tuple = 1, 2, 9, 16, 25 
+    >>> print(my_tuple) 
+    (1, 2, 9, 16, 25) 
+```
+
+_Нулевой индекс_
+
+```shell
+    >>> my_tuple[0] 
+    1 
+    >>> my_tuple[1] 
+    2 
+    >>> my_tuple[2] 
+    9 
+```
+
+_Обтекание индексации_
+
+```shell
+    >>> my_tuple[-1] 
+    25 
+    >>> my_tuple[-2] 
+    16 
+```
+
+**Упаковка и распаковка:**
+
+Утверждение `t = 12345, 54321, 'hello!'` пример упаковки кортежей: значения `12345` , `54321` и `'hello!'` упаковываются вместе в кортеж. Также возможна обратная операция:
+
+```shell
+    >>> x, y, z = t 
+```
+
+Это называется, достаточно подходящим образом, распаковка последовательности и работает для любой последовательности с правой стороны. Для распаковки последовательности требуется, чтобы в левой части знака равенства было столько же переменных, сколько элементов в последовательности. Обратите внимание, что множественное назначение - это всего лишь комбинация упаковки кортежей и распаковки последовательностей.
+
+```shell
+    >>> t = 1, 2, 3    # Tuple packing. 
+    >>> print(t) 
+    (1, 2, 3) 
+    >>> a, b, c = t    # Sequence unpacking. 
+    >>> print(a) 
+    1 
+    >>> print(b) 
+    2 
+    >>> print(c) 
+    3 
+    >>> d, e, f = 4, 5, 6    # Multiple assignment combines packing and unpacking. 
+    >>> print(d) 
+    4 
+    >>> print(e) 
+    5 
+    >>> print(f) 
+    6 
+    >>> a, b = 1, 2, 3       # Multiple assignment requires each variable (right) 
+    have a matching element (left). 
+    Traceback (most recent call last): 
+      File "<stdin>", line 1, in <module> 
+    ValueError: too many values to unpack (expected 2) 
+```
+
+**Неизменный:**
+
+`tuples` являются неизменяемыми контейнерами, гарантируя, **что** объекты, **которые** они содержат, не изменятся. Это **не** гарантирует, что объекты, которые они содержат, не изменятся:
+
+```shell
+    >>> a_list = [] 
+    >>> a_tuple = (a_list,)    # A tuple (immutable) with a list (mutable) element. 
+    >>> print(a_tuple) 
+    ([],) 
+ 
+    >>> a_list.append("Hello campers!") 
+    >>> print(a_tuple)         # Element of the immutable is mutated. 
+    (['Hello campers!'],) 
+```
+
+Область **применения:**
+
+Функции могут возвращать только одно значение, однако гетерогенный `tuple` может использоваться для возврата нескольких значений из функции. Одним из примеров является встроенная функция `enumerate` которая возвращает итерабельность гетерогенных `tuples` :
+
+```shell
+    >>> greeting = ["Hello", "campers!"] 
+    >>> enumerator = enumerate(greeting) 
+    >>> enumerator.next() 
+    >>> enumerator.__next__() 
+    (0, 'Hello') 
+    >>> enumerator.__next__() 
+    (1, 'campers!') 
+```
+
+### Больше информации:
+
+[Документы Python - кортежи](https://docs.python.org/3/library/stdtypes.html#tuples)