gaspersic/freeCodeCamp
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

fix(guide): simplify directory structure

Browse Source
This commit is contained in:
Mrugesh Mohapatra
2018-10-16 21:26:13 +05:30
parent f989c28c52
commit da0df12ab7
35752 changed files with 0 additions and 317652 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
guide/russian/python/abs-function/index.md Normal file
View File

@@ -0,0 +1,29 @@
---
title: Python Abs Function
localeTitle: Функция Python Abs
---
`abs()` является встроенной функцией в Python 3, чтобы вычислить абсолютное значение любого числа. Абсолютное значение числа "означает только, как далеко число от 0" 1 Требуется один аргумент `x` . Аргумент может быть даже [сложным числом](https://docs.python.org/3.0/library/cmath.html) , и в этом случае возвращается его [модуль](http://www.mathcentre.ac.uk/resources/sigma%20complex%20number%20leaflets/sigma-complex9-2009-1.pdf) .
## аргументация
Он принимает один аргумент `x` - целое, десятичное или комплексное число.
## Возвращаемое значение
Возвращаемое значение будет положительным. Даже если комплексное число будет передано, оно вернет свою величину, рассчитанную как алгебра с комплексным числом.
## Образец кода
```python
print(abs(3.4)) # prints 3.4
print(abs(-6)) # prints 6
print(abs(3 + 4j)) # prints 5, because |3 + 4j| = 5
```
[🚀 Код запуска](https://repl.it/CL8k/0)
[Официальные документы](https://docs.python.org/3/library/functions.html#abs)
### источники
1. [Математика - это весело. Доступ: 25 октября 2017 г.](https://www.mathsisfun.com/numbers/absolute-value.html)

43
guide/russian/python/all-iterable/index.md Normal file
View File

@@ -0,0 +1,43 @@
---
title: Python All Iterable
localeTitle: Python All Iterable
---
`all()` является встроенной функцией в Python 3 (и Python 2 начиная с версии 2.5), чтобы проверить, являются ли все элементы [_итерабельны_](https://docs.python.org/3/glossary.html#term-iterable) `True` . Он принимает один аргумент, `iterable` .
## аргументация
### итерируемый
`iterable` аргумент - это коллекция, чьи записи должны быть проверены. Это может быть `list` , `str` , `dict` , `tuple` и т. Д.
## Возвращаемое значение
Возвращаемое значение является логическим. Если и только если **все** записи `iterable` [правдивы](https://guide.freecodecamp.org/python/truth-value-testing) , он возвращает `True` . Эта функция по существу выполняет логическую операцию `AND` по всем элементам.
Если даже один из них не является правдивым, он возвращает `False` .
Операция `all()` эквивалентна (не внутренне реализована точно так же)
```
def all(iterable):
for element in iterable:
if not element:
return False
return True
```
## Образец кода
```
print(all([])) #=> True # Because an empty iterable has no non-truthy elements
print(all([6, 7])) #=> True
print(all([6, 7, None])) #=> False # Because it has None
print(all([0, 6, 7])) #=> False # Because it has zero
print(all([9, 8, [1, 2]])) #=> True
print(all([9, 8, []])) #=> False # Because it has []
print(all([9, 8, [1, 2, []]])) #=> True
print(all([9, 8, {}])) #=> False # Because it has {}
print(all([9, 8, {'engine': 'Gcloud'}])) #=> True
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CL9U/0)
[Официальные документы](https://docs.python.org/3/library/functions.html#all)

27
guide/russian/python/anaconda/index.md Normal file
View File

@@ -0,0 +1,27 @@
---
title: Anaconda
localeTitle: анаконда
---
**Anaconda** - это менеджер пакетов, менеджер среды и дистрибутив Python с набором многочисленных пакетов. Anaconda является платформенным агностиком, поэтому вы можете использовать его независимо от того, находитесь ли вы в Windows, macOS или Linux. Anaconda легко создает, сохраняет, загружает и переключает между средами на вашем локальном компьютере. Он был создан для программ Python, но он может упаковывать и распространять программное обеспечение для любого языка. Anaconda как менеджер пакетов помогает вам находить и устанавливать пакеты. Если вам нужен пакет, для которого требуется другая версия Python, вам не нужно переключаться на другой менеджер среды, потому что Anaconda также является менеджером среды. С помощью всего нескольких команд вы можете настроить совершенно отдельную среду для запуска этой другой версии Python, продолжая при этом запускать обычную версию Python в своей обычной среде.
## обзор
Самый быстрый способ начать использовать конду - пройти через 20 минут [Начало работы с](https://conda.io/docs/user-guide/getting-started.html) гидом [конды](https://conda.io/docs/user-guide/getting-started.html) .
Команда `conda` является основным интерфейсом для управления установки различных упаковок. Оно может:
* Запросить и найти индекс пакета Anaconda и текущий Установка Anaconda.
* Создайте новые среды conda.
* Установите и обновите пакеты в существующие среды conda.
СОВЕТ. Вы можете сокращать многие часто используемые параметры команд, которые предшествуют две тире ( `--` ) до 1 тире и первая письмо варианта. So `--name` и `-n` - то же самое, и `--envs` и `-e` - то же самое.
Для полного использования каждой команды, включая аббревиатуры, см. [Ссылка на команду](https://conda.io/docs/commands.html) .
### источники
1. [Документация Anaconda](https://docs.anaconda.com/)
2. [Документация Conda](https://conda.io/docs/)

42
guide/russian/python/any-iterable/index.md Normal file
View File

@@ -0,0 +1,42 @@
---
title: Python Any Iterable
localeTitle: Python Any Iterable
---
`any()` является встроенной функцией в Python 3 (и Python 2 начиная с версии 2.5), чтобы проверить, является ли какой-либо из элементов [_итерабельного_](https://docs.python.org/3/glossary.html#term-iterable) `True` . Он принимает один аргумент, `iterable` .
## аргументация
### итерируемый
`iterable` аргумент - это коллекция, чьи записи должны быть проверены. Обычно это `list` , `str` , `dict` , `tuple` и т. Д., Даже `file object` .
## Возвращаемое значение
Возвращаемое значение является логическим. В том и только том случае, если **все** записи итерабельны `False` , или `iterable` пуста; он возвращает `False` . Эта функция по существу выполняет логическую операцию `OR` по всем элементам.
Если даже один из них `True` , он возвращает `True` .
Операция `any()` эквивалентна (внутренне, не может быть реализована точно так же)
```
def any(iterable):
for element in iterable:
if element:
return True
return False
```
## Образец кода
```
print(any([])) #=> False
print(any({})) #=> False
print(any([None])) #=> False
print(any(['', {}, 0])) #=> False
print(any([6, 7])) #=> True
print(any([6, 7, None])) #=> True
print(any([0, 6, 7])) #=> True
print(any([9, 8, [1, 2]])) #=> True
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CL9c/0)
[Официальные документы](https://docs.python.org/3/library/functions.html#any)

47
guide/russian/python/args-variable/index.md Normal file
View File

@@ -0,0 +1,47 @@
---
title: Relationships between * and args
localeTitle: Отношения между * и args
---
## Наличие функции \* в определении функции
```Python
# How does *args work in a function definition
def hardFunc(arg1, arg2):
# create a tuple and pollute it with arguments passed to hardFunc
args=(arg1, arg2)
# print out results
print(args[0])
print(args[1])
hardFunc('hard_one', 'hard_two')
# output — Try it yourself now and in sequential snippets!
def softFunc(*args):
# at this point after calling softFunc a tuple with a name of a word
# followed by * is created automatically (in this case the name is args)
# print out results
print(args[0])
print(args[1])
softFunc('soft_one', 'soft_two')
# Now try to do something illegal
hardFunc('one', 'two', 'three')
# Now do things legally
softFunc('one', 'two', 'three')
# or even
softFunc('one', 'two', 'three', 'infinity')
# softFunc handles arbitrary amount of arguments easily by virtue of * syntax
# So using a single variable name in conjuction with * we gained the ability
# to invoke a function with arbitrary amount of arguments.
# Once again when softFunc is called the newly args
# tuple filled with provided arguments is created
# Conclusion softFunc is a more flexible/dynamic verson of a hardFunc
```

328
guide/russian/python/basic-operators/index.md Normal file
View File

@@ -0,0 +1,328 @@
---
title: Basic Operators
localeTitle: Основные операторы
---
## Основные операторы
Операторы - это символы, которые говорят интерпретатору выполнять определенную операцию (арифметику, сравнение, логику и т. Д.),
Ниже перечислены различные типы операторов в Python:
1. Арифметические операторы
2. Реляционные операторы
3. Побитовые операторы
4. Операторы присваивания
5. Логические операторы
6. Операторы членства
7. Операторы идентификации
#### Арифметические операторы
Арифметический оператор принимает два операнда в качестве входных данных, выполняет вычисление и возвращает результат.
Рассмотрим выражение **«a = 2 + 3»** . Здесь `2` и `3` - _операнды,_ а `+` - _арифметический оператор_ . Результат операции хранится в переменной a.
оператор
Описание
использование
+
Выполняет добавление в операндах
12 + 3 = 15
\-
Выполняет вычитание на операндах. Вычитает правый операнд из левого операнда
12 - 3 = 9
\*
Выполняет умножение на операнды
12 \* 3 = 36
/
Выполняет разделение на операнды. Делит левый операнд на правый операнд
12/3 = 4
Примечание. Когда используются два целых числа, результат отличается между Python 2 и Python 3.
5/2 = 2 в Python 2
5/2 = 2,5 в Python 3
%
Выполняет модуль для операндов. Возвращает остаток, полученный при делении левого операнда на правый операнд
16% 3 = 1
\*\*
Выполняет операцию экспонирования. Левый операнд поднят до степени правильного операнда
12 \*\* 3 = 1728
//
Выполняет операцию разделения пола. Возвращает интегральную часть частного, полученную после погружения левого операнда в правый операнд
18 // 5 = 3
Примечание. Чтобы получить результат в плавающем типе, один из операндов должен также иметь тип float.
#### Реляционные операторы
Для сравнения двух операндов используется реляционный оператор для определения отношения между ними. Он возвращает логическое значение, основанное на условии.
оператор
Описание
использование
\>
Возвращает True, если левый операнд больше, чем правый операнд Возвращает False в противном случае
12> 3 возвращает True
<
Возвращает True, если правый операнд больше, чем левый операнд Возвращает False в противном случае
12 <3 возвращает False
\==
Возвращает True, если оба операнда равны Возвращает False в противном случае
12 == 3 возвращает False
\> =
Возвращает True, если левый операнд больше или равен правильному операнду Возвращает False в противном случае
12> = 3 возвращает True
<=
Возвращает True, если правый операнд больше или равен левому операнду Возвращает False в противном случае
12 <= 3 возвращает False
знак равно
Возвращает True, если оба операнда не равны Возвращает False в противном случае
12! = 3 возвращает True
#### Побитовые операторы
Побитовый оператор выполняет операции по операндам по битам
Рассмотрим a = 2 (в двоичной нотации, 10) и b = 3 (в двоичной нотации, 11) для нижеследующих применений
оператор
Описание
использование
&
Выполняет побитовое И операцию над операндами
a & b = 2 Двоичный: 10 & 11 = 10
|
Выполняет побитовое ИЛИ операцию над операндами
a | b = 3 Двоичный: 10 | 11 = 11
^
Выполняет побитовое XOR-операцию над операндами
a ^ b = 1 Двоичный: 10 ^ 11 = 01
~
Выполняет побитовое НЕ операции над операндом Перемещает каждый бит в операнд
~ a = -3 Двоичный: ~ (00000010) = (11111101)
\>>
Выполняет побитовое смещение вправо. Сдвигает биты левого операнда, прямо на количество бит, указанное в качестве правильного операнда
a >> b = 0 Двоичный: 00000010 >> 00000011 = 0
<<
Выполняет побитовый сдвиг влево. Сдвигает биты левого операнда, оставшиеся от количества бит, заданных в качестве правильного операнда
a << b = 16 Двоичный: 00000010 << 00000011 = 00001000
#### Операторы присваивания
Оператор присваивания используется для назначения значений переменной. Обычно это объединяется с другими операторами (такими как арифметические, побитовые), где операция выполняется над операндами, а результат присваивается левому операнду.
Рассмотрим следующие примеры, **a = 18** . Здесь `=` - оператор присваивания, и результат сохраняется в переменной a. **a + = 10** . Здесь `+=` - оператор присваивания, и результат сохраняется в переменной a. Это то же самое, что и a = a + 10.
оператор
использование
знак равно
a = 5. Значение 5 присваивается переменной a
\+ =
a + = 5 эквивалентно a = a + 5
знак равно
а = 5 эквивалентно а = а - 5
знак равно
а \* = 3 эквивалентно а = а \* 3
знак равно
a / = 3 эквивалентно a = a / 3
знак равно
a% = 3 эквивалентно a = a% 3
знак равно
a \*\* = 3 эквивалентно a = a \*\* 3
знак равно
a // = 3 эквивалентно a = a // 3
знак равно
a = 3 эквивалентно a = a & 3
| =
a | = 3 эквивалентно a = a | 3
^ =
а ^ = 3 эквивалентно а = а ^ 3
\>> =
a >> = 3 эквивалентно a = a >> 3
<< =
a << = 3 эквивалентно a = a << 3
#### Логические операторы
Логический оператор используется для принятия решения на основе нескольких условий. Логические операторы, используемые в Python, `and` , `or` и `not`
оператор
Описание
использование
а также
Возвращает True, если оба операнда True Возвращает False в противном случае
a и b
или
Возвращает True, если любой из операндов True Возвращает False в противном случае
a или b
не
Возвращает True, если операнд False Возвращает False в противном случае
не
#### Операторы членства
Оператор членства используется для идентификации членства в любой последовательности (списки, строки, кортежи). `in` а `not in` операторы членства
`in` возвращает True, если указанное значение найдено в последовательности. Возвращает False в противном случае. `not in` возвращает True, если указанное значение не найдено в последовательности. Возвращает False в противном случае.
###### Пример использования
```py
a = [1,2,3,4,5]
#Is 3 in the list a?
print 3 in a # prints True
#Is 12 not in list a?
print 12 not in a # prints True
str = "Hello World"
#Does the string str contain World?
print "World" in str # prints True
#Does the string str contain world? (note: case sensitive)
print "world" in str # prints False
print "code" not in str # prints True
```
#### Операторы идентификации
Оператор идентификации используется для проверки того, имеют ли две переменные одинаковое расположение памяти. `is` и `is not` есть операторы тождества
`is` возвращает Истина , если операнды относятся к одному объекту. Возвращает False в противном случае. `is not` возвращает True, если операнды не относятся к одному и тому же объекту. Возвращает False в противном случае.
Обратите внимание, что два значения, когда они равны, не обязательно должны совпадать.
###### Пример использования
```py
a = 3
b = 3
c = 4
print a is b # prints True
print a is not b # prints False
print a is not c # prints True
x = 1
y = x
z = y
print z is 1 # prints True
print z is x # prints True
str1 = "FreeCodeCamp"
str2 = "FreeCodeCamp"
print str1 is str2 # prints True
print "Code" is str2 # prints False
a = [10,20,30]
b = [10,20,30]
print a is b # prints False (since lists are mutable in Python)
```

32
guide/russian/python/bool-function/index.md Normal file
View File

@@ -0,0 +1,32 @@
---
title: Python Bool Function
localeTitle: Функция Python Bool
---
`bool()` - встроенная функция в Python 3. Эта функция возвращает логическое значение, то есть True или False. Он принимает один аргумент, `x` .
## аргументы
Он принимает один аргумент, `x` . `x` преобразуется с использованием стандартной [процедуры тестирования прав](https://docs.python.org/3/library/stdtypes.html#truth) .
## Возвращаемое значение
Если `x` является ложным или опускается, это возвращает `False` ; иначе он вернет `True` .
## Образец кода
```
print(bool(4 > 2)) # Returns True as 4 is greater than 2
print(bool(4 < 2)) # Returns False as 4 is not less than 2
print(bool(4 == 4)) # Returns True as 4 is equal to 4
print(bool(4 != 4)) # Returns False as 4 is equal to 4 so inequality doesn't holds
print(bool(4)) # Returns True as 4 is a non-zero value
print(bool(-4)) # Returns True as -4 is a non-zero value
print(bool(0)) # Returns False as it is a zero value
print(bool('dskl')) # Returns True as the string is a non-zero value
print(bool([1, 2, 3])) # Returns True as the list is a non-zero value
print(bool((2,3,4))) # Returns True as tuple is a non-zero value
print(bool([])) # Returns False as list is empty and equal to 0 according to truth value testing
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CVCS/2)
[Официальные документы](https://docs.python.org/3/library/functions.html#bool)

52
guide/russian/python/boolean-operations/index.md Normal file
View File

@@ -0,0 +1,52 @@
---
title: Python Boolean Operations
localeTitle: Булевы операции на Python
---
[`and`](https://docs.python.org/3/reference/expressions.html#and) , [`or`](https://docs.python.org/3/reference/expressions.html#or) , [`not`](https://docs.python.org/3/reference/expressions.html#not)
[Документы Python - логические операции](https://docs.python.org/3/library/stdtypes.html#boolean-operations-and-or-not)
Это булевские операции, упорядоченные по приоритету приоритета:
Операция | Результат | Заметки
\--------- | ------------------------------------ | -----
x или y | если x ложно, то y, else x | (1)
x и y | если x ложно, то x, else y | (2)
не x | если x является ложным, то True, else False | (3)
**Заметки:**
1. Это оператор короткого замыкания, поэтому он оценивает только второй аргумент, если первый - False.
2. Это оператор короткого замыкания, поэтому он вычисляет только второй аргумент, если первый имеет значение True.
3. не имеет более низкого приоритета, чем небулевые операторы, поэтому не == b интерпретируется как нет (a == b), а a == not b является синтаксической ошибкой.
## Примеры:
### `not` :
```
>>> not True
False
>>> not False
True
```
### `and` :
```
>>> True and False # Short-circuited at first argument.
False
>>> False and True # Second argument is evaluated.
False
>>> True and True # Second argument is evaluated.
True
```
### `or` :
```
>>> True or False # Short-circuited at first argument.
True
>>> False or True # Second argument is evaluated.
True
>>> False or False # Second argument is evaluated.
False
```

30
guide/russian/python/built-in-constants/index.md Normal file
View File

@@ -0,0 +1,30 @@
---
title: Python Built in Constants
localeTitle: Встроенные константы Python
---
[Константы](https://docs.python.org/3/library/constants.html)
Три часто используемых встроенных константы:
* `True` : истинное значение типа _bool_ . Присвоения `True` поднимают _SyntaxError_ .
* `False` : ложное значение типа _bool_ . Присвоения для `False` повышают значение _SyntaxError_ .
* `None` : Единственное значение типа _NoneType_ . Ни один из них не используется для представления отсутствия значения, так как аргументы по умолчанию не передаются функции. Отчисления в `None` поднять _SyntaxError._
Другие встроенные константы:
* `NotImplemented` : специальное значение, которое должно быть возвращено двоичными специальными методами, такими как `__eg__()` , `__add__()` , `__rsub__()` и т. Д.), Чтобы указать, что операция не реализована по отношению к другому типу.
* `Ellipsis` : особое значение используется в основном в сочетании с расширенным синтаксисом среза для пользовательских типов данных контейнера.
* `__debug__` : True, если Python не был запущен с опцией -o.
Константы, добавленные модулем сайта Модуль сайта (который автоматически импортируется во время запуска, за исключением случаев, когда задана опция командной строки -S) добавляет несколько констант во встроенное пространство имен. Они полезны для оболочки интерактивного интерпретатора и не должны использоваться в программах.
Объекты, которые при печати печатают сообщение типа «Использовать quit () или Ctrl-D (т.е. EOF) для выхода», и при вызове поднять SystemExit с указанным кодом выхода:
* (Код = нет) бросить курить
* Выход (код = нет)
Объекты, которые при печати печатают сообщение типа «Тип лицензии (), чтобы увидеть полный текст лицензии», а при вызове отображает соответствующий текст в виде пейджера (по одному экрану за раз):
* Авторские права
* лицензия
* кредиты

53
guide/russian/python/calling-functions/index.md Normal file
View File

@@ -0,0 +1,53 @@
---
title: Python Calling Functions
localeTitle: Функции вызова Python
---
Оператор определения функции не выполняет функцию. Выполнение (вызов) функции выполняется с использованием имени функции, за которым следует скобка, в которой содержатся необходимые аргументы (если есть).
```
>>> def say_hello():
... print('Hello')
...
>>> say_hello()
Hello
```
Выполнение функции представляет новую таблицу символов, используемую для локальных переменных функции. Точнее, все присваивания переменных в функции сохраняют значение в таблице локальных символов; в то время как ссылки на переменные сначала рассматриваются в таблице локальных символов, затем в таблицах локальных символов охватывающих функций, затем в глобальной таблице символов и, наконец, в таблице встроенных имен. Таким образом, глобальные переменные не могут быть напрямую назначены значения внутри функции (если не указано в глобальном заявлении), хотя на них можно ссылаться.
```
>>> a = 1
>>> b = 10
>>> def fn():
... print(a) # local a is not assigned, no enclosing function, global a referenced.
... b = 20 # local b is assigned in the local symbol table for the function.
... print(b) # local b is referenced.
...
>>> fn()
1
20
>>> b # global b is not changed by the function call.
10
```
Фактические параметры (аргументы) для вызова функции вводятся в локальную таблицу символов вызываемой функции при ее вызове; таким образом, аргументы передаются с использованием вызова по значению (где значение всегда является ссылкой на объект, а не значением объекта). Когда функция вызывает другую функцию, для этого вызова создается новая таблица локальных символов.
```
>>> def greet(s):
... s = "Hello " + s # s in local symbol table is reassigned.
... print(s)
...
>>> person = "Bob"
>>> greet(person)
Hello Bob
>>> person # person used to call remains bound to original object, 'Bob'.
'Bob'
```
Аргументы, используемые для вызова функции, не могут быть переназначены функцией, но аргументы, которые ссылаются на изменяемые объекты, могут изменить их значения:
```
>>> def fn(arg):
... arg.append(1)
...
>>> a = [1, 2, 3]
>>> fn(a)
>>> a
[1, 2, 3, 1]
```

71
guide/russian/python/class/index.md Normal file
View File

@@ -0,0 +1,71 @@
---
title: Class
localeTitle: Класс
---
## Класс
Классы обеспечивают возможность объединения данных и функциональных возможностей вместе. Создание нового класса создает новый тип объекта, позволяя создавать новые экземпляры этого типа. Каждый экземпляр класса может иметь прикрепленные к нему атрибуты для поддержания его состояния. У экземпляров класса также могут быть методы (определенные его классом) для изменения его состояния.
По сравнению с другими языками программирования, механизм класса Python добавляет классы с минимумом новый синтаксис и семантика. Это смесь классовых механизмов, найденных в C ++. Классы Python предоставляют все стандартные функции объектно-ориентированного программирования: механизм наследования класса допускает множество базовых классов, производный класс может переопределять любые методы своего базового класса или классов, и метод может вызвать метод базового класса с тем же именем. Объекты могут содержать произвольные суммы и виды данных. Как и для модулей, классы участвуют в динамическом характере Python: они создаются во время выполнения и могут быть изменены после создания.
#### Синтаксис определения класса:
Простейшая форма определения класса выглядит следующим образом:
```python
class ClassName:
<statement-1>
...
...
...
<statement-N>
```
#### Class Objects:
Class objects support two kinds of operations: attribute references and instantiation.
Attribute references use the standard syntax used for all attribute references in Python: `obj.name`.
Valid attribute names are all the names that were in the class's namespace when the class object was created.
So, if the class definition looked like this:
```
питон класс MyClass: «" Простой примерный класс "" " i = 12345
```
def f(self):
return 'hello world'
```
```
Then `MyClass.i` and `MyClass.f` are valid attribute references, returning an integer and a function object, respectively.
Class attributes can also be assigned to, so you can change the value of `MyClass.i` by assignment. `__doc__` is also a valid attribute, returning the docstring belonging to the class: `"A simple example class"`.
Class instantiation uses function notation. Just pretend that the class object is a parameterless function that returns a new instance of the class. For example (assuming the above class):
```
питон x = MyClass ()
```
Creates a new instance of the class and assigns this object to the local variable x.
The instantiation operation (“calling” a class object) creates an empty object.
Many classes like to create objects with instances customized to a specific initial state.
Therefore a class may define a special method named __init__(), like this:
```
питон def **init** (self): self.data = \[\]
```
When a class defines an `__init__()` method, class instantiation automatically invokes `__init__()` for the newly-created class instance.
So in this example, a new, initialized instance can be obtained by:
```
питон x = MyClass ()
```
Of course, the `__init__()` method may have arguments for greater flexibility.
In that case, arguments given to the class instantiation operator are passed on to `__init__()`. For example,
```
питон класс: def **init** (self, realpart, imagpart): self.r = фактическая часть self.i = imagpart ...
x = комплекс (3,0, -4,5)
> > > xr, xi (3,0, -4,5) \`\` \`

48
guide/russian/python/code-blocks-and-indentation/index.md Normal file
View File

@@ -0,0 +1,48 @@
---
title: Python Code Blocks and Indentation
localeTitle: Блоки и отступы кода Python
---
Как правило, вам не следует смешивать вкладки и пробелы при кодировании в Python. Это может привести к `TabError` , и ваша программа выйдет из `TabError` . Будьте последовательны при кодировании - выберите либо отступ, используя вкладки или пробелы, и следуйте выбранному вами соглашению в своей программе.
#### Блоки кода и отступы
Одной из самых отличительных особенностей Python является использование отступов для маркировки блоков кода. Рассмотрим инструкцию if из нашей простой программы проверки пароля:
\`\` \`python если pwd == 'apple': print («Вход в систему ...») еще: print («Неверный пароль»).
print («Все сделано!»)
```
The lines print('Logging on ...') and print('Incorrect password.') are two separate code blocks. These ones happen to be only a single line long, but Python lets you write code blocks consisting of any number of statements.
To indicate a block of code in Python, you must indent each line of the block by the same amount. The two blocks of code in our example if-statement are both indented four spaces, which is a typical amount of indentation for Python.
In most other programming languages, indentation is used only to help make the code look pretty. But in Python, it is required for indicating what block of code a statement belongs to. For instance, the final print('All done!') is not indented, and so is not part of the else-block.
Programmers familiar with other languages often bristle at the thought that indentation matters: Many programmers like the freedom to format their code how they please. However, Python indentation rules are quite simple, and most programmers already use indentation to make their code readable. Python simply takes this idea one step further and gives meaning to the indentation.
#### If/elif-statements
An if/elif-statement is a generalized if-statement with more than one condition. It is used for making complex decisions. For example, suppose an airline has the following “child” ticket rates: Kids 2 years old or younger fly for free, kids older than 2 but younger than 13 pay a discounted child fare, and anyone 13 years or older pays a regular adult fare. The following program determines how much a passenger should pay:
```
питон
# airfare.py
age = int (ввод («Сколько вам лет?»)) если возраст <= 2: печать («бесплатно») elif 2 <возраст <13: печать («детский тариф») еще: печать («взрослый тариф»)
```
After Python gets age from the user, it enters the if/elif-statement and checks each condition one after the other in the order they are given. So first it checks if age is less than 2, and if so, it indicates that the flying is free and jumps out of the elif-condition. If age is not less than 2, then it checks the next elif-condition to see if age is between 2 and 13. If so, it prints the appropriate message and jumps out of the if/elif-statement. If neither the if-condition nor the elif-condition is True, then it executes the code in the else-block.
#### Conditional expressions
Python has one more logical operator that some programmers like (and some don't!). It's essentially a shorthand notation for if-statements that can be used directly within expressions. Consider this code:
```
питон food = input («Какая ваша любимая еда?») ответ = 'yuck', если пища == 'lamb' else 'yum'
```
The expression on the right-hand side of = in the second line is called a conditional expression, and it evaluates to either 'yuck' or 'yum'. It's equivalent to the following:
```
питон food = input («Какая ваша любимая еда?») если пища == 'ягненок': ответить = 'yuck' еще: ответить = 'yum' \`\` \`
Условные выражения обычно короче соответствующих if / else-операторов, хотя и не столь гибкие или легко читаемые. В общем, вы должны использовать их, когда они упрощают ваш код.
[Документация Python - отступы](https://docs.python.org/3/reference/lexical_analysis.html#indentation)

38
guide/russian/python/commenting-code/index.md Normal file
View File

@@ -0,0 +1,38 @@
---
title: Python Commenting Code
localeTitle: Код комментария Python
---
Комментарии используются для комментирования, описания или объяснения кода, который является сложным или трудным для понимания. Python намеренно игнорирует комментарии при компиляции с помощью байт-кода интерпретатором. [`PEP 8`](https://www.python.org/dev/peps/pep-0008/#comments) имеет раздел, посвященный комментариям. Они также повышают удобочитаемость кода, добавляя легкий и описательный язык для лучшего понимания.
**Заблокированные** и **встроенные** комментарии начинаются с символа `#` , за которым следует пробел перед комментарием:
```python
# This is a block comment.
print('Hello world!') # This is an inline commment.
```
Python не включает формальный способ написания многострочных комментариев. Каждая строка комментария, охватывающая несколько строк, должна начинаться с `#` и пробела:
```python
# This is the first line of a multiline comment.
# This is the second line.
```
Другим типом комментариев является **docstring** , задокументированная в [`PEP 257`](https://www.python.org/dev/peps/pep-0257/) . Docstrings - это особый тип комментария, который становится атрибутом `__doc__` .
Чтобы строковый литерал являлся docstring, он должен начинаться и заканчиваться символом `\"\"\"` и быть первым выражением определения модуля, функции, класса или метода, которое он документирует:
```python
class SomeClass():
"""Summary line for SomeClass.
More elaborate descriptions may require using a
a multiline docstring.
"""
def method_a(self):
"""Single line summary of method_a."""
pass
```
Строковые литералы, которые начинаются и заканчиваются на `"""` , которые не являются docstrings (не первый оператор), могут использоваться для многострочных строк. Они не станут атрибутами `__doc__` . Если они не назначены переменной, они не будут генерировать байт-код. Существует некоторая дискуссия об использовании их в виде многострочных комментариев, найденных [здесь](http://stackoverflow.com/questions/7696924/multiline-comments-in-python) .

84
guide/russian/python/comparisons/index.md Normal file
View File

@@ -0,0 +1,84 @@
---
title: Python Comparisons
localeTitle: Сравнение Python
---
[Документы Python - Сравнение](https://docs.python.org/3/library/stdtypes.html#comparisons)
В Python имеется восемь операций сравнения. Все они имеют одинаковый приоритет (что выше, чем у булевых операций). Сравнения могут быть скованы произвольно; например, `x < y <= z` эквивалентно `x < y and y <= z` , за исключением того, что `y` оценивается только один раз (но в обоих случаях `z` вообще не оценивается, когда `x < y` оказывается ложным).
В этой таблице приведены операции сравнения:
Операция | Имея в виду
\--------- | -----------------------
`<` | строго меньше
`<=` | меньше или равно `>` | строго больше, чем `>=` | больше или равно `==` | равно `!=` | не равный `is` | идентификатор объекта
`is not` | отрицательный идентификатор объекта
Объекты разных типов, кроме разных числовых типов, никогда не сравниваются с равными. Кроме того, некоторые типы (например, объекты функций) поддерживают только вырожденное понятие сравнения, где любые два объекта такого типа неравны. Операторы `<` , `<=` , `>` и `>=` будут вызывать исключение `TypeError` при сравнении сложного числа с другим встроенным числовым типом, когда объекты имеют разные типы, которые нельзя сравнивать, или в других случаях, когда нет определенных упорядоченность.
`__eq__()` экземпляры класса обычно сравниваются как не равные, если класс не определяет метод `__eq__()` .
Экземпляры класса не могут быть упорядочены относительно других экземпляров одного и того же класса или других типов объектов, если только класс не определяет достаточно методов `__lt__()` , `__le__()` , `__gt__()` и `__ge__()` (в общем случае , `__lt__()` и `__eq__()` достаточны, если вы хотите использовать обычные значения операторов сравнения).
Поведение `is` и `is not` операторы не могут быть настроены; также они могут применяться к любым двум объектам и никогда не создавать исключение.
Мы также можем связать операторы `<` и `>` . Например, `3 < 4 < 5` вернет `True` , но `3 < 4 > 5` не будет. Мы также можем связать оператор равенства. Например, `3 == 3 < 5` вернет `True` но `3 == 5 < 5` не будет.
### Сравнение равенств - "is" vs "=="
В Python есть два оператора сравнения, которые позволяют нам проверить, равны ли два объекта. Оператор `is` оператор `==` . Однако есть ключевое различие между ними!
Ключевое различие между «is» и «==» можно суммировать как:
* `is` используется для сравнения **идентичности**
* `==` используется для сравнения **равенства**
## пример
Сначала создайте список в Python.
```python
myListA = [1,2,3]
```
Затем создайте копию этого списка.
```python
myListB = myListA
```
Если мы используем оператор '==' или оператор 'is', оба будут иметь выход **True** .
```python
>>> myListA == myListB # both lists contains similar elements
True
>>> myListB is myListA # myListB contains the same elements
True
```
Это связано с тем, что myListA и myListB указывают на ту же переменную списка, которую я определил в начале моей программы Python. Оба списка точно такие же, как в личном, так и в контенте.
Однако, что, если я сейчас создам новый список?
```python
myListC = [1,2,3]
```
Выполнение оператора `==` все еще показывает, что оба списка одинаковы с точки зрения контента.
```python
>>> myListA == myListC
True
```
Однако выполнение оператора `is` теперь приведет к выходу `False` . Это связано с тем, что myListA и myListC представляют собой две разные переменные, несмотря на то, что они содержат одни и те же данные. Хотя они выглядят одинаково, они **разные** .
```python
>>> myListA is myListC
False # both lists have different reference
```
Подводить итоги:
* An `is` выражение выводит `True` если обе переменные указывают на одну и ту же ссылку
* Выражение `==` выводит значение `True` если обе переменные содержат одни и те же данные

62
guide/russian/python/complex-numbers/index.md Normal file
View File

@@ -0,0 +1,62 @@
---
title: Python Complex Numbers
localeTitle: Комплексные числа Python
---
Сложные числа имеют вещественную и мнимую часть, каждая из которых представлена ​​числом с плавающей запятой.
Мнимая часть комплексного числа может быть создана с использованием воображаемого литерала, это приводит к комплексному числу с вещественной частью `0.0` :
```python
>>> a = 3.5j
>>> type(a)
<class 'complex'>
>>> print(a)
3.5j
>>> a.real
0.0
>>> a.imag
3.5
```
Нет литерала для создания сложного числа с ненулевой вещественной и мнимой частями. Чтобы создать ненулевое комплексное число действительной части, добавьте воображаемый литерал к числу с плавающей запятой:
```python
>>> a = 1.1 + 3.5j
>>> type(a)
<class 'complex'>
>>> print(a)
(1.1+3.5j)
>>> a.real
1.1
>>> a.imag
3.5
```
Или используйте [сложный конструктор](https://docs.python.org/3/library/functions.html#complex) .
```python
class complex([real[, imag]])
```
Аргументы, используемые для вызова сложного конструктора, могут иметь числовой (в том числе `complex` ) тип для любого параметра:
```python
>>> complex(1, 1)
(1+1j)
>>> complex(1j, 1j)
(-1+1j)
>>> complex(1.1, 3.5)
(1.1+3.5j)
>>> complex(1.1)
(1.1+0j)
>>> complex(0, 3.5)
3.5j
```
В качестве аргумента также может использоваться `string` . Второй аргумент не разрешен, если строка используется как аргумент
```python
>>> complex("1.1+3.5j")
(1.1+3.5j)
```

7
guide/russian/python/containers/index.md Normal file
View File

@@ -0,0 +1,7 @@
---
title: Python Containers
localeTitle: Контейнеры Python
---
Некоторые объекты содержат ссылки на другие объекты; они называются контейнерами. Примерами контейнеров являются кортежи, списки и словари. Ссылки являются частью значения контейнера. В большинстве случаев, когда мы говорим о значении контейнера, мы подразумеваем значения, а не идентификаторы содержащихся объектов; однако, когда мы говорим о изменчивости контейнера, подразумеваются только тождества непосредственно содержащихся объектов. Таким образом, если неизменяемый контейнер (например, кортеж) содержит ссылку на изменяемый объект, его значение изменяется, если измененный объект изменяется.
[Документы Python - значения и типы объектов](https://docs.python.org/3/reference/datamodel.html#objects-values-and-types)

75
guide/russian/python/converting-integer-to-string-in-python/index.md Normal file
View File

@@ -0,0 +1,75 @@
---
title: Converting Integer to String in Python
localeTitle: Преобразование целочисленного в String в Python
---
## Преобразование целочисленного в String в Python
В отличие от многих других языков, Python не подразумевает, что цепочки целых чисел (или плавающие) не привязаны к строкам при конкатенации строками. К счастью, у Python есть удобная встроенная функция `str()` которая преобразует аргумент, переданный в строковый формат.
#### Неправильный путь
Программисты, поступающие с других языков, могут попытаться выполнить следующую конкатенацию строк, которая вызывает ошибку:
```py
age = 18
string = "Hello, I am " + age + " years old"
```
[Выполнить код на repl.it](https://repl.it/JyYH/0)
Ошибка, которая появляется
```
Traceback (most recent call last):
File "python", line 3, in <module>
TypeError: must be str, not int
```
`TypeError: must be str, not int` указывает, что целое число сначала должно быть преобразовано в строку, которая будет конкатенирована.
#### Правильный путь
Пример простой конкатенации:
```py
age = 18
print("Hello, I am " + str(age) + " years old")
# Output
# Hello, I am 18 years old
```
[Выполнить код на repl.it](https://repl.it/Jz8Q/0)
Печать `1 2 3 4 5 6 7 8 9 10` с использованием одной строки
```py
result = ""
for i in range(1, 11):
result += str(i) + " "
print(result)
# Output
# 1 2 3 4 5 6 7 8 9 10
```
[Выполнить код на repl.it](https://repl.it/KBLB/0)
#### Объяснение строки за строкой приведенного выше кода
1. Прежде всего переменный «результат» присваивается пустой строке.
2. Для цикла используется для перебора списка чисел.
3. Этот список чисел генерируется с использованием функции диапазона.
4. поэтому диапазон (1,11) будет генерировать список чисел от 1 до 10.
5. На каждой итерации цикла эта переменная «i» будет принимать значения от 1 до 10.
6. На первой итерации, когда переменная i = 1, тогда переменная \[result = result + str (i) + "(пробел)"\], str (i) преобразует значение «i», которое является целым значением в строковое значение.
7. Так как i = 1, то на первой итерации окончательно результат = 1.
8. И тот же процесс продолжается до i = 10 и, наконец, после последнего результата итерации = 1 2 3 4 5 6 7 8 9 10.
9. Поэтому, когда мы окончательно печатаем результат после цикла for, вывод на консоли «1 2 3 4 5 6 7 8 9 10».
#### Дополнительная информация:
[Официальная документация на Python для `str()`](https://docs.python.org/3/library/stdtypes.html#str)

9
guide/russian/python/creating-guis-in-python3/index.md Normal file
View File

@@ -0,0 +1,9 @@
---
title: Creating GUI's in Python3
localeTitle: Создание GUI в Python3
---
# Создание GUI в Python 3
Это заглушка. [Помогите нашему сообществу расширить его](https://github.com/freecodecamp/guides/tree/master/src/pages/java/collections/index.md) .
[Это руководство по быстрому стилю поможет вам принять ваш запрос на тягу](https://github.com/freecodecamp/guides/blob/master/README.md) .

130
guide/russian/python/data-structures/dictionaries/index.md Normal file
View File

@@ -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
```

118
guide/russian/python/data-structures/floating-point-numbers/index.md Normal file
View File

@@ -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
```

18
guide/russian/python/data-structures/index.md Normal file
View File

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

165
guide/russian/python/data-structures/integers/index.md Normal file
View File

@@ -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
```

116
guide/russian/python/data-structures/objects/index.md Normal file
View File

@@ -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/) чтобы узнать больше.

87
guide/russian/python/data-structures/ranges/index.md Normal file
View File

@@ -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` методов выполняются и не реализуются**

13
guide/russian/python/data-structures/scopes/index.md Normal file
View File

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

36
guide/russian/python/data-structures/strings/index.md Normal file
View File

@@ -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)

196
guide/russian/python/data-structures/tuples/index.md Normal file
View File

@@ -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)

263
guide/russian/python/decorators/index.md Normal file
View File

@@ -0,0 +1,263 @@
---
title: Python Decorators
localeTitle: Декораторы Python
---
Декораторы по существу работают как обертки. Они изменяют поведение кода до и после выполнения целевой функции без необходимости изменения самой функции, дополняя исходную функциональность, тем самым ее украшая.
Прежде чем подробно рассказывать о декораторах, есть некоторые концепции, которые должны быть понятны. В Python функции являются объектами, и мы можем делать с ними много полезного материала.
> ### Присвоение функций переменным:
```
def greet(name):
return "Hello "+name
greet_someone = greet
print greet_someone("John")
```
> Выход: Привет, Джон
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CXGk)
> ### Определение функций внутри других функций:
```
def greet(name):
def get_message():
return "Hello "
result = get_message()+name
return result
print(greet("John"))
```
> Выход: Привет, Джон
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CXGu)
> ### Функции также могут передаваться в качестве параметров для других функций:
```
def greet(name):
return "Hello " + name
def call_func(func):
other_name = "John"
return func(other_name)
print call_func(greet)
```
> Выход: Привет, Джон
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CXHC)
> ### Функции могут возвращать другие функции:
>
> Другими словами, функции, генерирующие другие функции.
```
def compose_greet_func():
def get_message():
return "Hello there!"
return get_message
greet = compose_greet_func()
print(greet())
```
Результат: Привет!
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CXHG)
> ### Внутренние функции имеют доступ к охватывающей области
>
> Более известный как [закрытие](http://www.shutupandship.com/2012/01/python-closures-explained.html) . Очень мощный образец, который мы встретим при создании декораторов. Еще одно замечание: Python разрешает [доступ](http://www.tech-thoughts-blog.com/2013/07/writing-closure-in-python.html) только для [чтения к внешней области,](http://www.tech-thoughts-blog.com/2013/07/writing-closure-in-python.html) а не к назначению. Обратите внимание, как мы изменили приведенный выше пример, чтобы прочитать аргумент «name» из охватывающей области внутренней функции и вернуть новую функцию.
```
def compose_greet_func(name):
def get_message():
return "Hello there "+name+"!"
return get_message
greet = compose_greet_func("John")
print(greet())
```
> Результат: Привет, Джон!
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CXHI)
## Состав декораторов
Декораторы функций - это просто обертки для существующих функций. Объединяя идеи, упомянутые выше, мы можем построить декоратора. В этом примере рассмотрим функцию, которая переносит вывод строки другой функции с помощью p-тегов.
```
def get_text(name):
return "lorem ipsum, {0} dolor sit amet".format(name)
def p_decorate(func):
def func_wrapper(name):
return "`<p>`{0}`</p>`".format(func(name))
return func_wrapper
my_get_text = p_decorate(get_text)
print (my_get_text("John"))
```
> Выход: `<p>` lorem ipsum, John dolor sit amet `</p>`
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CXHL)
Это был наш первый декоратор. Функция, которая принимает другую функцию в качестве аргумента, генерирует новую функцию, увеличивая работу исходной функции и возвращая сгенерированную функцию, чтобы мы могли ее использовать в любом месте. Чтобы `get_text` был оформлен `p_decorate` , нам просто нужно назначить get _text для результата p_ decorate.
```
get_text = p_decorate(get_text)
print (get_text("John"))
```
> Выход: lorem ipsum, John dolor sit amet
Еще одно замечание заключается в том, что наша украшенная функция принимает аргумент имени. Все, что нам нужно было сделать в декораторе, - это позволить оболочке get\_text передать этот аргумент.
> ### Синтаксис стилиста Python
Python делает создание и использование декораторов немного более чистым и приятным для программиста через какой-то [синтаксический сахар.](http://en.wikipedia.org/wiki/Syntactic_sugar) Чтобы украсить _текст, нам не нужно получать_ text = p _decorator (получить_ текст). Для этого есть аккуратный ярлык, который должен упомянуть имя функции украшения перед функцией, которую нужно украсить. Имя декоратора должно быть перпендикулярно символу @.
```
def p_decorate(func):
def func_wrapper(name):
return "`<p>`{0}`</p>`".format(func(name))
return func_wrapper
@p_decorate
def get_text(name):
return "lorem ipsum, {0} dolor sit amet".format(name)
print get_text("John")
```
> Выход: `<p>` lorem ipsum, John dolor sit amet `</p>`
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CXHN)
Теперь давайте рассмотрим, что мы хотели украсить нашу функцию get\_text двумя другими функциями, чтобы обернуть div и сильный тег вокруг вывода строки.
```
def p_decorate(func):
def func_wrapper(name):
return "`<p>`{0}`</p>`".format(func(name))
return func_wrapper
def strong_decorate(func):
def func_wrapper(name):
return "`<strong>`{0}`</strong>`".format(func(name))
return func_wrapper
def div_decorate(func):
def func_wrapper(name):
return "`<div>`{0}`</div>`".format(func(name))
return func_wrapper
```
При базовом подходе декорирование get\_text будет осуществляться в соответствии с
```
get_text = div_decorate(p_decorate(strong_decorate(get_text)))
```
С синтаксисом декоратора Python то же самое можно добиться с гораздо большей выразительностью.
```
@div_decorate
@p_decorate
@strong_decorate
def get_text(name):
return "lorem ipsum, {0} dolor sit amet".format(name)
print (get_text("John"))
```
> Выход: `<div><p><strong>` lorem ipsum, John dolor sit amet `</strong></p></div>`
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CXHQ)
Здесь важно отметить, что порядок установки наших декораторов имеет значение. Если в приведенном выше примере порядок был другим, результат был бы иным. ## Decorating Methods В Python методы - это функции, которые ожидают, что их первый параметр будет ссылкой на текущий объект. Мы можем создавать декораторы для методов одинаково, принимая во внимание функцию обертки.
```
def p_decorate(func):
def func_wrapper(self):
return "`<p>`{0}`</p>`".format(func(self))
return func_wrapper
class Person(object):
def __init__(self):
self.name = "John"
self.family = "Doe"
@p_decorate
def get_fullname(self):
return self.name+" "+self.family
my_person = Person()
print (my_person.get_fullname())
```
> Выход: `<p>` Джон Доу `</p>`
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CXH2)
Намного лучше было бы сделать наш декоратор полезным для функций и методов. Это можно сделать, поместив [\* args и \*\* kwargs в](http://docs.python.org/2/tutorial/controlflow.html#arbitrary-argument-lists) качестве параметров для обертки, тогда он может принимать любое произвольное количество аргументов и аргументов ключевых слов.
```
def p_decorate(func):
def func_wrapper(*args, **kwargs):
return "`<p>`{0}`</p>`".format(func(*args, **kwargs))
return func_wrapper
class Person(object):
def __init__(self):
self.name = "John"
self.family = "Doe"
@p_decorate
def get_fullname(self):
return self.name+" "+self.family
my_person = Person()
print (my_person.get_fullname())
```
> Выход: `<p>` Джон Доу `</p>`
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CXH5)
### Передача аргументов декораторам. Оглядываясь на пример до вышеприведенного, вы можете заметить, как избыточные декораторы в этом примере. 3 декоратора ( _украшают_ div _, p_ decorate, strong\_decorate), каждый с одинаковой функциональностью, но обертывает строку разными тегами. Мы можем определенно сделать намного лучше, чем это. Почему бы не иметь более общую реализацию для той, которая берет тег для обертывания в виде строки? Да, пожалуйста!
```
def tags(tag_name):
def tags_decorator(func):
def func_wrapper(name):
return "<{0}>{1}</{0}>".format(tag_name, func(name))
return func_wrapper
return tags_decorator
@tags("p")
def get_text(name):
return "Hello "+name
print (get_text("John"))
```
> Вывод: `<p>` Привет, Джон `</p>`
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CXH6)
В этом случае потребовалось немного больше работы. Декораторы ожидают получить функцию в качестве аргумента, поэтому нам придется строить функцию, которая принимает эти дополнительные аргументы и генерировать наш декоратор «на лету». В приведенном выше примере теги, наш генератор декоратора. Отладка украшенных функций. В конце дня декораторы просто обертывают наши функции, в случае отладки это может быть проблематично, поскольку функция-обертка не несет имени, модуля и docstring исходной функции. Исходя из приведенного выше примера, если мы это сделаем:
```
print (get_text.__name__)
```
> Вывод: func _wrapper. Ожидается, что выход будет получать_ текст, **имя** атрибута, **doc** и **модуль** get _text будут переопределены теми из оболочки (func_ wrapper). Очевидно, что мы можем повторно установить их в func\_wrapper, но Python обеспечивает много более удобный способ. ### Functools для спасения
```
from functools import wraps
def tags(tag_name):
def tags_decorator(func):
@wraps(func)
def func_wrapper(name):
return "`<{0}>`{1}`</{0}>`".format(tag_name, func(name))
return func_wrapper
return tags_decorator
@tags("p")
def get_text(name):
"""returns some text"""
return "Hello "+name
print (get_text.__name__) # get_text
print (get_text.__doc__) # returns some text
print (get_text.__module__) # __main__
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CXHb)
Вы можете заметить на выходе, что атрибуты get\_text являются правильными.

137
guide/russian/python/defaultdict/index.md Normal file
View File

@@ -0,0 +1,137 @@
---
title: Python defaultdict
localeTitle: Python defaultdict
---
## Python defaultdict
Словарь - одна из наиболее используемых структур данных в Python. Словарь представляет собой неупорядоченный набор элементов, и мы обычно имеем ключи и значения, хранящиеся в словаре. Давайте рассмотрим несколько примеров того, как обычно используется словарь.
```python
# dictionary declaration 1
dict1 = dict()
# dictionary declaration 2
dict2 = {}
# Add items to the dictionary
# The syntax to add and retrieve items is same for either of the two objects we defined above.
key = "X"
value = "Y"
dict1[key] = value
# The dictionary doesn't have any specific data-type.
# So, the values can be pretty diverse.
dict1[key] = dict2
```
Давайте посмотрим на некоторые способы поиска.
```python
# Since "X" exists in our dictionary, this will retrieve the value
value = dict1[key]
# This key doesn't exist in the dictionary.
# So, we will get a `KeyError`
value = dict1["random"]
```
### Избегайте KeyError: используйте функцию .get
В случае, если данный ключ не существует в словаре, Python будет бросать `KeyError` . Для этого есть простой способ обхода. Давайте посмотрим, как мы можем избежать `KeyError` используя встроенная функция `.get` для словарей.
```python
dict_ = {}
# Some random key
random_key = "random"
# The most basic way of doing this is to check if the key
# exists in the dictionary or not and only retrieve if the
# key exists. Otherwise not.
if random_key in dict_:
print(dict_[random_key])
else:
print("Key = {} doesn't exist in the dictionary".format(dict_))
```
Много раз мы нормально получаем значение по умолчанию, когда ключ не существует. Например, когда построение счетчика. Существует лучший способ получить значения по умолчанию из словаря в случае отсутствующие ключи, а не полагаться на стандартное `if-else` .
```python
# Let's say we want to build a frequency counter for items in the following array
arr = [1,2,3,1,2,3,4,1,2,1,4,1,2,3,1]
freq = {}
for item in arr:
# Fetch a value of 0 in case the key doesn't exist. Otherwise, fetch the stored value
freq[item] = freq.get(item, 0) + 1
```
Таким образом, `get(<key>, <defaultval>)` - это удобная операция для получения значения по умолчанию для любого заданного ключа из словаря. Проблема с этим методом возникает, когда мы хотим иметь дело с изменяемыми структурами данных как значения, например, `list` или `set` .
```python
dict_ = {}
# Some random key
random_key = "random"
dict_[random_key] = dict_.get(random_key, []).append("Hello World!")
print(dict_) # {'random': None}
dict_ = {}
dict_[random_key] = dict_.get(random_key, set()).add("Hello World!")
print(dict_) # {'random': None}
```
Вы видели проблему?
Новый `set` или `list` не привязаны к ключу словаря. Мы должны назначить новый `list` или `set` к ключу в случае отсутствия значения, а затем `append` или `add` соответственно. Лей смотрит на пример для этого.
```python
dict_ = {}
dict_[random_key] = dict_.get(random_key, set())
dict_[random_key].add("Hello World!")
print(dict_) # {'random': set(['Hello World!'])}. Yay!
```
### Избегайте KeyError: используйте defaultdict
Это работает большую часть времени. Однако есть лучший способ сделать это. Более `pythonic` путь. `defaultdict` является подклассом встроенного класса dict. `defaultdict` просто присваивает значение по умолчанию, которое мы укажем в случае отсутствия ключа. Итак, два шага:
```python
dict_[random_key] = dict_.get(random_key, set())
dict_[random_key].add("Hello World!")
```
теперь можно объединить в один шаг. Например, для
```python
from collections import defaultdict
# Yet another random key
random_key = "random_key"
# list defaultdict
list_dict_ = defaultdict(list)
# set defaultdict
set_dict_ = defaultdict(set)
# integer defaultdict
int_dict_ = defaultdict(int)
list_dict_[random_key].append("Hello World!")
set_dict_[random_key].add("Hello World!")
int_dict_[random_key] += 1
"""
defaultdict(<class 'list'>, {'random_key': ['Hello World!']})
defaultdict(<class 'set'>, {'random_key': {'Hello World!'}})
defaultdict(<class 'int'>, {'random_key': 1})
"""
print(list_dict_, set_dict_, int_dict_)
```
* * *
[Официальные документы](https://docs.python.org/2/library/collections.html)

24
guide/russian/python/defining-functions/index.md Normal file
View File

@@ -0,0 +1,24 @@
---
title: Python Defining Functions
localeTitle: Функции определения Python
---
[Документы Python](https://docs.python.org/3/tutorial/controlflow.html#defining-functions)
Мы можем создать функцию, которая записывает ряд Фибоначчи в произвольную границу:
```
>>> def fib(n): # write Fibonacci series up to n
... """Print a Fibonacci series up to n."""
... a, b = 0, 1
... while a < n:
... print(a, end=' ')
... a, b = b, a+b
... print()
...
>>> # Now call the function we just defined:
... fib(2000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
```
Ключевое слово [`def`](https://docs.python.org/3/reference/compound_stmts.html#def) вводит определение функции. За ним должно следовать имя функции и список формальных параметров в скобках. Операторы, которые образуют тело функции, начинаются со следующей строки и должны быть отступом.
Первый оператор тела функции может быть произвольным строковым литералом; этот строковый литерал является строкой документации функции или [docstring](https://www.python.org/dev/peps/pep-0257/) (больше о docstrings можно найти в разделе «Строки документации»). Некоторые инструменты используют docstrings для автоматического создания онлайн-или печатной документации или для интерактивного просмотра пользователем кода. Хорошая практика заключается в том, чтобы включить в текст код, который вы пишете, поэтому попробуйте сделать его привычкой.

27
guide/russian/python/difference-between-is-and-equal-equal-operators/index.md Normal file
View File

@@ -0,0 +1,27 @@
---
title: Difference between Python 'is' and '==' operators
localeTitle: Разница между операторами Python 'is' и '=='
---
`is` является проверка идентичности объекта - то есть, проверка , если два или более переменных имеют в виду тот же объект. Вы не можете перегрузить `is` .
`==` оценивает значение true, если объект, на который ссылаются переменные, равен. Вы можете перегружать `==` помощью оператора `__eq__` .
## Возвращаемое значение
Возвращаемое значение для обоих будет равно `True` или `False` .
## Образец кода
```
a = 2.3
a is 2.3 # => False
a == 2.3 # => True
a = [234,123,321]
b = [234,123,321]
a == b # => True
a is b # => False
a = b
a == b # => True
a is b # => True, because if we change a, b changes too
```

67
guide/russian/python/docstring/index.md Normal file
View File

@@ -0,0 +1,67 @@
---
title: Docstring
localeTitle: строка документации
---
## строка документации
Docstring - это способ для разработчиков передать цели, параметры, требования и использование функции в Python другим разработчикам. Это позволяет упростить обслуживание и понимание кода.
В отличие от обычных комментариев исходного кода, docstring должен описывать, что функция., нет как.
Аналогичным примером для Docstring является @Javadoc в Java.
Docstring записывается как многострочный комментарий сразу после заголовка объявления в Python. В docstring имеется 4 различных части:
1. Тип ввода и тип вывода
* Ввод / вывод может быть `obj, list, bool, int, str, float`
2. Описание функции
* Краткое, но подробное описание того, что делает ваша функция
3. Требования
* Это читает человек, поэтому он не должен быть кодом
4. Испытательные случаи (обычно 2-3)
Ниже приведен общий формат.
## Формат Docstring
```python
def my_examplefunc(input_type1, input_type2):
'''(input_type1, input_type2) -> output_type # Your first line will be the input/output. Remember the space around the arrow!
Here is a description of my example function # Your second line will be the description
REQ: type(input_type1) == list # Your next line (or lines) will be the requirements for the input of your function
REQ: type(input_type2) == str
>>> my_example_func([2, 3], "Hello World!") # After the requirements come test cases
[2, 3] "Hello World"
>>> my_example_func([7, 2], "Another test case") # Your first line of the test case is an example of the usage, prefaced by >>>
[7, 2] "Another test case" # Your second line of the test case is the output
>>> my_example_func([5, 6], "Last test case")
[5, 6] "Last test case"
'''
# Your code goes here, underneath the Docstring
```
Docstring лучше всего разбирается в примерах, поэтому взгляните на приведенную ниже примерную программу, где программа выводит True, если число меньше 5, а False - если число больше 5.
## Пример 1
```python
def is_less_than_five(some_number):
'''(int) -> bool
Returns True if the given number is less than 5, and False is the given number is greater than 5.
REQ: some_number != 5
>>> is_less_than_five(4)
True
>>> is_less_than_five(6)
False
>>> is_less_than_five(100000)
False
'''
# Your code goes here
```
### Некоторые полезные ссылки:
Numpy и Google Docstrings - два широко используемых подхода:
* Google: http://sphinxcontrib-napoleon.readthedocs.io/en/latest/example\_google.html
* Numpy: http://sphinxcontrib-napoleon.readthedocs.io/en/latest/example\_numpy.html Кроме того, обратитесь к некоторым старым старым комментариям PEP: https://www.python.org/dev/peps/pep-0257/

36
guide/russian/python/escape-sequences/index.md Normal file
View File

@@ -0,0 +1,36 @@
---
title: Python Escape Sequences
localeTitle: Последовательности выхода Python
---
Список escape-последовательностей можно найти [здесь](https://docs.python.org/3/reference/lexical_analysis.html#strings)
Последовательности эвакуации позволяют включать специальные символы в строки.
```
>>> print('Single quote strings can have \'single\' quotes if they are escaped')
"Single quote strings can have 'single' quotes if they are escaped"
>>> print("Double quote strings can have \"double\" quotes if they are escaped")
'Double quote strings can have "double" quotes if they are escaped'
>>> print("Multiline strings\ncan be created\nusing escape sequences.")
Multiline strings
can be created
using escape sequences.
>>> print("Backslashes \\ need to be escaped.")
Backslashes \ need to be escaped.
```
_Необработанную_ строку можно использовать, префикс строки с `r` или `R` которая позволяет включать обратную косую черту без необходимости их избегать -
```
>>> print(r"Backslashes \ don't need to be escaped in raw strings.")
Backslashes \ don't need to be escaped in raw strings.
>>> print(r"An odd number of backslashes at the end of a raw string will cause an error\")
File "<stdin>", line 1
print(r"An odd number of backslashes at the end of a raw string will cause an error\")
^
SyntaxError: EOL while scanning string literal.
```
#Достаточно больше примеров escape-последовательностей. Escape Sequence
\\ Печать обратной косой черты
\`Печать одной кавычки
\\ "Печать двойной кавычки
\\ a Колокол ASCII вызывает звуковые сигналы звонка (например, xterm) \\ b ASCII backspace (BS) удаляет предыдущий символ \\ n Добавляет новую строку.

32
guide/russian/python/exception-and-error-handling/index.md Normal file
View File

@@ -0,0 +1,32 @@
---
title: Exceptions and Errors Handling
localeTitle: Исключения и ошибки Обработка
---
## Исключения и ошибки Обработка
При создании программы мы можем делать ошибки, которые заканчиваются ошибками и худшими программами, которые мы делаем, было бы еще более раздражать, если бы мы не смогли найти ошибок в коде, который мы сделали, или что было не так. Простыми словами, ошибки - это то, что программисты избегают при создании программы. Чтобы решить эту проблему в python, мы можем использовать `try` и `except`
Пример:
```shell
>>> try:
>>> . . . print "this is not a string "+1
>>> except:
>>> . . . print "error"
error
```
и если вы хотите получить сообщения об ошибках более подробно из своего кода, вы можете добавить аргументы, `except Exception as err`
```shell
>>> try:
>>> . . . print "this is not a string "+1
>>> except Exception as err:
>>> . . . print "error:\n"+str(err)
error:
cannot concatenate 'str' and 'int' objects
```
Дополнительная информация:
[Документация по](https://docs.python.org/2/tutorial/errors.html) ошибкам и исключениям.

115
guide/russian/python/files-and-io/index.md Normal file
View File

@@ -0,0 +1,115 @@
---
title: Files and IO
localeTitle: Файлы и ввод-вывод
---
## Файлы и ввод-вывод
Файл является именованным местоположением на диске для хранения связанной информации. Он используется для постоянного хранения данных в энергонезависимой памяти (например, жесткий диск). Поскольку оперативное запоминающее устройство (ОЗУ) является энергозависимым, которое теряет свои данные, когда компьютер выключен, мы используем файлы для последующего использования данных.
Когда мы хотим читать или писать в файл, нам нужно сначала открыть его. Когда мы закончим, его нужно закрыть, чтобы ресурсы, связанные с файлом, были освобождены.
Следовательно, в Python операция файла происходит в следующем порядке: 1) Открыть файл 2) Чтение или запись (выполнение операции) 3) Закройте файл
Python имеет множество способов ввода и вывода. Некоторые из операций вывода могут печатать текстовые, консольные журналы и даже выводить текст или файл электронной таблицы.
### Выход на экран
Python обеспечивает самый простой способ вывода вывода на экран.
```python
print "Python is a powerful language.","It is easy to learn."
```
Вывод:
```
Python is a powerful language.It is easy to learn.
```
### Вход от пользователя
Существует два способа ввода данных от пользователя.
raw\_input (\[подсказка\])
Используется для чтения одной строки со стандартного ввода и возвращает ее как строку
```python
str = raw_input("Enter your name: ")
print "Welcome ", str
```
Вывод:
```
Enter your name: John Doe
Welcome John Doe
```
вход (приглашение)
Аналогичная функциональность для raw\_input (), но предполагает, что вход является допустимым выражением Python
```python
str = input("Enter input: ")
print "Input: ", str
```
Вывод:
```
Enter input: [x*5 for x in range(2,10,2)]
Input: [10,20,30,40]
```
### Взаимодействие с файлами в Python
Используя Python, файлы можно легко открыть, прочитать, записать и закрыть. Имеющиеся функции:
1. `open()`
2. `read()`
3. `write()`
4. `close()`
Пример:
```python
file1 = open("foo.txt", "r+") # Opens the file with read permission.
file1.write("Python is a powerful language.It is easy to learn.") # Writes data into the file.
data = file1.read(15) # Reads first 15 characters in the file.
print "First 15 characters are:\n", data # Prints output
file1.close() # Closes the opened file.
```
Вывод:
```
First 15 characters are:
Python is a pow
```
#### Открытие файлов
Метод python open () может использоваться для возврата объекта файла. Он чаще всего используется с двумя аргументами, которые являются именем файла и режимом доступа. Режим доступа используется для описания способа доступа или использования файла.
Наиболее часто используемые режимы - это «w», который предназначен для записи в файл и «r», который используется для чтения файла, в то время как «r +» используется для чтения и записи файла. 'a' - это режим, который используется для добавления текста в файл. Аргумент mode также является необязательным и будет считаться «r», если он опускается.
После завершения операции ввода и вывода файл должен быть закрыт, чтобы освободить все ресурсы.
Пример кода для открытия текстового файла:
\`\` \`python file = open ('hello\_world.txt', 'w') file.write ('Hello World!') file.close ()
```
##### Using with
An alternative to using the `open()` function in standalone is to make use of the `with` statement to open a file. This is considered best practice as it allows the Python framework to manage the context of opening the file, and will autmoatically perform any required resource cleanup.
This is adventageous in the fact that it takes the onus off the programmer to close every file that is opened, and that the file will still be closed even if an exception was encountered during an IO operation.
When using the `with` statement is important to note that access to the file will only available within the scope of the `with` block.
To open a file using the `with` statement the `with` keyword is entered, followed by the call to `open(file)`. Following this the variable used as a handle to the open file is declared after the `as` keyword. Once the programs execution returns from this block, the file will be closed automatically.
Sample code to open a text file using the `with` statement:
```
с открытым ('hello\_world.txt', 'w') как f: f.write ('Hello World!') \`\` \`
#### Дополнительная информация:
[Документация Python - IO](https://docs.python.org/2/tutorial/inputoutput.html) [Автоматизация бурового инструмента](https://automatetheboringstuff.com/chapter8/) [Точки обучения - Python IO](https://www.tutorialspoint.com/python/python_files_io.htm) [8 PEP 343: оператор «с»](https://docs.python.org/2.5/whatsnew/pep-343.html)

184
guide/russian/python/for-loop-statements/index.md Normal file
View File

@@ -0,0 +1,184 @@
---
title: For Loop Statements
localeTitle: Записи цикла
---
## Записи цикла
Python использует цикл for для перебора списка элементов. В отличие от C или Java, которые используют цикл for для изменения значения в шагах и доступа к чему-то, например массиву, используя это значение.
Для циклов итерации по структурам данных на основе сбора данных, таким как списки, кортежи и словари.
Основной синтаксис:
```python
for value in list_of_values:
# use value inside this block
```
В общем, вы можете использовать что-либо как значение итератора, где могут быть назначены записи итерации. Например, вы можете распаковать кортежи из списка кортежей:
```python
list_of_tuples = [(1,2), (3,4)]
for a, b in list_of_tuples:
print("a:", a, "b:", b)
```
С другой стороны, вы можете перебрать все, что итерабельно. Вы можете вызвать функцию или использовать литерал списка.
```python
for person in load_persons():
print("The name is:", person.name)
```
```python
for character in ["P", "y", "t", "h", "o", "n"]:
print("Give me a '{}'!".format(character))
```
Некоторые способы использования циклов For:
**Итерация по функции range ()**
```python
for i in range(10):
print(i)
```
Вместо того, чтобы быть функцией, диапазон фактически является неизменным типом последовательности. Результат будет содержать результаты от нижней границы, т. Е. 0 до верхней границы, т. Е. 10, но исключая 10.By по умолчанию нижняя граница или начальный индекс устанавливается на ноль. Вывод:
```
>
0
1
2
3
4
5
6
7
8
9
>
```
Кроме того, можно указать нижнюю границу последовательности и даже шаг последовательности, добавив второй и третий параметры.
```python
for i in range(4,10,2): #From 4 to 9 using a step of two
print(i)
```
Вывод:
```
>
4
6
8
>
```
**Функция xrange ()**
По большей части, xrange и range являются точными с точки зрения функциональности. Они оба предоставляют способ генерации списка целых чисел для вас, но, как вам угодно. Единственное различие заключается в том, что диапазон возвращает объект списка Python, а xrange возвращает объект xrange. Это означает, что xrange фактически не создает статический список во время выполнения, например, диапазон. Он создает ценности по мере необходимости с помощью специального метода, называемого yielding. Этот метод используется с типом объекта, который известен как генераторы.
Еще одна вещь, которую нужно добавить. В Python 3.x функция xrange больше не существует. Функция диапазона теперь делает то, что делает xrange в Python 2.x
**Итерировать значения в списке или кортеже**
```python
A = ["hello", 1, 65, "thank you", [2, 3]]
for value in A:
print(value)
```
Вывод:
```
>
hello
1
65
thank you
[2, 3]
>
```
**Итерации по клавишам в словаре (aka hashmap)**
```python
fruits_to_colors = {"apple": "#ff0000",
"lemon": "#ffff00",
"orange": "#ffa500"}
for key in fruits_to_colors:
print(key, fruits_to_colors[key])
```
Вывод:
```
>
apple #ff0000
lemon #ffff00
orange #ffa500
>
```
**Итерацию над двумя списками одинакового размера в одном цикле с помощью функции zip ()**
\`\` \`\` Питон A = \["a", "b", "c"\] B = \["a", "d", "e"\]
для a, b в zip (A, B): print a, b, a == b
```
Output:
```
\> aa True bd False Неверно >
```
**Iterate over a list and get the corresponding index with the enumerate() function**
```
питон A = \["this", "is", "something", "fun"\]
для индекса, слова в перечислении (A): print (индекс, слово)
```
Output:
```
\> 0 это 1 - 2 что-то 3 весело >
```
A common use case is iterating over a dictionary:
```
питон для имени, номер телефона в contacts.items (): print (имя, «доступно под», номер телефона)
```
If you absolutely need to access the current index of your iteration, do **NOT** use `range(len(iterable))`! This is an extremely bad practice and will get you plenty of chuckles from senior Python developers. Use the built in function `enumerate()` instead:
```
питон для индекса, элемент в перечислении (shopping\_basket): print («Item», index, «is», item)
```
**for/else statements**
Pyhton permits you to use else with for loops, the else case is executed when none of the conditions with in the loop body was satisfied. To use the else we have to make use of `break` statement so that we can break out of the loop on a satsfied condition.If we do not break out then the else part will be executed.
```
питон недельные _дни = \['Понедельник', 'Вторник', 'Среда', 'Четверг', 'Пятница'\] Сегодня = 'Суббота' за день в неделю_ : если день == сегодня: print ('сегодня - недельный день') перерыв еще: print («сегодня не день недели»)
```
In the above case the output will be `today is not a week day` since the break within the loop will never be executed.
**Iterate over a list using inline loop function**
We could also iterate inline using python, for example if we need to uppercase all the words in a list from a list we could simply do the following:
```
питон A = \["this", "is", "awesome", "shinning", "star"\]
UPPERCASE = \[word.upper () для слова в A\] print (UPPERCASE)
```
Output:
```
\> \[«ЭТО», «ЕСТЬ», «УДИВИТЕЛЬНОЕ», «СИНХРОНИЗАЦИЯ», «ЗВЕЗДА») > \`\` \`
#### Дополнительная информация:
* [Документация Python2 для цикла](https://docs.python.org/2.7/tutorial/controlflow.html#for-statements)
* [Python3 для документации по циклам](https://docs.python.org/3/tutorial/controlflow.html#for-statements)

35
guide/russian/python/from-x-import-y/index.md Normal file
View File

@@ -0,0 +1,35 @@
---
title: Python from X Import Y
localeTitle: Python из X Импорт Y
---
Если вы прочитали `import statements` wiki `import statements` вы бы увидели, как я использую этот оператор в одном из примеров. Сегодня мы постараемся понять, что он делает
Итак, возьмем тот же пример:
```
>>> from math import ceil, sqrt
>>> # here it would be
>>> sqrt(36)
<<< 6
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CS5t/1)
Или мы могли бы использовать это:
```
>>> import math
>>> # here it would be
>>> math.sqrt(36)
<<< 6
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CS5u)
Тогда наш код будет выглядеть как `math.sqrt(x)` вместо `sqrt(x)` . Это происходит потому, что, когда мы используем `import x` , пространство имен `x` создается самим, чтобы избежать конфликтов имен. Вы должны получить доступ к каждому объекту модуля как `x.<name>` . Но когда мы используем `from x import y` мы соглашаемся добавить `y` в основное глобальное пространство имен. Поэтому при использовании этого мы должны убедиться, что у нас нет объекта с таким же именем в нашей программе.
> **Никогда не используйте `from x import y` если объект с именем `y` уже существует**
Например, в `os` модуле есть метод `open` . Но у нас даже есть встроенная функция `open` . Итак, здесь нам следует избегать использования `from os import open` .
Мы даже можем использовать `form x import *` , это будет импортировать все методы, классы этого модуля в глобальное пространство имен программы. Это плохая практика программирования. Пожалуйста, избегайте этого.
В общем, вам следует избегать `from x import y` просто из-за проблем, которые могут возникнуть в крупномасштабных программах. Например, вы никогда не знаете, может ли другой программист создать новую функцию, которая называется именем одной из существующих функций. Вы также не знаете, изменит ли Python библиотеку, из которой вы импортируете функции. Хотя эти проблемы не будут существовать так часто для сольных проектов, как было сказано ранее, это плохая практика программирования, и ее следует избегать.

37
guide/russian/python/frozenset/index.md Normal file
View File

@@ -0,0 +1,37 @@
---
title: Python Frozenset
localeTitle: Python Frozenset
---
**Основная информация о `frozenset`** Тип `frozenset` - встроенный набор типов, который является неизменным и хешируемым - его содержимое не может быть изменено после его создания; однако он может использоваться как ключ словаря или как элемент другого набора. Frozensets подобны наборам, за исключением того, что они не могут быть изменены, т. Е. Они являются immutale.
```
>>> cities = frozenset(["Frankfurt", "Basel", "Freiburg"])
>>> cities.add("Strasbourg")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'frozenset' object has no attribute 'add'
>>>
```
`frozenset` : `frozenset([iterable])` Итерируемый содержит элементы для инициализации frozenset. Итерируемый может быть установлен, словарь, кортеж и т. Д. Если параметр не передан, метод `frozenset()` возвращает пустой фризонсет.
**Примеры**
```
>>> vowels = ('a', 'e', 'i', 'o', 'u')
>>> fSet = frozenset(vowels)
>>> print("The frozen set is: ", fSet)
The frozen set is: frozenset({'i', 'e', 'a', 'u', 'o'})
>>> print("The empty frozen set is: ", frozenset())
The empty frozen set is: frozenset()
>>>
```
**Другой пример**
```
>>> person = {"name": "John", "age": 23, "sex": "male"}
>>> fSet = frozenset(person)
>>> print("The frozen set is: ", fSet)
The frozen set is: frozenset({'sex', 'name', 'age'})
>>>
```
**Дополнительная информация** [Python Frozenset ()](https://www.programiz.com/python-programming/methods/built-in/frozenset) [Set Types - set, frozenset](https://docs.python.org/2.4/lib/types-set.html) [Учебник Python: наборы и замороженные наборы](https://www.python-course.eu/sets_frozensets.php)

139
guide/russian/python/functions/index.md Normal file
View File

@@ -0,0 +1,139 @@
---
title: Functions
localeTitle: функции
---
## функции
Функция позволяет вам определить многоразовый блок кода, который может выполняться многократно в вашей программе.
Функции позволяют создавать более сложные и [сухие](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself) решения сложных проблем.
Хотя Python уже предоставляет множество встроенных функций, таких как `print()` и `len()` , вы также можете определить свои собственные функции для использования в ваших проектах.
Одним из больших преимуществ использования функций в вашем коде является то, что он уменьшает общее количество строк кода в вашем проекте.
### Синтаксис
В Python определение функции имеет следующие функции:
1. Ключевое слово `def`
2. имя функции
3. paranthesis '()' и внутри входных параметров paranthesis, хотя входные параметры являются необязательными.
4. двоеточие ':'
5. некоторый блок кода для выполнения
6. оператор возврата (необязательно)
```python
# a function with no parameters or returned values
def sayHello():
print("Hello!")
sayHello() # calls the function, 'Hello!' is printed to the console
# a function with a parameter
def helloWithName(name):
print("Hello " + name + "!")
helloWithName("Ada") # calls the function, 'Hello Ada!' is printed to the console
# a function with multiple parameters with a return statement
def multiply(val1, val2):
return val1 * val2
multiply(3, 5) # prints 15 to the console
```
Функции - это блоки кода, которые можно повторно использовать, вызывая функцию. Это позволяет простое и элегантное повторное использование кода без явного переписывания разделов кода. Это делает код более читаемым, упрощает отладку и ограничивает ошибки ввода.
Функции в Python создаются с использованием ключевого слова `def` , за которым следуют имя функции и параметры функции в круглых скобках.
Функция всегда возвращает значение. Ключевое слово `return` используется функцией для возврата значения, если вы не хотите возвращать какое-либо значение, значение по умолчанию `None` будет возвращено.
Имя функции используется для вызова функции, передающей необходимые параметры в круглых скобках.
```python
# this is a basic sum function
def sum(a, b):
return a + b
result = sum(1, 2)
# result = 3
```
Вы можете определить значения по умолчанию для параметров, таким образом Python будет интерпретировать, что значение этого параметра является значением по умолчанию, если ни один не указан.
```python
def sum(a, b=3):
return a + b
result = sum(1)
# result = 4
```
Вы можете передать параметры в том порядке, который вы хотите, используя имя параметра.
```python
result = sum(b=2, a=2)
# result = 4
```
Тем не менее, невозможно передать аргумент ключевого слова перед не ключевым словом
```Python
result = sum(3, b=2)
#result = 5
result2 = sum(b=2, 3)
#Will raise SyntaxError
```
Функции также являются объектами, поэтому вы можете назначить их переменной и использовать эту переменную как функцию.
```python
s = sum
result = s(1, 2)
# result = 3
```
### Заметки
* Если определение функции включает параметры, вы должны указать одинаковое количество параметров при вызове функции.
```python
print(multiply(3)) # TypeError: multiply() takes exactly 2 arguments (0 given)
print(multiply('a', 5)) # 'aaaaa' printed to the console
print(multiply('a', 'b')) # TypeError: Python can't multiply two strings
```
* Блок кода, который будет выполнять эта функция, включает все инструкции, отступы внутри функции.
```python
def myFunc():
print('this will print')
print('so will this')
x = 7
# the assignment of x is not a part of the function since it is not indented
```
* Переменные, определенные внутри функции, существуют только в пределах этой функции.
```python
def double(num):
x = num * 2
return x
print(x) # error - x is not defined
print(double(4)) # prints 8
```
\-Python интерпретирует функциональный блок только при вызове функции, а не когда функция определена. Даже если блок определения функции содержит какую-то ошибку, интерпретатор python укажет на это только тогда, когда вызывается функция.
### Дополнительная информация:
* [Python 3 Docs: определение функций](https://docs.python.org/3/tutorial/controlflow.html#defining-functions)

60
guide/russian/python/generators/index.md Normal file
View File

@@ -0,0 +1,60 @@
---
title: Generators
localeTitle: Генераторы
---
## Генераторы
Генераторы - это особый тип функции, который позволяет возвращать значения без завершения функции. Он делает это, используя ключевое слово `yield` . Подобно `return` , выражение `yield` возвращает значение вызывающему. Ключевое различие между ними состоит в том, что `yield` приостанавливает функцию, позволяя в будущем возвращать больше значений.
Генераторы являются итерабельными, поэтому их можно использовать чисто для циклов или чего-либо еще, что итерации.
```python
def my_generator():
yield 'hello'
yield 'world'
yield '!'
for item in my_generator():
print(item)
# output:
# hello
# world
# !
```
Как и другие итераторы, генераторы могут быть переданы `next` функции для извлечения следующего элемента. Когда генератор не имеет больше значений, `StopIteration` ошибка `StopIteration` .
```python
g = my_generator()
print(next(g))
# 'hello'
print(next(g))
# 'world'
print(next(g))
# '!'
print(next(g))
# Traceback (most recent call last):
# File "<stdin>", line 1, in <module>
# StopIteration
```
Генераторы особенно полезны, когда вам нужно создать большой набор значений, но им не нужно сохранять их все в памяти одновременно. Например, если вам нужно напечатать первые миллионы чисел фибоначчи, вы обычно возвращаете список из миллиона значений и перебираете список для печати каждого значения. Однако с генератором вы можете возвращать каждое значение по одному за раз:
```python
def fib(n):
a = 1
b = 1
for i in range(n):
yield a
a, b = b, a + b
for x in fib(1000000):
print(x)
```
### Больше информации
* [PEP 255](https://www.python.org/dev/peps/pep-0255/)
* [Python Wiki](https://wiki.python.org/moin/Generators)
* [Документация о выходе](https://docs.python.org/2/reference/simple_stmts.html#yield)

24
guide/russian/python/hex-functions/index.md Normal file
View File

@@ -0,0 +1,24 @@
---
title: Python Hex Function
localeTitle: Функция Hex Python
---
`hex(x)` - встроенная функция в Python 3 для преобразования целочисленного числа в строчную [шестнадцатеричную](https://www.mathsisfun.com/hexadecimals.html) строку с префиксом «0x».
## аргументация
Эта функция принимает один аргумент `x` , который должен иметь целочисленный тип.
## Вернуть
Эта функция возвращает строчную шестнадцатеричную строку с префиксом «0x».
## пример
```
print(hex(16)) # prints 0x10
print(hex(-298)) # prints -0x12a
print(hex(543)) # prints 0x21f
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CV0S)
[Официальная документация](https://docs.python.org/3/library/functions.html#hex)

79
guide/russian/python/how-to-convert-strings-into-integers-in-python/index.md Normal file
View File

@@ -0,0 +1,79 @@
---
title: How to Convert Strings into Integers in Python
localeTitle: Как преобразовать строки в целые числа в Python
---
## Как преобразовать строки в целые числа в Python
Подобно встроенной функции `str()` , Python также предлагает удобный встроенный элемент, который принимает строковый объект в качестве аргумента и возвращает соответствующий целочисленный объект.
#### Пример использования:
```py
# Here age is a string object
age = "18"
print(age)
# Converting string to integer
int_age = int(age)
print(int_age)
```
Вывод
```py
18
18
```
Здесь, хотя вывод визуально похож, но вы должны иметь в виду, что первая строка печатает строковый объект, а строка рядом с ним печатает целочисленный объект, который далее проиллюстрирован в следующем примере:
```py
age = "18"
print(age+2)
```
Вывод:
```py
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: cannot concatenate 'str' and 'int' objects
```
`The error should make it clear to you that you need to convert the` объект age в целое число, прежде чем добавлять что-то к нему.
```py
age = "18"
age_int = int(age)
print(age_int+2)
```
Вывод:
```py
20
```
Но вы должны иметь в виду некоторые особые случаи:
1. Плавающая точка (целое число с дробной частью) в качестве аргумента вернет float, округленное до ближайшего целого целого. Например: `print(int(7.9))` напечатает `7` . Также `print(int("7.9"))` приведет к ошибке, поскольку строка является недопустимым аргументом для преобразования в целое число.
```py
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '7.9'
```
2. Также любое целое число в словах, если задано в качестве аргумента, вернет ту же ошибку, что и выше: `print(int("one"))` выдаст ошибку следующим образом:
```py
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 'one'
```
#### Дополнительная информация:
Официальная документацию для `int()` встроенные можно найти [здесь](https://docs.python.org/3.6/library/functions.html#int)

43
guide/russian/python/idobject/index.md Normal file
View File

@@ -0,0 +1,43 @@
---
title: Python Idobject
localeTitle: Python Idobject
---
`id()` - встроенная функция в Python 3, которая возвращает _идентификатор_ объекта. _Идентификатор_ является уникальным целым для этого объекта в течение его жизни. Это также адрес объекта в памяти.
## аргументация
#### объект
Аргументом `object` обычно может быть `int` , `float` , `str` , `list` , `dict` , `tuple` и т. Д.
## Образец кода
```
a = 2
print(id(a)) #=> 140454723286976 (Values returned by id() might be different for different users)
b = 3
print(id(b)) #=> 140454723287008
c = 2
print(id(c)) #=> 140454723286976 (This is same as id(a) since they both contain the same value and hence have same memory address)
print(id(a) == id(b)) #=> False (since a and b have different values stored in them)
print(id(a) == id(c)) #=> True (since a and c have same values stored in them)
d = 1.1
e = 1.1
print(id(d) == id(e)) #=> True (since d and e have same values stored in them)
str1 = 'hello'
str2 = 'hello'
print(id(str1) == id(str2)) #=> True (since str1 and str2 have same values stored in them)
# For complex objects like lists, tuples, dictionaries etc. id() would give a unique integer even if the content of those containers is same.
tup1 = (1,1)
tup2 = (1,1)
print(id(tup1) == id(tup2)) #=> False
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CQw7/1)
[Официальные документы](https://docs.python.org/3/library/functions.html#id)

96
guide/russian/python/if-elif-else-statements/index.md Normal file
View File

@@ -0,0 +1,96 @@
---
title: If Elif Else Statements
localeTitle: Если Elif Else Statementments
---
## Если Elif Else Statementments
Структура `if` / `elif` / `else` - это общий способ управления потоком программы, позволяющий выполнять определенные блоки кода в зависимости от значения некоторых данных. Если условие, следующее за ключевым словом `if` оценивается как `true` , блок кода будет выполняться: Обратите внимание, что скобки не используются до и после проверки условий, как на других языках.
```python
if True:
print('If block will execute!')
```
```python
x = 5
if x > 4:
print("The condition was true!") #this statement executes
```
Вы можете дополнительно добавить ответ `else` который будет выполняться, если условие `false` :
```python
if not True:
print('If statement will execute!')
else:
print('Else statement will execute!')
```
Или вы также можете увидеть этот пример
```python
y = 3
if y > 4:
print("I won't print!") #this statement does not execute
else:
print("The condition wasn't true!") #this statement executes
```
_Обратите внимание, что нет никакого условия, следуя ключевому слову `else` - он ловит все ситуации, когда условие было `false`_
Несколько условий можно проверить, включив одну или несколько проверок `elif` после вашего первоначального оператора `if` но будет выполнено только одно условие:
```python
z = 7
if z > 8:
print("I won't print!") #this statement does not execute
elif z > 5:
print("I will!") #this statement will execute
elif z > 6:
print("I also won't print!") #this statement does not execute
else:
print("Neither will I!") #this statement does not execute
```
_Обратите внимание, что будет выполняться только первое условие, которое оценивается как `true` . Несмотря на то, что `z > 6` `true` , блок `if/elif/else` завершается после первого истинного условия. Это означает, что `else` будет выполняться только в том случае, если ни одно из условий не было `true` ._
Мы также можем создавать вложенные if для принятия решений. Перед тем, как раньше, обратитесь к разделу href = 'https: //guide.freecodecamp.org/python/code-blocks-and-indentation' target = '\_ blank' rel = 'nofollow'> отступов до предыдущего.
Давайте возьмем пример нахождения числа, которое равно и больше, чем '10 \`
```
python
x = 34
if x % 2 == 0: # this is how you create a comment and now, checking for even.
if x > 10:
print("This number is even and is greater than 10")
else:
print("This number is even, but not greater 10")
else:
print ("The number is not even. So point checking further.")
```
Это был простой пример для вложенных if. Пожалуйста, не стесняйтесь изучать больше онлайн.
Хотя приведенные выше примеры просты, вы можете создавать сложные условия, используя [логические сравнения](https://guide.freecodecamp.org/python/comparisons) и [логические операторы](https://guide.freecodecamp.org/python/boolean-operations) .
**_Встроенный оператор python if-else_**
Мы также можем использовать операторы if-else встроенные функции python Следующий пример должен проверить, больше ли число или равно 50, если да, верните True:
```
python
x = 89
is_greater = True if x >= 50 else False
print(is_greater)
```
Вывод
```
>
True
>
```

97
guide/russian/python/import-statements/index.md Normal file
View File

@@ -0,0 +1,97 @@
---
title: Python Import Statements
localeTitle: Операции импорта Python
---
Изучая программирование и чтение некоторых ресурсов, вы столкнулись с этим словом «абстракция», что просто означает как можно больше уменьшить и повторно использовать код.
Функции и модули облегчают абстрагирование. Вы создаете функции, когда хотите что-то повторять в файле.
Модули входят в изображение, если вы хотите повторно использовать группу функций в разных исходных файлах. Модули также полезны для структурирования программы.
* Использование стандартных библиотек и других сторонних модулей:
* Структурирование программы
## Использование стандартных библиотек
Пример. Подробно вы можете прочитать о методах / функциях всех стандартных библиотек в официальных документах Python.
```
import time
for i in range(100):
time.sleep(1) # Waits for 1 second and then executes the next command
print(str(i) + ' seconds have passed') # prints the number of seconds passed after the program was started
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CS6C)
```
# To calculate the execution time of a part of program
import time
start = time.time()
# code here
end = time.time()
print('Execution time:' , end-start)
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CS6C/1)
```
# Using math Module
import math
print(math.sqrt(100)) # prints 10
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CS6C/2)
## Использование сторонних модулей
Модули сторонних разработчиков не поставляются в комплекте с python, но мы должны установить его извне с помощью менеджеров пакетов, таких как [`pip`](https://bootstrap.pypa.io/get-pip.py) и [`easy install`](https://bootstrap.pypa.io/ez_setup.py)
```
# To make http requests
import requests
rq = requests.get(target_url)
print(rq.status_code)
```
Узнайте больше о модуле python-запросов [здесь](http://docs.python-requests.org/en/master/)
## Структурировать программы
Мы хотим создать программу, которая имеет различные функции относительно простых чисел. Итак, начнем. Мы определим все функции в `prime_functions.py`
```
# prime_functions.py
from math import ceil, sqrt
def isPrime(a):
if a == 2:
return True
elif a % 2 == 0:
return False
else:
for i in range(3,ceil(sqrt(a)) + 1,2):
if a % i == 0:
return False
return True
def print_n_primes(a):
i = 0
m = 2
while True:
if isPrime(m) ==True:
print(m)
i += 1
m += 1
if i == a:
break
```
Теперь мы хотим использовать функции, которые мы только что создали в `prime_functions.py` чтобы мы создали новый файл `playground.py` для использования этих функций.
> _Обратите внимание, что эта программа слишком проста для создания двух отдельных файлов, это просто для демонстрации. Но когда есть большие сложные программы, создание разных файлов действительно полезно._
```
# playground.py
import prime_functions
print(prime_functions.isPrime(29)) # returns True
```
## Сортировка импорта
Хорошей практикой является сортировка модулей `import` в трех группах: импорт стандартных библиотек, импорт сторонних поставщиков и местный импорт. В каждой группе разумно сортировать по алфавиту по имени модуля. Вы можете найти [дополнительную информацию в PEP8](https://www.python.org/dev/peps/pep-0008/?#imports) .
Одним из самых важных для языка Python является разборчивость, а сортировка по алфавиту модулей быстрее читается и выполняется. Также легче проверить, что что-то импортировано, и избежать дублирования импорта.

175
guide/russian/python/index.md Normal file
View File

@@ -0,0 +1,175 @@
---
title: Python
localeTitle: питон
---
## Что такое Python?
[Python](https://www.python.org) - это язык программирования общего назначения, который динамически типизируется, интерпретируется и известен своей легкостью чтения с отличными принципами проектирования.
Чтобы узнать больше о Python, ознакомьтесь с этими страницами на python.org:
[Что такое Python?](https://www.python.org/doc/essays/blurb/)
[Часто задаваемые вопросы по Python](https://docs.python.org/3/faq/general.html) .
## Python 2 или Python 3
* Эти две версии схожи, и знание одного перехода на другой код написано легко.
* [Python 2 или Python 3](https://wiki.python.org/moin/Python2orPython3)
* [Python 2.x не будет поддерживаться до 2020 года.](https://www.python.org/dev/peps/pep-0373/)
* 3.x находится в активной разработке. Это означает, что все последние усовершенствования стандартной библиотеки, например, доступны только по умолчанию в Python 3.x.
* На протяжении многих лет экосистема Python накопила значительное количество качественного программного обеспечения. Недостатком отлаженной обратной совместимости в версии 3.x является то, что часть этого программного обеспечения (особенно собственного программного обеспечения в компаниях) до сих пор не работает на 3.x.
## Монтаж
Большинство операционных систем на базе nix поставляются с установленным Python (как правило, Python 2, Python 3 в большинстве последних). Замена системы Python не рекомендуется и может вызвать проблемы. Тем не менее, различные версии Python можно безопасно установить рядом с системой Python. См. [Настройка и использование Python](https://docs.python.org/3/using/index.html) .
Windows не поставляется с Python, установщик и инструкции можно найти [здесь](https://docs.python.org/3/using/windows.html)
## Python Interpreter
Интерпретатор Python - это то, что используется для запуска скриптов Python.
Если он доступен и в пути поиска оболочки Unix можно запустить его, введя команду `python` за которой следует имя сценария, вызывается интерпретатор и запускается скрипт.
`hello_campers.py`
```python
print('Hello campers!')
```
От терминала:
```
$ python hello_campers.py
Hello campers!
```
«Когда установлены несколько версий Python, их можно использовать в зависимости от конфигурации установки. В пользовательской среде Cloud9 ide они могут быть вызваны, например:
```
$ python --version
Python 2.7.6
$ python3 --version
Python 3.4.3
$ python3.5 --version
Python 3.5.1
$ python3.6 --version
Python 3.6.2
$ python3.7 --version
Python 3.7.1
```
## Интерпретатор Python Interpreter
Интерактивный режим можно запустить, вызвав интерпретатор Python с помощью флага `-i` или без каких-либо аргументов.
Интерактивный режим имеет приглашение, в котором могут быть введены и запущены команды Python:
```
$ python3.5
Python 3.5.1 (default, Dec 18 2015, 00:00:00)
GCC 4.8.4 on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> print("Hello campers!")
Hello campers!
>>> 1 + 2
3
>>> exit()
$
```
## Дзен Питона
Некоторые из принципов, которые повлияли на дизайн Python, включены в пасхальное яйцо и могут быть прочитаны с помощью команды внутри интерактивного режима интерпретатора Python:
```
>>> import this
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!
```
## Плюсы и минусы Python
### Pros
1. Интерактивный язык с поддержкой модуля практически для всех функций.
2. Открытый исходный код: Итак, вы можете внести вклад в сообщество, функции, которые вы разработали для будущего использования, и помочь другим
3. Много хороших переводчиков и ноутбуков доступно для лучшего опыта, такого как ноутбук jupyter.
#### Cons
1. Будучи с открытым исходным кодом, многие разные способы развивались в течение года для одной и той же функции. Иногда это создает хаос для других, чтобы читать код другого.
2. Это медленный язык. Итак, очень плохой язык для разработки общих алгоритмов.
## Документация
[Python хорошо документирован](https://docs.python.org/3/) . Эти документы включают в себя руководства, руководства, ссылки и метаинформацию для языка.
Другой важной ссылкой являются предложения по улучшению Python ( [PEP](https://www.python.org/dev/peps/) ). В PEP входит руководство по стилю написания кода Python, [`PEP 8`](https://www.python.org/dev/peps/pep-0008/) .
## отладка
Операторы внутренней `print` могут использоваться для простой отладки:
> **... часто самый быстрый способ отладки программы состоит в том, чтобы добавить в исходный код несколько операторов печати: быстрый цикл редактирования-тестирования-отладки делает этот простой подход очень эффективным.**
>
> \- [Резюме](https://www.python.org/doc/essays/blurb/)
Python также включает более мощные инструменты для отладки, такие как:
* модуль [_регистрации_](https://docs.python.org/3/library/logging.html) , [_протоколирование_](https://docs.python.org/3/library/logging.html)
* модуль отладки, [_pdb_](https://docs.python.org/3/library/pdb.html)
Просто отметьте, что они существуют на данный момент.
## Привет, мир!
Возвращаясь к документам, мы можем прочитать о функции [`print`](https://docs.python.org/3/library/functions.html#print) , [_встроенной функции_](https://docs.python.org/3/library/functions.html) [стандартной библиотеки Python](https://docs.python.org/3/library/index.html) .
```
print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
```
Встроенные функции перечислены в алфавитном порядке. За именем следует скопированный список формальных параметров с необязательными значениями по умолчанию. При этом дается краткое описание функции и ее параметры, а иногда и пример.
Функция [`print`](https://docs.python.org/3/library/functions.html#print) в Python 3 заменяет оператор [`print`](https://docs.python.org/2/reference/simple_stmts.html#print) в Python 2.
```
>>> print("Hello world!")
Hello world!
```
Вызывается функция, когда за именем функции следует `()` . Для Hello world! Например, функция print вызывается со строкой в ​​качестве аргумента для первого параметра. Для остальных параметров используются значения по умолчанию.
Аргументом, который мы назвали функцией `print` является `str` объект или _строка_ , один из [_встроенных типов_](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str) Python. Также самое важное в python заключается в том, что вам не нужно указывать тип данных при объявлении переменной, компилятор python будет делать это сам по типу присвоенного значения.
Параметр `objects` имеет префикс с `*` который указывает, что функция примет произвольное количество аргументов для этого параметра.
## Хотите узнать больше?
В Free Code Camp есть отличные ресурсы. Сеть - большое место, есть еще много возможностей для изучения:
* Практическая книга Питона: http://anandology.com/python-practice-book/index.html
* Think Python: http://greenteapress.com/thinkpython/html/index.html
* Практический бизнес Python: http://pbpython.com/
* Другой курс: https://realpython.com/?utm _source = fsp & utm_ medium = promo & utm\_campaign = bestresources
* Общее: https://www.fullstackpython.com/
* Изучите основы: https://www.codecademy.com/learn/learn-python
* Компьютерные науки, использующие Python: https://www.edx.org/course/introduction-computer-science-mitx-6-00-1x-11?ref=hackernoon#!
* Список ресурсов для изучения python: https://github.com/vinta/awesome-python
* Интерактивный Python: http://interactivepython.org/runestone/static/thinkcspy/index.html
* Руководство разработчика для Python: https://devguide.python.org/

51
guide/russian/python/input-functions/index.md Normal file
View File

@@ -0,0 +1,51 @@
---
title: Python Input Function
localeTitle: Входная функция Python
---
Много раз в программе нам нужен какой-то ввод от пользователя. Ввод данных от пользователя заставляет программу чувствовать себя интерактивной. В Python 3 для ввода ввода у пользователя есть функция `input()` . Если вызывается функция ввода, поток программы будет остановлен до тех пор, пока пользователь не даст вход и не завершит вход с помощью клавиши возврата. Давайте посмотрим несколько примеров:
1. Когда мы просто хотим принять вход:
# Это просто даст подсказку без какого-либо сообщения
inp = input ()
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CUqX/0)
1. Чтобы дать подсказку с сообщением:
prompt _с_ сообщением = input (' «)
# \_
# «\_» На выходе - это приглашение
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CUqX/1)
3\. Когда мы хотим взять целочисленный ввод:
```
number = int(input('Please enter a number: '))
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CUqX/2)
Если вы введете не целое значение, тогда Python вызовет ошибку `ValueError` . **Поэтому всякий раз, когда вы используете это, убедитесь, что вы его тоже поймали.** В противном случае ваша программа неожиданно остановится после запроса.
```
number = int(input('Please enter a number: '))
# Please enter a number: as
# Enter a string and it will throw this error
# ValueError: invalid literal for int() with base 10 'as'
```
4\. Когда нам нужен ввод строки:
```
string = str(input('Please enter a string: '))
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CUqX/3)
Хотя, входы хранятся по умолчанию в виде строки. Использование функции `str()` позволяет считывателю кода понять, что вход будет «строкой». Хорошая практика - указать, какой тип ввода будет сделан заранее.
[Официальные документы](https://docs.python.org/3/library/functions.html#input)

77
guide/russian/python/installing-and-using-python-3/index.md Normal file
View File

@@ -0,0 +1,77 @@
---
title: Installing and Using Python 3
localeTitle: Установка и использование Python 3
---
## Установка Python 3
Вы можете скачать Python из этой официальной [ссылки](https://www.python.org/downloads/) . На основе вашей ОС (Windows или Linux или OSX) вы можете установить Python 3 в соответствии с [этими инструкциями](http://docs.python-guide.org/en/latest/starting/installation/) .
## Использование виртуальных сред
Это всегда отличная идея, чтобы [изолировать](https://en.wikipedia.org/wiki/Sandbox_(computer_security)) вашу установку Python; и держать его отдельно от вашего _системного Python_ . _System Python_ - это путь к интерпретатору Python, который используется другими модулями, установленными вместе с вашей ОС.
**Нельзя** устанавливать Python Web-фреймворки или библиотеки напрямую с помощью _System Python_ . Вместо этого вы можете использовать [Virtualenv](https://virtualenv.readthedocs.org/en/latest/) для создания и создания отдельного процесса Python при разработке приложений Python.
### Virtualenvwrapper
Модуль [Virtualenvwrapper](https://virtualenvwrapper.readthedocs.org/en/latest/) упрощает управление и изолировать изолированную среду Python в изолированной среде на одной машине; без искажения любых модулей или служб, написанных на Python и используемых вашей машиной.
Конечно, большинство облачных сред разработки, таких как [Nitrous](https://www.nitrous.io/) или [Cloud9,](https://c9.io/) также поставляются с предустановленной и готовой для вас кодировкой! Вы можете быстро выбрать окно из панели управления и начать кодирование после активации среды Python 3.
В [Cloud9](https://c9.io/) вам нужно выбрать поле Django при создании новой среды разработки.
Приведем несколько примеров команд оболочки. Если вы хотите скопировать-вставить, обратите внимание, что знак `$` является сокращением для подсказки терминала, это не является частью команды. Моя подсказка терминала выглядит примерно так:
```
alayek:~/workspace (master) $
```
И, `ls` будет выглядеть
```
alayek:~/workspace (master) $ ls
```
Но, написав то же самое в этой документации, я бы написал это как
```
$ ls
```
Возвращаясь к обсуждению, вы можете создать в Cloud9 программную среду Python 3 с включенным интерпретатором, работая на вашем облачном терминале:
```
$ mkvirtualenv py3 --python=/usr/bin/python3
```
Вы должны запускать его только один раз после создания нового окна для вашего проекта. После выполнения этой команды эта команда создаст новый изолированный `py3` готовый для использования, с именем `py3` .
Чтобы просмотреть доступные виртуальные среды, вы можете использовать
```
$ workon
```
Чтобы активировать `py3` , вы можете использовать команду `workon` с именем среды:
```
$ workon py3
```
Все три команды терминала выше также будут работать на локальных машинах Linux или на машинах OSX. Это команды [virtualenvwrapper](https://virtualenvwrapper.readthedocs.org/en/latest/#introduction) ; поэтому, если вы планируете их использовать, убедитесь, что этот модуль установлен и добавлен в `PATH` .
Если вы находитесь в виртуальной среде; вы можете легко найти это, проверив подсказку своего терминала. Имя среды будет четко указано в подсказке вашего терминала.
Например, когда я `py3` среду `py3` ; Я бы увидел это как подсказку моего терминала:
```
(py3)alayek:~/workspace (master) $
```
Обратите внимание на `(py3)` в фигурных скобках! Если по какой-то причине вы не видите этого, даже если вы находитесь в виртуальном env; вы можете попробовать сделать одно из [упомянутых здесь](http://stackoverflow.com/questions/1871549/python-determine-if-running-inside-virtualenv) вещей.
Выйти из виртуальной среды; или деактивировать один - используйте команду
```
$ deactivate
```
Опять же, это работает только с модулем virtualenvwrapper.
### Pipenv
Альтернативой использованию virtualenvwrapper является [Pipenv](https://docs.pipenv.org/) . Он автоматически создает виртуальные среды для ваших проектов и поддерживает `Pipfile` который содержит зависимости. Использование Pipenv означает, что вам больше не нужно использовать pip и virtualenv отдельно или управлять собственным файлом `requirements.txt` . Txt. Для тех, кто знаком с JavaScript, Pipenv похож на использование упаковочного инструмента, такого как `npm` .
Чтобы начать работу с Pipenv, вы можете следовать этому очень подробному [руководству](https://docs.pipenv.org/install.html#installing-pipenv) . Pipenv позволяет легко [указать, какую версию Python](https://docs.pipenv.org/basics.html#specifying-versions-of-python) вы хотите использовать для каждого проекта, [импортировать](https://docs.pipenv.org/basics.html#importing-from-requirements-txt) из существующего файла `requirements.txt` и [отобразить](https://docs.pipenv.org/#pipenv-graph) зависимости.

125
guide/russian/python/is-there-a-way-to-substring-a-string-in-python/index.md Normal file
View File

@@ -0,0 +1,125 @@
---
title: Is There a Way to Substring a String in Python
localeTitle: Есть ли способ подстроить строку в Python
---
## Есть ли способ подстроить строку в Python
Python предлагает множество способов подстроки строки. Его часто называют «срезанием».
Он следует этому шаблону:
```python
string[start: end: step]
```
Куда,
`start` : начальный индекс подстроки. Символ в этом индексе включен в подстроку. Если _старт_ не включен, предполагается, что он равен 0.
`end` : `end` индекс подстроки. Символ в этом индексе _НЕ_ входит в подстроку. Если _конец_ не включен или если указанное значение превышает длину строки, оно считается равным длине строки по умолчанию.
`step` : Каждый символ «step» после текущего символа, который будет включен. Значение по умолчанию равно 1. Если значение _шага_ опущено, предполагается, что оно равно 1.
#### шаблон
`string[start:end]` : получить все символы от _начала_ индекса до _конца-1_
`string[:end]` : получить все символы от начала строки до _конца-1_
`string[start:]` : получить все символы от _начала_ индекса до конца строки
`string[start:end:step]` : получить все символы от _начала_ до _конца-1,_ уклоняясь от каждого _шага_
#### Примеры
* **Получить первые 5 символов строки**
```python
string = "freeCodeCamp"
print(string[0:5])
```
Вывод:
```shell
> freeC
```
Примечание: `print(string[:5])` возвращает тот же результат, что и `print(string[0:5])`
* **Получить подстроку длиной 4 от третьего символа строки**
```python
string = "freeCodeCamp"
print(string[2:6])
```
Вывод:
```shell
> eeCo
```
Обратите внимание, что начальный или конечный индекс может быть отрицательным числом. Отрицательный индекс означает, что вы начинаете отсчет с конца строки вместо начала (т. Е. Справа налево). Индекс -1 представляет собой последний символ строки, -2 - второй и последний символы и т. Д. ...
* **Получить последний символ строки**
```python
string = "freeCodeCamp"
print(string[-1])
```
Вывод:
```shell
> p
```
* **Получить последние 5 символов строки**
```python
string = "freeCodeCamp"
print(string[-5:])
```
Вывод:
```shell
> eCamp
```
* **Получить подстроку, содержащую все символы, кроме последних 4 символов, и 1-й символ**
```python
string = "freeCodeCamp"
print(string[1:-4])
```
Вывод:
```shell
> reeCode
```
#### Дополнительные примеры
```py
str = “freeCodeCamp”
print str[-5:-2] # prints 'eCa'
print str[-1:-2] # prints '' (empty string)
```
* **Получить любой другой символ из строки**
```python
string = "freeCodeCamp"
print(string[::2])
```
Вывод:
```shell
> feCdCm
```

40
guide/russian/python/iterators/index.md Normal file
View File

@@ -0,0 +1,40 @@
---
title: Python Iterators
localeTitle: Итераторы на Python
---
Python поддерживает концепцию итерации по контейнерам. Это реализовано с использованием двух различных методов; они используются, чтобы позволить пользовательским классам поддерживать итерацию.
[Документы Python - Типы итераторов](https://docs.python.org/3/library/stdtypes.html#iterator-types)
Итерация - это процесс программного повторения шага определенное количество раз. Программист может использовать итерацию для выполнения одной и той же операции для каждого элемента в коллекции данных, например, для распечатки каждого элемента в списке.
* Объекты могут реализовать `__iter__()` который возвращает объект итератора для поддержки итерации.
* Объекты Iterator должны реализовывать:
* `__iter__()` : возвращает объект итератора.
* `__next__()` : возвращает следующий объект контейнера.
итератор _object = 'abc'. **iter** () print (_ объект _итератора_ ) print (id ( _объект_ итератора _)) print (id (iterator_ object. **iter** ())) # Возвращает сам итератор. print (iterator _object. **next** ()) # Возвращает 1-й объект и продвигает итератор. print (iterator_ object. **next** ()) # Возвращает 2-й объект и продвигает итератор. print (iterator _object. **next** ()) # Возвращает 3-й объект и продвигает итератор. print (_ объект _итератора_ **next** ()) # вызывает исключение StopIteration.
Выход :
```
<str_iterator object at 0x102e196a0>
4343305888
4343305888
a
b
c
---------------------------------------------------------------------------
StopIteration Traceback (most recent call last)
<ipython-input-1-d466eea8c1b0> in <module>()
6 print(iterator_object.__next__()) # Returns 2nd object and advances iterator.
7 print(iterator_object.__next__()) # Returns 3rd object and advances iterator.
----> 8 print(iterator_object.__next__()) # Raises StopIteration Exception.
StopIteration:
```

51
guide/russian/python/itertools/index.md Normal file
View File

@@ -0,0 +1,51 @@
---
title: Itertools
localeTitle: Itertools
---
Itertools - это модуль функций python, возвращающий генераторы, объекты, которые работают только при повторении. Некоторые примеры функций itertool включают, но не ограничиваются следующими: chain (), imap (), product () и compress ().
### цепь ()
Функция chain () принимает несколько итераторов в качестве аргументов и возвращает один итератор, который создает содержимое всех из них, как если бы они поступали из одной последовательности.
```py
import itertools
list(itertools.chain([1, 2], [3, 4]))
# Output
# [1, 2, 3, 4]
```
### Ислица ()
Функция islice () возвращает итератор, который возвращает выбранные элементы из входного итератора по индексу. Он принимает те же аргументы, что и оператор среза для списков: старт, стоп и шаг. Запуск и остановка являются необязательными.
```py
import itertools
list(itertools.islice(count(), 5))
# Output
# [0,1, 2, 3, 4]
```
### izip ()
izip () возвращает итератор, который объединяет элементы нескольких итераторов в кортежи. Он работает как встроенная функция zip (), за исключением того, что возвращает итератор вместо списка.
```py
import itertools
list(izip([1, 2, 3], ['a', 'b', 'c']))
# Output
# [(1, 'a'),(2, 'b'),(3, 'c')]
```
Комбинаторные итераторы:
Итерационные аргументы product () p, q, ... \[repeat = 1\] декартово произведение, эквивалентное вложенному циклу перестановки () p \[, r\] r-длины, все возможные упорядочения, не повторяющиеся элементы комбинаций () p, r r-length кортежей в отсортированном порядке, без повторных элементов комбинации _с_ заменами () p, r r-length кортежей в отсортированном порядке с повторяющимися элементами продукт ('ABCD', repeat = 2) AA AB AC AD BA BB BC BD CA CB CC CD DA DB DC DD перестановки ('ABCD', 2) AB AC AD BA BC BD CA CB CD DA DB DC
комбинации ('ABCD', 2) AB AC AD BC BD CD
комбинации _с_ заменой («ABCD», 2) AA AB AC AD BB BC BD CC CD DD
Источник: https: //docs.python.org/3/library/itertools.html

22
guide/russian/python/keywords/index.md Normal file
View File

@@ -0,0 +1,22 @@
---
title: Python Keywords
localeTitle: Ключевые слова Python
---
## Ключевые слова Python
В Python есть список [ключевых слов,](https://docs.python.org/3/reference/lexical_analysis.html#keywords) которые нельзя использовать в качестве идентификаторов (имена переменных). Попытка использовать любое из этих ключевых слов в качестве переменных приведет к созданию **ошибки синтаксиса,** и ваш скрипт Python не будет запущен:
```
>>> False = "Hello campers!"
File "<stdin>"
SyntaxError: can't assign to keyword
>>> break = "Hello campers!"
File "<stdin>", line 1
break = "Hello campers!"
^
SyntaxError: invalid syntax
```
#### Список ключевых слов
Ключевое слово | - | - | - | - --- | --- | --- | --- | --- `False` | `class` | `finally` | `is` | `return` `None` | `continue` | `for` | `lambda` | `try` `True` | `def` | `from` | `nonlocal` | `while` `and` | `del` | `global` | `not` | `with` `as` | `elif` | `if` | `or` | `yield` `assert` | `else` | `import` | `pass` `break` | `except` | `in` | `raise`

94
guide/russian/python/lambda-expressions/index.md Normal file
View File

@@ -0,0 +1,94 @@
---
title: Lambda Expressions
localeTitle: Лямбда-выражения
---
## Лямбда-выражения
Лямбда-выражения идеально используются, когда у нас есть что-то простое, чтобы быть сделанным, мы больше заинтересованы в быстром выполнении работы, а не в формальном названии функции. Лямбда-выражения также известны как анонимные функции. [Помогите нашему сообществу расширить его](https://github.com/freecodecamp/guides/tree/master/src/pages/python/lambda-expressions/index.md) .
Лямбда-выражения в Python - это короткий способ объявить небольшие и анонимные функции (нет необходимости указывать имя для лямбда-функций). Лямбда-функции ведут себя так же, как обычные функции, объявленные с ключевым словом `def` . Они пригождаются, когда вы хотите кратко определить небольшую функцию. Они могут содержать только одно выражение, поэтому они не подходят для функций с операторами потока управления. мастер
#### Синтаксис лямбда-функции
`lambda arguments: expression`
Лямбда-функции могут иметь любое количество аргументов, но только одно выражение
#### Пример кода
```py
# Lambda function to calculate square of a number
square = lambda x: x ** 2
print(square(3)) # Output: 9
# Traditional function to calculate square of a number
def square1(num):
return num ** 2
print(square(5)) # Output: 25
```
В приведенном выше примере `lambda x: x ** 2` дает анонимный функциональный объект, который может быть связан с любым именем. Таким образом, мы связали объект функции с `square` и, следовательно, с этого момента мы можем назвать `square` объект, как любая традиционная функция. например, `square(10)`
## Примеры
### начинающий
```py
lambda_func = lambda x: x**2 # Function that takes an integer and returns its square
lambda_func(3) # Returns 9
```
### промежуточный
```py
lambda_func = lambda x: True if x**2 >= 10 else False
lambda_func(3) # Returns False
lambda_func(4) # Returns True
```
### Сложный
```py
my_dict = {"A": 1, "B": 2, "C": 3}
sorted(my_dict, key=lambda x: my_dict[x]%3) # Returns ['C', 'A', 'B']
```
### Использование регистра
Предположим, вы хотите отфильтровать нечетные числа из `list` . Вы можете использовать цикл `for` :
```python
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
filtered = []
for num in my_list:
if num % 2 != 0:
filtered.append(num)
print(filtered) # Python 2: print filtered
# [1, 3, 5, 7, 9]
```
You could write this as a one liner with list-comprehensions
```
питон filter = \[x для x в \[1, 2, 3, 4, 5, 6, 7, 8, 9, 10\], если x% 2! = 0\] \`\` \`
Но у вас может возникнуть соблазн использовать встроенную функцию `filter` . Зачем? Первый пример - немного подробный, однострочный может быть сложнее понять, где в качестве `filter` предлагает лучшее из обоих слов. Более того, встроенные функции обычно быстрее.
\`\` \`\` Питон my\_list = \[1, 2, 3, 4, 5, 6, 7, 8, 9, 10\]
filter = filter (lambda x: x% 2! = 0, my\_list)
Список (фильтруется)
# \[1, 3, 5, 7, 9\]
` `` NOTE: in Python 3 built in function return generator objects, so you have to call` список `, while in Python 2 they return a` список `,` кортеж `or` строку\`.
Что случилось? Вы сказали, что `filter` принимает каждый элемент в `my_list` и применяет лямбда-выражения. Значения, возвращающие `False` , отфильтровываются.
#### Дополнительная информация:
* [Официальный документ](https://docs.python.org/3/reference/expressions.html#lambda)
* [Дальнейшее чтение](https://dbader.org/blog/python-lambda-functions)

35
guide/russian/python/learn-about-python-sets/index.md Normal file
View File

@@ -0,0 +1,35 @@
---
title: Learn About Python Sets
localeTitle: Узнайте о наборах Python
---
`Set` s в Python - это тип изменяемой, но неупорядоченной структуры данных, которая может содержать только _уникальные_ элементы.
**Создание:**
`set` literal:
Кулистые скобки `{}` _не_ могут использоваться для создания пустого набора:
```python
>>> not_set = {} # set constructor must be used to make empty sets.
>>> type(not_set) # Empty curly brackets create empty dictionaries.
<class 'dict'>
```
Вы можете создать пустой набор с помощью метода `set()` .
```python
>>> example_set = set()
>>> type(example_set)
<class 'set'>
```
Однако, если элементы включены в фигурные скобки, тогда было бы приемлемым синтаксисом для создания набора.
```python
>>> example_set_2 = {1, 2, 3}
>>> type(example_set_2)
<class 'set'>
```
\`

32
guide/russian/python/len-function/index.md Normal file
View File

@@ -0,0 +1,32 @@
---
title: Python Len Function
localeTitle: Функция Python Len
---
`len()` - встроенная функция в Python 3. Этот метод возвращает длину (количество элементов) объекта. Он принимает один аргумент `x` .
## аргументы
Он принимает один аргумент, `x` . Этот аргумент может быть последовательностью (например, строкой, байтами, кортежем, списком или диапазоном) или набором (например, словарем, набором или замороженным набором).
## Возвращаемое значение
Эта функция возвращает количество элементов в аргументе, передаваемом функции `len()` .
## Образец кода
```
list1 = [123, 'xyz', 'zara'] # list
print(len(list1)) # prints 3 as there are 3 elements in the list1
str1 = 'basketball' # string
print(len(str1)) # prints 10 as the str1 is made of 10 characters
tuple1 = (2, 3, 4, 5) # tuple
print(len(tuple1)) # prints 4 as there are 4 elements in the tuple1
dict1 = {'name': 'John', 'age': 4, 'score': 45} # dictionary
print(len(dict1)) # prints 3 as there are 3 key and value pairs in the dict1
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CUmt/15)
[Официальные документы](https://docs.python.org/3/library/functions.html#len)

32
guide/russian/python/list-deque/index.md Normal file
View File

@@ -0,0 +1,32 @@
---
title: Deque
localeTitle: и
---
## Использование списка в качестве очередей
Также возможно использовать список в качестве очереди, где требуется операция FIFO («первый вход, первый выход»). Списки не эффективны как очередь при использовании добавок и всплывающих окон, поскольку она может замедляться, поскольку все элементы должны быть сдвинуты на один для каждого добавления / всплытия.
Чтобы реализовать очередь, используйте collection.deque, который был разработан для быстрого добавления и всплывания с обоих концов.
#### Пример использования
```py
from collections import deque
queue = deque(["January", "February", "March", "April"] )
queue.append("May")
queue.popleft()
queue.popleft()
print "Spring months in the list: ", queue
```
#### Вывод
```
Spring months in the list: deque(['March', 'April', 'May'])
```
#### Дополнительная информация:
Официальную документацию для `collections.deque` можно найти [здесь](https://docs.python.org/3/library/collections.html#collections.deque)

124
guide/russian/python/lists/index.md Normal file
View File

@@ -0,0 +1,124 @@
---
title: Lists
localeTitle: Списки
---
**TODO: `list` основных сведений**
[Документы Python - Списки](https://docs.python.org/3/library/stdtypes.html#lists)
**Создание:**
Пустой `list` создается с помощью пары квадратных скобок:
```shell
>>> empty_list = []
>>> type(empty_list)
<class 'list'>
>>> len(empty_list)
0
```
`list` может быть создан с помощью элементов, заключая в список разделенных запятыми элементов с квадратными скобками. Списки позволяют использовать элементы разных типов (гетерогенные), но чаще всего однотипные (однородные):
```shell
>>> homogeneous_list = [1, 1, 2, 3, 5, 8]
>>> type(homogeneous_list)
<class 'list'>
>>> print(homogeneous_list)
[1, 1, 2, 3, 5, 8]
>>> len(homogeneous_list)
6
>>> heterogeneous_list = [1, "Hello Campers!"]
>>> print(heterogeneous_list)
[1, "Hello Campers!"]
>>> len(heterogeneous_list)
2
```
Конструктор `list` также можно использовать для создания `list` :
```shell
>>> empty_list = list() # Creates an empty list
>>> print(empty_list)
[]
>>> list_from_iterable = list("Hello campers!") # Creates a list from an iterable.
>>> print(list_from_iterable)
['H', 'e', 'l', 'l', 'o', ' ', 'c', 'a', 'm', 'p', 'e', 'r', 's', '!']
```
**Доступ к элементам `list` :**
```shell
>>> my_list = [1, 2, 9, 16, 25]
>>> print(my_list)
[1, 2, 9, 16, 25]
```
_Нулевой индекс_
```shell
>>> my_list[0]
1
>>> my_list[1]
2
>>> my_list[2]
9
```
_Обтекание индексации_
```shell
>>> my_list[-1]
25
>>> my_list[-2]
16
```
_Распаковка списков для python-3_
```shell
>>> print(*my_list)
1 2 9 16 25
```
**Mutable:**
`lists` являются изменяемыми контейнерами. Конвертируемые контейнеры представляют собой контейнеры, которые допускают внесение изменений в объекты, содержащиеся в контейнере. **TODO: ДОБАВИТЬ БОЛЬШЕ?**
_Переустановка элементов в списке_
Элементы из `list` могут быть извлечены и перенастроены с использованием другого `list` качестве индекса.
```shell
>>> my_list = [1, 2, 9, 16, 25, 34, 53, 21]
>>> my_index = [5, 2, 0]
>>> my_new_list = [my_list[i] for i in my_index]
>>> print(my_new_list)
[34, 9, 1]
```
**TODO: Какие из них следует обсудить здесь:**
[Документы Python - дополнительные сведения о списках](https://docs.python.org/3/tutorial/datastructures.html#more-on-lists)
* `list.append(x)` Добавить элемент в конец списка. Эквивалентен \[len (a):\] = \[x\].
* `list.extend(L)` Расширить список, добавив все элементы в данный список. Эквивалентен \[len (a):\] = L.
* `list.insert(i, x)` Вставить элемент в заданную позицию. Первый аргумент - это индекс элемента, перед которым нужно вставить, поэтому a.insert (0, x) вставлен в начале списка, а a.insert (len (a), x) эквивалентен a.append ( Икс).
* `list.remove(x)` Удалить первый элемент из списка, значение которого равно x. Это ошибка, если такой элемент отсутствует.
* `list.pop([i])` Удалите элемент в указанной позиции в списке и верните его. Если индекс не указан, a.pop () удаляет и возвращает последний элемент в списке. (Квадратные скобки вокруг i в сигнатуре метода означают, что параметр является необязательным, а не то, что вы должны вводить квадратные скобки в этой позиции. Вы часто увидите эту нотацию в Справочнике по библиотеке Python.)
* `list.clear()` Удалить все элементы из списка. Эквивалентен del a \[:\].
* `list.index(x)` Возвращает индекс в списке первого элемента, значение которого равно x. Это ошибка, если такой элемент отсутствует.
* `list.count(x)` Возвращает количество раз, когда x отображается в списке.
* `list.sort(key=None, reverse=False)` Сортировка элементов списка на месте (аргументы могут использоваться для настройки сортировки, см. sorted () для их объяснения).
* `list.reverse()` элементы списка на место.
* `list.copy()` Верните мелкую копию списка. Эквивалентен \[:\].

26
guide/russian/python/lists/list-append-method/index.md Normal file
View File

@@ -0,0 +1,26 @@
---
title: List Append Method
localeTitle: Метод добавления списка
---
## Метод добавления списка
Существует множество методов для списков, вы можете изучить их все, набрав `help(list)` в вашей консоли python. Одна из них - это функция добавления, которая, как сказано в названии, добавляет приведенный аргумент.
#### Пример использования
```py
words = ["I", "love", "Python"]
words.append("very much")
print(words)
```
#### Вывод
```
["I", "love", "Python", "very much"]
```
Как вы могли заметить, элемент `"very much"` добавлен в список.
#### Дополнительная информация:
Официальную документацию для `append()` можно найти [здесь](https://docs.python.org/3.6/tutorial/datastructures.html)

116
guide/russian/python/lists/list-comprehension/index.md Normal file
View File

@@ -0,0 +1,116 @@
---
title: List Comprehension
localeTitle: Учет списка
---
## Учет списка
List Comprehension - это способ перебирать список, чтобы создать новый список, основанный на некоторых условиях. Сначала это может сбивать с толку, но как только вы приспосабливаетесь к синтаксису, он очень мощный и быстрый.
Первым шагом в обучении использованию понимания списка является просмотр традиционного способа перебора списка. Ниже приведен простой пример, который возвращает новый список четных чисел.
```python
# Example list for demonstration
some_list = [1, 2, 5, 7, 8, 10]
# Empty list that will be populate with a loop
even_list = []
for number in some_list:
if number % 2 == 0:
even_list.append(number)
# even_list now equals [2, 8, 10]
```
Сначала создается список с некоторыми числами. Затем вы создаете пустой список, который будет удерживать ваши результаты в цикле. В цикле вы проверяете, является ли каждое число делимым на 2, и если вы добавите его в список четных. Это заняло 5 строк кода, не включая комментарии и пробелы, что в этом примере мало.
Теперь для примера понимания списка.
```python
# Example list for demonstration
some_list = [1, 2, 5, 7, 8, 10]
# List Comprehension
even_list = [number for number in some_list if number % 2 == 0]
# even_list now equals [2, 8, 10]
```
Другой пример, с теми же двумя шагами: Ниже будет создан список номеров, соответствующих номерам в `my_starting_list` умноженном на 7.
```py
my_starting_list = [1, 2, 3, 4, 5, 6, 7, 8]
my_new_list = []
for item in my_starting_list:
my_new_list.append(item * 7)
```
Когда этот код запускается, конечным значением `my_new_list` является: `[7, 14, 21, 28, 35, 42, 49, 56]`
Разработчик, использующий понимание списков, может достичь того же результата, используя следующее понимание списка, которое приводит к тому же `my_new_list` .
```py
my_starting_list = [1, 2, 3, 4, 5, 6, 7, 8]
my_new_list = [item * 7 for item in my_starting_list]
```
Простая формула для записи в способе составления списка:
`my_list = [{operation with input n} for n in {python iterable}]`
Замените `{operation with input n}` однако вы хотите изменить элемент, возвращенный из итерабельного. В приведенном выше примере используется `n * 7` но операция может быть как простой, так и сложной по мере необходимости.
Замените `{python iterable}` любым итерабельным. [Типы последовательности](https://guide.freecodecamp.org/python/sequence-types) будут наиболее распространены. Список был использован в приведенном выше примере, но кортежи и диапазоны также распространены.
Понимание списка добавляет элемент из существующего списка в новый список, если выполняется какое-либо условие. Он более аккуратный, но в большинстве случаев он намного быстрее. В некоторых случаях понимание списка может затруднять читаемость, поэтому разработчик должен взвесить свои параметры, когда вы выбираете использование списка.
## Примеры понимания списка с помощью условных выражений
Поток управления в списках можно контролировать с помощью условных выражений. Для exmaple:
```py
only_even_list = [i for i in range(13) if i%2==0]
```
Это эквивалентно следующему циклу:
```py
only_even_list = list()
for i in range(13):
if i%2 == 0:
only_even_list.append(i)
```
Учет списка также может содержать вложенные условия. Рассмотрим следующий цикл:
```py
divisible = list()
for i in range(50):
if i%2 == 0:
if i%3 == 0:
divisible.append(i)
```
Используя понимание списка, это можно записать так:
```py
divisible = [i for i in range(50) if i%2==0 if i%3==0]
```
Оператор If-Else также может использоваться вместе со списком.
```py
list_1 = [i if i%2==0 else i*-1 for i in range(10)]
```
#### Дополнительная информация:
[Структуры данных Python - Списки](https://docs.python.org/2.7/tutorial/datastructures.html)
[Python for Loops](https://guide.freecodecamp.org/python/for-loop-statements)
[Списки Python](https://guide.freecodecamp.org/python/learn-about-python-lists)
[Python для начинающих - список понятий](http://www.pythonforbeginners.com/basics/list-comprehensions-in-python)

25
guide/russian/python/lists/list-extend-method/index.md Normal file
View File

@@ -0,0 +1,25 @@
---
title: List Extend Method
localeTitle: Метод расширения списка
---
## Метод расширения списка
Существует множество методов для списков, вы можете изучить их все, набрав `help(list)` в вашей консоли python. Одна из них - это функция расширения, которая, как сказано в названии, расширяет список, добавляя все элементы списка (переданные как аргумент) до конца.
#### Пример использования
```py
cities = ["San Francisco", "Los Angeles", "New York"]
cities_in_texas = ["San Antonio", "Austin", "Dallas"]
cities.extend(cities_in_texas)
print(cities)
```
#### Вывод
```
["San Francisco", "Los Angeles", "New York", "San Antonio", "Austin", "Dallas"]
```
#### Дополнительная информация:
Официальную документацию для `extend()` можно найти [здесь](https://docs.python.org/3.6/tutorial/datastructures.html)

59
guide/russian/python/lists/list-index-method/index.md Normal file
View File

@@ -0,0 +1,59 @@
---
title: List Index Method
localeTitle: Метод индекса списка
---
## Метод индекса списка
Среди множества функций, которые входят вместе со структурой данных списка, `index()` возвращает первое вхождение / индекс элемента в списке, заданном как аргумент функции.
Списки представляют собой самую основную структуру данных Python и сохраняют список значений по порядку (по сравнению со словарями, порядок которых не имеет значения). Мы извлекаем элементы по числовому индексу.
Имея в виду тот факт, что индексирование начинается с 0 или первый элемент считается индексом 0, давайте посмотрим на некоторые примеры.
#### Пример использования:
```py
numbers = [1, 2, 2, 3, 9, 5, 6, 10]
words = ["I", "love", "Python", "I", "love"]
print(numbers.index(9))
print(numbers.index(2))
print(words.index("I"))
print(words.index("am"))
```
##### Вывод:
```py
4
1
0
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: 'am' is not in list
```
Здесь первый вывод очень очевиден, но второй и третий могут показаться запутанными вначале. Но помните, что `index()` возвращает первое вхождение элемента и, следовательно, в этом случае `1` и `0` являются индексами, где `2` и `"I"` встречаются первыми в списках соответственно.
Кроме того, если элемент не найден в списке, возвращается значение `ValueError` как в случае индексации `"am"` в списке `words` .
#### Дополнительные аргументы:
Вы также можете использовать необязательные аргументы, чтобы ограничить поиск определенной подпоследовательностью списка, как показано в этом примере:
```py
words = ["I","am", "a", "I", "am", "Pythonista"]
print(words.index("am",2,5))
```
##### Вывод:
```
4
```
Здесь, хотя элемент выполняется поиск между индексами 2 (включительно) и 5 ​​(не включительно), но возвращаемый индекс вычисляется относительно начала полного списка, а не аргумента start.
#### Дополнительная информация:
Официальную документацию для `index()` можно найти [здесь](https://docs.python.org/3.6/tutorial/datastructures.html)

88
guide/russian/python/lists/list-map-filter-reduce/index.md Normal file
View File

@@ -0,0 +1,88 @@
---
title: Map, Reduce, Filter
localeTitle: Карта, Уменьшить, Фильтровать
---
# Карта, Уменьшить & Фильтровать
Большинство инженеров работают со списками, чтобы обрабатывать список заказов / пользователей и т. Д. Анализ списков может быть сложным и загроможденным быстро, если используется несколько циклов for-loop и вложенных циклов. Следовательно, эти вышеописанные методы могут оптимизировать использование операций с списками.
## карта
Если ваша задача - применить конкретный метод к каждому элементу списка, карта будет полезна. Скажем, у вас есть список значений степени, и вы хотите преобразовать все эти значения в список значений в единицах Fahrenheit.
#### Пример использования
```py
inputs = [10,32,5,40,25]
def degreesToFahren(deg):
fahrenheit = (9.0/5)*deg +32
return fahrenheit
# The most common way of doing this
result=[]
for i in inputs:
iTofahren = degreesToFahren(i)
result.append(iTofahren)
print(result) # [50.0, 89.6, 41.0, 104.0, 77.0]
```
```py
# Using Map
result = list(map(degreesToFahren,inputs))
print(result) # [50.0, 89.6, 41.0, 104.0, 77.0]
```
Как вы могли заметить, использование карты - это просто операция с одним лайнером. Как правило, если у вас есть данные = `[a1,a2,...,an]` и функция `f()` , тогда `map(f,data):` возвращает итератор по `f(a1),f(a2)...f(an).` use `list()` чтобы преобразовать объект итератора в список python.
## Фильтр
Функция фильтра удаляет данные в списке, который вам нужен / не нужен, следовательно, имя. Скажем, вы хотите отфильтровать список на основе значений, которые вам не нужны, например, значения выше 2.
#### Пример использования
```py
data = [1.2,2.5,5.8,0.4,4.7,9.9]
result = list(filter(lambda x:x > 2,data))
print(result)
```
#### Вывод
```
[2.5, 5.8, 4.7, 9.9]
```
Это также простой 1 лайнер, похожий на вышеприведенную функцию map (). Обратитесь к руководству по лямбда-функциям, если этот термин незначителен.
## уменьшить
От создателя Python, Guido van Rossum `"Use functools.reduce if you really need it; however, 99% of the time an explicit for loop is more readable"`
Как правило, это применить функцию `f()` к элементам данных в списке и использовать этот результат для следующего значения в списке. Визуально,
Данные = \[a 1 , a 2 , ..., a n \] функция = f (x, y)
снизить (е, данных): Шаг 1: val 1 = f (a 1 , a 2 ) Шаг 2: val 2 = f (val 1 , a 3 ) Шаг 3: val 3 = f (val 2 , a 4 ) , , , Шаг n-1: val n-1 = f (val n-2 , a n )
Например, вы хотите умножить все числа в списке.
#### Пример использования
```py
from functools import reduce
input = [1,2,3,4,5,6]
multiplier = lambda x,y:x*y
answer = reduce(multiplier,input)
print(answer)
```
#### Вывод
```
720
```
Однако вышеизложенное может быть вычислено с использованием простого цикла, и использование этих методов зависит от предпочтений.
#### Дополнительная информация:

31
guide/russian/python/lists/list-pop/index.md Normal file
View File

@@ -0,0 +1,31 @@
---
title: List Pop Method
localeTitle: Список методов поп-музыки
---
# Функция Pop
Метод pop () удаляет и возвращает последний элемент из списка. Существует необязательный параметр, индекс элемента, который должен быть удален из списка. Если индекс не указан, a.pop () удаляет и возвращает последний элемент в списке. Если индекс, переданный методу pop (), не находится в диапазоне, он вызывает IndexError: индекс pop index вне диапазона.
#### Пример использования
\`\` \`Ру города = \['Нью-Йорк', 'Даллас', 'Сан-Антонио', 'Хьюстон', 'Сан-Франциско'\];
print "City popped is:", cities.pop () print "Город по индексу 2:", cities.pop (2) \`\` \`
\#### Выход `City popped is : San Francisco City at index 2 is : San Antonio`
#### Основные функции стека
Метод `pop()` часто используется вместе с `append()` для реализации базовых функций стека в приложении Python.
```py
stack = []
for i in range(5):
stack.append(i)
while len(stack):
print(stack.pop())
```
\#### Дополнительная информация: Официальную документацию для `pop()` можно найти [здесь](https://docs.python.org/3.6/tutorial/datastructures.html)

40
guide/russian/python/lists/list-remove-method/index.md Normal file
View File

@@ -0,0 +1,40 @@
---
title: List Remove Method
localeTitle: Список Удалить метод
---
## Список Удалить метод
Метод `remove()` удаляет аргумент, предоставленный ему из списка.
#### Пример использования
```py
words = ["I", "love", "Python"]
words.remove("I")
print(words)
```
#### Вывод
```py
["love","Python"]
```
Обратите внимание, что он возвращает ошибку, если элемент, который нужно удалить, не найден в списке, как показано в примере ниже.
```py
kiss = ["keep", "it", "simple", "stupid"]
kiss.remove("complex")
print(kiss)
```
#### Вывод
```
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list
```
#### Дополнительная информация:
Более подробную информацию о `remove()` можно найти [здесь.](https://docs.python.org/3.6/tutorial/datastructures.html)

109
guide/russian/python/lists/list-sort-method/index.md Normal file
View File

@@ -0,0 +1,109 @@
---
title: List Sort Method
localeTitle: Метод сортировки списка
---
## Метод сортировки списка
Списки Python имеют встроенный метод `sort()` который изменяет список на месте и функцию `sorted()` которая создает новый отсортированный список из итерабельного.
list.sort (key = ..., reverse = \[True / False\])
### параметры
Для этого метода есть два необязательных параметра _key_ - входное значение для ключевого параметра должно быть функцией, которая принимает один аргумент и возвращает значение, используемое для сравнения, для сортировки элементов в списке _обратное = \[значение\]_ _value = True_ : сортирует элементы в списке в порядке убывания _value = False_ : сортирует элементы в списке в порядке возрастания. Это считается значением по умолчанию. Обратите внимание, что метод `sort()` не возвращает никакого значения. Он изменяет исходный список.
### Пример использования
```py
a = [4, 2, 5, 3, 1]
a.sort()
print a # prints [1, 2, 3, 4, 5]
b = ['free', 'code', 'camp']
b.sort()
print b # prints ['camp', 'code', 'free']
```
Рассмотрим пример с **обратным** параметром
```py
a = [4, 2, 5, 3, 1]
#Sorts the list in descending order
a.sort(reverse=True)
print a # prints [5, 4, 3, 2, 1]
```
Если вы хотите отсортировать список на основе собственной функции, используйте параметр **ключа** . Ниже приведен пример сортировки строк в списке по длине, в порядке возрастания
```py
a = ["hello", "hi", "hey"]
#The built-in len() function is given as an input to key parameter to sort the strings by length
a.sort(key = len)
print a # prints ['hi', 'hey', 'hello']
```
Вот еще один пример, в котором список содержит кортежи (имя, возраст). Ниже показано, как сортировать список по возрасту в порядке возрастания.
```py
#Consider the second element in the tuple for sorting
>>> def compareByAge(element):
... return element[1]
b = [('Adam', 20), ('Rahman', 30), ('Rahul', 25)]
#Sort the list by age
b.sort(key = compareByAge)
#Output
print b # prints [('Adam', 20), ('Rahul', 25), ('Rahman', 30)]
```
### Основы сортировки
Простое восходящее сортирование очень просто - просто вызовите функцию sorted (). Он возвращает новый отсортированный список:
```python
>>> sorted([5, 2, 3, 1, 4])
[1, 2, 3, 4, 5]
```
Вы также можете использовать метод list.sort () списка. Он изменяет список на месте (и возвращает None, чтобы избежать путаницы). Обычно это менее удобно, чем отсортировано (), но если вам не нужен исходный список, он немного эффективнее.
```python
>>> a = [5, 2, 3, 1, 4]
>>> a.sort()
>>> a
[1, 2, 3, 4, 5]
```
Другое отличие состоит в том, что метод list.sort () определен только для списков. Напротив, функция sorted () принимает любой итерабельный.
```python
>>> sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})
[1, 2, 3, 4, 5]
```
#### Детали реализации
Если вы хотите узнать подробности о реализации функции сортировки, см. [Здесь](http://svn.python.org/projects/python/trunk/Objects/listsort.txt) алгоритм, временную сложность и т. Д. Вкратце, функция сортировки использует алгоритм TimSort, который, согласно разработчикам Python, представляет собой: -
> адаптивное, стабильное, естественное объединение, скромно называемое timsort (эй, я заработал это ). Он обладает сверхъестественными характеристиками на многих виды частично упорядоченных массивов (требуется меньше, чем lg (N!)), и всего лишь N-1), но так же быстро, как предыдущая высоконадежная модель данных Python гибрид на случайных массивах.
#### sort () Параметры
По умолчанию sort () не требует дополнительных параметров. Однако он имеет два необязательных параметра:
* reverse - если true, отсортированный список отменяется (или сортируется в порядке убывания)
* key - функция, которая служит ключом для сравнения сортировки
#### Дополнительная информация:
Более подробную информацию о `sort()` можно найти [здесь](https://docs.python.org/3/library/functions.html#sorted)
Более подробную информацию о sort () и sorted () можно найти [здесь](https://docs.python.org/3.6/tutorial/datastructures.html)
Более подробную информацию о sort () и sorted () можно найти [здесь](https://docs.python.org/3.6/tutorial/datastructures.html) .

51
guide/russian/python/max-function/index.md Normal file
View File

@@ -0,0 +1,51 @@
---
title: Python Max Function
localeTitle: Функция Python Max
---
`max()` - встроенная функция в Python 3. Она возвращает наибольший элемент в итерабельном или самом большом из двух или более аргументов.
## аргументы
Эта функция принимает в качестве аргумента два или более числа или любой итерабельный. Предоставляя итерабельность в качестве аргумента, мы должны убедиться, что все элементы в iterable имеют один и тот же тип. Это означает, что мы не можем передать список, в котором хранятся как строковые, так и целочисленные значения. Синтаксис: max (iterable, \* iterables \[, key, default\]) max (arg1, arg2, \* args \[, key\])
Допустимые аргументы:
```
max(2, 3)
max([1, 2, 3])
max('a', 'b', 'c')
```
Недопустимые аргументы:
```
max(2, 'a')
max([1, 2, 3, 'a'])
max([])
```
## Возвращаемое значение
Возвращается самый большой элемент в iterable. Если предоставляются два или более позиционных аргумента, возвращается наибольший из аргументов positional. Если итерабельность пуста и значение по умолчанию не указано, повышается значение `ValueError` .
## Образец кода
```
print(max(2, 3)) # Returns 3 as 3 is the largest of the two values
print(max(2, 3, 23)) # Returns 23 as 23 is the largest of all the values
list1 = [1, 2, 4, 5, 54]
print(max(list1)) # Returns 54 as 54 is the largest value in the list
list2 = ['a', 'b', 'c' ]
print(max(list2)) # Returns 'c' as 'c' is the largest in the list because c has ascii value larger then 'a' ,'b'.
list3 = [1, 2, 'abc', 'xyz']
print(max(list3)) # Gives TypeError as values in the list are of different type
#Fix the TypeError mentioned above first before moving on to next step
list4 = []
print(max(list4)) # Gives ValueError as the argument is empty
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CVok)
[Официальные документы](https://docs.python.org/3/library/functions.html#max)

52
guide/russian/python/min-function/index.md Normal file
View File

@@ -0,0 +1,52 @@
---
title: Python Min Function
localeTitle: Функция Python Min
---
`min()` является встроенной функцией в Python 3. Она возвращает наименьший элемент в итерабельном или наименьшем из двух или более аргументов.
## аргументы
Эта функция принимает в качестве аргумента два или более числа или любой итерабельный. Предоставляя итерабельность в качестве аргумента, мы должны убедиться, что все элементы в iterable имеют один и тот же тип. Это означает, что мы не можем передать список, в котором хранятся как строковые, так и целочисленные значения.
Допустимые аргументы:
```
min(2, 3)
min([1, 2, 3])
min('a', 'b', 'c')
```
Недопустимые аргументы:
```
min(2, 'a')
min([1, 2, 3, 'a'])
min([])
```
## Возвращаемое значение
Возвращается наименьший элемент в iterable. Если предоставляются два или более позиционных аргумента, наименьший из аргументов позиционирования
возвращается. Если итерабельность пуста и значение по умолчанию не указано, повышается значение ValueError.
## Образец кода
```
print(min(2, 3)) # Returns 2 as 2 is the smallest of the two values
print(min(2, 3, -1)) # Returns -1 as -1 is the smallest of the two values
list1 = [1, 2, 4, 5, -54]
print(min(list1)) # Returns -54 as -54 is the smallest value in the list
list2 = ['a', 'b', 'c' ]
print(min(list2)) # Returns 'a' as 'a' is the smallest in the list in alphabetical order
list3 = [1, 2, 'abc', 'xyz']
print(min(list3)) # Gives TypeError as values in the list are of different type
#Fix the TypeError mentioned above first before moving on to next step
list4 = []
print(min(list4)) # Gives ValueError as the argument is empty
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CVir/4)
[Официальные документы](https://docs.python.org/3/library/functions.html#min)

9
guide/russian/python/more-built-in-types/index.md Normal file
View File

@@ -0,0 +1,9 @@
---
title: Python More Built in Types
localeTitle: Python Больше встроенных типов
---
В следующих разделах описываются стандартные типы, встроенные в интерпретатор.
Основными встроенными типами являются числа, последовательности, сопоставления, классы, экземпляры и исключения.
Некоторые классы коллекций изменяемы. Методы, которые добавляют, вычитают или переставляют свои члены на место и не возвращают определенный элемент, никогда не возвращают сам экземпляр коллекции, но None.

68
guide/russian/python/mutability-and-variable-assignments/index.md Normal file
View File

@@ -0,0 +1,68 @@
---
title: Python Mutability and Variable Assignments
localeTitle: Mutability Python и назначения переменных
---
> Каждый объект имеет идентификатор, тип и значение. Идентификация объекта никогда не изменяется после его создания; вы можете думать об этом как о адресе объекта в памяти. [источник](https://docs.python.org/3/reference/datamodel.html#data-model)
После создания `object` тип и идентификатор не могут быть изменены. Независимо от того, изменится ли значение (ы) объекта после его создания, определяет, является ли объект изменчивым (может изменяться) или неизменным (не может измениться).
До сих пор мы узнали о нескольких типах объектов и их подклассах: `string` и числовых (целых, плавающих, сложных и логических) объектах. Все это **неизменные** объекты.
Сначала эта концепция может сбивать с толку, потому что то, что хорошо, является объектом, если вы не можете его изменить. То, что делает эти объекты полезными, - это возможность назначать и переназначать переменные. Функции и операторы могут возвращать новые объекты, которые могут быть назначены переменным.
Используя встроенную [функцию id](https://docs.python.org/3/library/functions.html#id) , которая возвращает идентификатор объекта, мы можем видеть, как это работает.
Вот несколько вещей, которые нужно иметь в виду:
* Назначение переменной не означает, что _переменная_ является _объектом_ . Мы использовали очень специфический язык, отметив, что _операторы присваивания_ **связывают** **имя** (идентификатор) с _объектом_ . Переменные можно переназначить:
\`питон
> > > a = 1 # Привязать к объекту.
> > > Ида)
> > > 140355241530152
> > > a = 2 # Перевяжите a другому объекту.
> > > Ида)
> > > 140355241530128
> > > \`
* Присвоение двух разных переменных _неизменяемым объектам_ с одинаковым значением может привести (не гарантируется) к ним, связанным с одним и тем же _объектом_
\`питон
> > > a = 1
> > > b = 1
> > > Ида)
> > > 140355241530152
> > > id (b) # В этом случае a и b привязаны к одному и тому же объекту.
> > > 140355241530152
> > > \`
* Назначение двух разных переменных для _объектов_ с разными значениями всегда приведет к их привязке к различным _объектам_ :
\`питон
> > > a = 1
> > > b = 2
> > > Ида)
> > > 140355241530152
> > > id (b) # a и b связаны с разными объектами.
> > > 140355241530128
> > > \`
* Переназначение переменных не изменяет исходный объект, он связывает их с другим объектом.
\`питон
> > > a = 1
> > > b = 1
> > > Ида)
> > > 140355241530152
> > > Идентификатор (б)
> > > 140355241530152
> > > a = 2
> > > id (a) # a - отскок другого объекта.
> > > 140355241530128
> > > id (b) # b все еще привязан к исходному объекту.
> > > 140355241530152
> > > \`

28
guide/russian/python/name-binding-and-aliasing-functions/index.md Normal file
View File

@@ -0,0 +1,28 @@
---
title: Python Name Binding and Aliasing Functions
localeTitle: Функции связывания и слияния имени Python
---
Определение функции вводит имя функции в текущей таблице символов. Значение имени функции имеет тип, который распознается интерпретатором как пользовательская функция.
```
>>> something = 1
>>> type(something)
<type 'int'>
>>> def something():
... pass
...
>>> type(something)
<type 'function'>
>>> something = []
>>> type(something)
<type 'list'>
```
Это значение может быть присвоено другому имени, которое затем также может использоваться как функция. Это служит общим механизмом переименования:
```
>>> fib
<function fib at 10042ed0>
>>> f = fib
>>> f(100)
0 1 1 2 3 5 8 13 21 34 55 89
```

105
guide/russian/python/nested-functions/index.md Normal file
View File

@@ -0,0 +1,105 @@
---
title: Nested Functions in Python
localeTitle: Вложенные функции в Python
---
### Пространства имен
Параметры функции, а также любые переменные, которые связаны (посредством присвоения или другими операторами привязки, такими как def) в теле функции, составляют локальное пространство имен функции, также известное как локальная область. Каждая из этих переменных известна как локальная переменная функции.
Переменные, которые не являются локальными, известны как глобальные переменные (при отсутствии определений вложенных функций, которые мы обсудим в ближайшее время). Глобальные переменные являются атрибутами объекта модуля, как описано в «Атрибутах объектов модуля» на стр. 140. Всякий раз, когда локальная переменная функции имеет то же имя, что и глобальная переменная, это имя в теле функции относится к локальной переменной, а не глобальный. Мы выражаем это, говоря, что локальная переменная скрывает глобальную переменную с тем же именем во всем теле функции.
### Глобальное заявление
По умолчанию любая переменная, связанная внутри тела функции, является локальной переменной функции. Если функции необходимо перестроить некоторые глобальные переменные, первая утверждение функции должно быть:
глобальные идентификаторы
где идентификаторы - один или несколько идентификаторов, разделенных запятыми (,). Идентификаторы, перечисленные в глобальном заявлении, относятся к глобальным переменным (т. Е. Атрибутам объекта модуля), которые функция должна перестраивать. Например, счетчик функций, который мы видели в «Другие атрибуты объектов функций» на стр. 73, может быть реализован с использованием глобальной и глобальной переменных, а не атрибута объекта функции:
\_count = 0 def counter (): глобальный \_count \_count + = 1 return \_count
Без глобального оператора функция счетчика вызовет исключение UnboundLocal-Error, потому что \_count тогда будет неинициализированной (несвязанной) локальной переменной. Хотя глобальное заявление допускает такой вид программирования, этот стиль часто неэлегантен и нецелесообразен. Как я упоминал ранее, когда вы хотите сгруппировать какое-то состояние и какое-то поведение, объектно-ориентированные механизмы, описанные в главе 5, обычно лучше всего.
Не используйте global, если тело функции просто использует глобальную переменную (включая мутацию объекта, привязанного к этой переменной, если объект изменен). Используйте глобальный оператор только в том случае, если тело функции восстанавливает глобальную переменную (обычно назначая имя переменной). В отношении стиля, не используйте глобальные, если это строго необходимо, так как его присутствие заставит читателей вашей программы предполагать, что инструкция существует для какой-то полезной цели. В частности, никогда не используйте глобальный, кроме как первый оператор в теле функции.
{mospagebreak title = Вложенные функции и вложенные области}
Обозначение def внутри тела функции определяет вложенную функцию, а функция, тело которой включает def, называется внешней функцией вложенной. Код в теле вложенной функции может обращаться к (но не восстанавливать) локальные переменные внешней функции, также называемой свободными переменными вложенной функции.
Самый простой способ позволить вложенной функции получить доступ к значению, часто не полагаться на вложенные области, а скорее явно передавать это значение как один из аргументов функции. При необходимости значение аргумента может быть привязано, если вложенная функция определена с использованием значения по умолчанию для необязательного аргумента. Например:
def percent1 (a, b, c): def pc (x, total = a + b + c): return (x \* 100.0) / total print "Проценты:", pc (a), pc (b), pc (c)
Вот те же функции, что и вложенные области:
def percent2 (a, b, c): def pc (x): return (x \* 100.0) / (a ​​+ b + c) print "Проценты:", pc (a), pc (b), pc (c)
В этом конкретном случае процент 1 имеет крошечное преимущество: вычисление a + b + c происходит только один раз, а внутренняя функция comp2 compc трижды повторяет вычисление. Однако, если внешняя функция перепроверяет свои локальные переменные между вызовами вложенной функции, может потребоваться повторение вычисления. Поэтому целесообразно осознавать оба подхода и выбирать наиболее подходящий вариант в каждом случае.
Вложенная функция, которая обращается к значениям из внешних локальных переменных, также известна как замыкание. В следующем примере показано, как построить закрытие:
def make\_adder (augend): def add (добавить): return addend + augend return add
Закрытие является исключением из общего правила, согласно которому объектно-ориентированные механизмы, описанные в главе 5, являются наилучшим способом объединения данных и кода. Когда вам нужно специально создавать вызываемые объекты, с некоторыми параметрами, зафиксированными во время построения объекта, замыкания могут быть проще и эффективнее классов. Например, результат make\_adder (7) - это функция, которая принимает один аргумент и добавляет 7 к этому аргументу. Внешняя функция, возвращающая замыкание, является «фабрикой» для членов семейства функций, отличающихся некоторыми параметрами, такими как значение аргумента augend в предыдущем примере и часто может помочь избежать дублирования кода.
### лямбда-выражения
Если тело функции является единственным выражением выражения return, вы можете заменить функцию специальной формой выражения лямбда:
Параметры лямбда: выражение
Выражение лямбда является анонимным эквивалентом нормальной функции, тело которой является единственным оператором return. Обратите внимание, что синтаксис лямбда не использует ключевое слово return. Вы можете использовать выражение лямбда везде, где вы могли бы использовать ссылку на функцию. lambda иногда может быть удобно, если вы хотите использовать простую функцию в качестве аргумента или возвращаемого значения. Вот пример, который использует лямбда-выражение в качестве аргумента функции встроенного фильтра (см. Фильтр на стр. 161):
aList = \[1, 2, 3, 4, 5, 6, 7, 8, 9\] низкий = 3 высокий = 7 фильтр (lambda x, l = низкий, h = высокий: h> x> l, aList) # возвращает: \[4, 5, 6\]
В качестве альтернативы вы всегда можете использовать локальную команду def, которая дает объекту функции имя. Затем вы можете использовать это имя в качестве аргумента или возвращаемого значения. Вот тот же пример фильтра, в котором используется локальная команда def:
aList = \[1, 2, 3, 4, 5, 6, 7, 8, 9\] низкий = 3 высокий = 7 def в _пределах (значение, l = низкий, h = высокий): return h> value> l фильтр (в пределах_ границ, aList) # возвращает: \[4, 5, 6\]
Хотя лямбда иногда может быть полезна, многие пользователи Python предпочитают def, что является более общим, и могут сделать ваш код более читаемым, если вы выберете разумное имя для этой функции.
{mospagebreak title = Генераторы}
Когда тело функции содержит одно или несколько вхождений выхода ключевого слова, функция называется генератором. Когда вы вызываете генератор, тело функции не выполняется. Вместо этого вызов генератора возвращает специальный объект итератора, который обертывает тело функции, его локальные переменные (включая его параметры) и текущую точку выполнения, которая изначально является началом функции.
Когда вызывается следующий метод этого объекта итератора, тело функции выполняет следующий оператор yield, который принимает форму:
выходное выражение
Когда выполняется оператор yield, выполнение функции «заморожено» с текущей точкой выполнения и локальными переменными нетронутыми, а результат следующего результата возвращается в результате следующего метода. Когда снова вызывается снова, выполнение тела функции возобновляется там, где оно было остановлено, снова до следующего оператора yield. Если тело функции заканчивается или выполняет оператор return, итератор вызывает исключение StopIteration, чтобы указать, что итерация завершена. Операторы return в генераторе не могут содержать выражения.
Генератор - очень удобный способ создания итератора. Поскольку наиболее распространенный способ использования итератора - это цикл с ним с помощью инструкции for, вы обычно вызываете генератор следующим образом:
для avariable в somegenerator (аргументы):
Например, скажем, что вы хотите, чтобы последовательность чисел подсчитывалась от 1 до N, а затем до 1 снова. Генератор может помочь:
def updown (N): для x в xrange (1, N): выход x для x в xrange (N, 0, -1): получаем x для i в updown (3): print i # prints: 1 2 3 2 1
Вот генератор, который работает как встроенная функция xrange, но возвращает последовательность значений с плавающей запятой вместо последовательности целых чисел:
def frange (start, stop, step = 1.0): в то время как start <stop: начало выпуска start + = step
Этот пример frange лишь немного похож на xrange, потому что для простоты он приводит к тому, что аргументы начинаются и прекращаются, и молча предполагает, что шаг положительный.
Генераторы более гибкие, чем функции, которые возвращают списки. Генератор может построить неограниченный итератор, то есть тот, который возвращает бесконечный поток результатов (использовать только в циклах, которые завершаются другими способами, например, с помощью инструкции break). Кроме того, итератор, созданный генератором, выполняет ленивую оценку: итератор вычисляет каждый следующий элемент только тогда, когда и когда это необходимо, как раз вовремя, в то время как эквивалентная функция выполняет все вычисления заранее и может потребовать больших объемов памяти для хранения списка результатов. Поэтому, если вам нужна только возможность итерации по вычисленной последовательности, часто лучше всего вычислить последовательность в генераторе, а не в функции, которая возвращает список. Если вызывающему абоненту нужен список всех элементов, созданных некоторым ограниченным генератором G (аргументы), вызывающий может просто использовать следующий код:
result\_list = list (G (аргументы))
### Выражения генератора
Python 2.4 вводит еще более простой способ кодирования особенно простых генераторов: генераторные выражения, обычно известные как genexps. Синтаксис гена xp аналогичен синтаксису определения списка (как описано в «Пояснениях списков» на стр. 67), за исключением того, что ген xp заключен в круглые скобки (()) вместо скобок (\[\]); семантика гена xp совпадает с семантикой соответствующего понимания списка, за исключением того, что ген xp производит итератор, дающий по одному элементу за раз, в то время как понимание списка создает список всех результатов в памяти (поэтому, используя ген xp, когда соответствующий, сохраняет память). Например, чтобы суммировать квадраты всех однозначных целых чисел, в любом современном Python, вы можете кодировать sum (\[x _x для x в xrange (10)\]); в Python 2.4 вы можете выразить эту функциональность еще лучше, закодировав ее как сумму (x_ x для x в xrange (10)) (точно так же, но опуская скобки), и получите точно такой же результат, потребляя меньше памяти. Обратите внимание, что круглые скобки, которые указывают на вызов функции, также «делают двойной долг» и заключают в себе ген xp (нет необходимости в дополнительных скобках).
{mospagebreak title = Генераторы в Python 2.5}
В Python 2.5 генераторы еще более расширены, с возможностью получения значения (или исключения) обратно от вызывающего, поскольку каждый выход выполняется. Эти расширенные функции позволяют генераторам в 2.5 реализовать полноценные совместные подпрограммы, как описано в http://www.python.org/peps/pep-0342.html. Главное изменение заключается в том, что в 2.5 доход не является выражением, а выражением, поэтому он имеет значение. Когда генератор возобновляется, вызывая его следующий метод, значение соответствующего урона равно None. Чтобы передать значение x в некоторый генератор g (так что g принимает x как значение выхода, на котором оно приостановлено) вместо вызова g.next () вызывающий вызов g.send (x) (вызов g.send (Нет) так же, как вызов g.next ()). Кроме того, годовая доходность без аргументов в Python 2.5 становится законной и эквивалентна выводу None.
Другие улучшения Python 2.5 для генераторов связаны с исключениями и описаны в «Улучшениях генератора» на стр. 126.
### Рекурсия
Python поддерживает рекурсию (т. Е. Функция Python может вызывать себя), но существует ограничение на глубину рекурсии. По умолчанию Python прерывает рекурсию и вызывает исключение RecursionLimitExceeded (см. «Стандартные классы исключений» на стр. 130), когда обнаруживает, что стек рекурсивных вызовов прошел на глубину 1000. Вы можете изменить предел рекурсии с помощью функции setrecursionlimit модуля sys, указанной в setrecursionlimit на стр. 171.
Однако изменение предела рекурсии не дает вам неограниченной рекурсии; абсолютный максимальный предел зависит от платформы, на которой работает ваша программа, особенно в базовой операционной системе и библиотеке времени выполнения C, но обычно это несколько тысяч уровней. Если рекурсивные вызовы становятся слишком глубокими, ваша программа вылетает из строя. Такая рекурсия бегства после вызова setrecursionlimit, который превосходит возможности платформы, является одним из немногих способов, с помощью которых программа Python может аварийно завершать работу, - это действительно крушение, жесткое, без обычной безопасности механизмов исключения Python. Поэтому будьте осторожны, пытаясь исправить программу, которая получает исключения RecursionLimitExceeded, повышая слишком высокий предел рекурсии с помощью setrecursionlimit. Чаще всего вам лучше советовать искать способы удаления рекурсии или, более конкретно, ограничить глубину рекурсии, которую требуется вашей программе.
Читатели, знакомые с языками Lisp, Scheme или функционального программирования, должны, в частности, знать, что Python не реализует оптимизацию «устранения хвостового вызова», что так важно на этих языках. В Python любой вызов, рекурсивный или нет, имеет одинаковую стоимость как по времени, так и по пространству памяти, зависящему только от количества аргументов: стоимость не изменяется, является ли вызов «хвостом» (что означает вызов - это последняя операция, выполняемая вызывающим абонентом) или любой другой, не входящий вызов.

45
guide/russian/python/numeric-operations/index.md Normal file
View File

@@ -0,0 +1,45 @@
---
title: Python Numeric Operations
localeTitle: Числовые операции на Python
---
[Документы Python - числовые операции](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)
Python полностью поддерживает смешанную арифметику: когда двоичный арифметический оператор имеет операнды разных числовых типов, операнд с более узким типом расширяется до другого, где целое число уже, чем с плавающей точкой, которое уже, чем сложное. Сравнение между числами смешанного типа использует одно и то же правило. [2\] Конструкторы int (), float () и complex () могут использоваться для создания чисел определенного типа.](https://docs.python.org/3/library/functions.html#abs)
Все числовые типы (кроме сложных) поддерживают следующие операции, отсортированные по возрастающему приоритету (все числовые операции имеют более высокий приоритет, чем операции сравнения):
Операция | Результаты | Примечания | Полная документация
\----------------- | -------------------------------------------------- ------------------------- | ------ | -------------------------------------------------- ---------------------
`x + y` | сумма х и у | |
`x - y` | разность x и y | |
`x * y` | произведение х и у | |
`x / y` | частное от x и y | |
`x // y` | наложенное частное от x и y | (1) |
`x % y` | остаток от x / y | (2)
`-x` | x отрицание | |
`+x` | x без изменений | |
`abs(x)` | абсолютное значение или величина x | | \[ `abs()`
`int(x)` | x преобразован в целое число | (3) (6) | [`int()`](https://docs.python.org/3/library/functions.html#int)
`float(x)` | x преобразован в плавающую точку | (4) (6) | [`float()`](https://docs.python.org/3/library/functions.html#float)
`complex(re, im)` | комплексное число с вещественной частью re, мнимая часть im. im по умолчанию равен нулю. | (6) | [`complex()`](https://docs.python.org/3/library/functions.html#complex)
`c.conjugate()` | сопряженное к комплексному числу c | |
`divmod(x, y)` | пара (x // y, x% y) | (2) | [`divmod()`](https://docs.python.org/3/library/functions.html#divmod)
`pow(x, y)` | x к мощности y | (5) | [`pow()`](https://docs.python.org/3/library/functions.html#pow)
`x ** y` | x к мощности y | (5)
**Заметки:**
1. Также упоминается как целочисленное деление. Результирующее значение представляет собой целое целое число, хотя тип результата не обязательно является int. Результат всегда округляется до минус бесконечности: `1//2` равно `0` , `(-1)//2` равно `-1` , `1//(-2)` `-1` , а `(-1)//(-2)` является `0` .
2. Не для комплексных чисел. Вместо этого конвертируйте в float, используя `abs()` если это необходимо.
3. Преобразование с плавающей запятой в целое число может округлять или обрезать, как в C; см. функции [`math.floor()`](https://docs.python.org/3/library/math.html#math.floor) и [`math.ceil()`](https://docs.python.org/3/library/math.html#math.ceil) для четко определенных преобразований.
4. `float` также принимает строки `“nan”` и `“inf”` с необязательным префиксом `“+”` или `“-”` для Not Number (NaN) и положительной или отрицательной бесконечности.
5. Python определяет `pow(0, 0)` и `0 ** 0` равным `1` , что является общим для языков программирования.
6. Числовые литералы, принятые, включают цифры от 0 до 9 или любой эквивалент Unicode (кодовые точки с свойством `Nd` ).
> См. [Unicode Derived Numeric Type](http://www.unicode.org/Public/8.0.0/ucd/extracted/DerivedNumericType.txt) для получения полного списка кодовых точек с свойством `Nd` .

36
guide/russian/python/numeric-types/index.md Normal file
View File

@@ -0,0 +1,36 @@
---
title: Python Numeric Types
localeTitle: Числовые типы Python
---
[Числовые типы](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex) для Python:
* integers ( `int` )
#### Примеры:
```py
print(1)
print(100)
print(8435367)
```
* числа с плавающей запятой ( `float` )
* [конструктор](https://docs.python.org/3/library/functions.html#float)
#### Примеры:
```py
print(1.5)
print(46.84)
print(84357.435)
```
* сложные числа
* [конструктор](https://docs.python.org/3/library/functions.html#complex)
Стандартная библиотека добавляет числовые типы для
* [фракции](https://docs.python.org/3/library/fractions.html#module-fractions)
* [десятичные](https://docs.python.org/3/library/decimal.html#module-decimal)
Числовые объекты создаются из литералов или как результат функций и операторов. Синтаксис для числовых литералов хорошо [документирован](https://docs.python.org/3/reference/lexical_analysis.html#numeric-literals) .

17
guide/russian/python/object-oriented-programming/classes/index.md Normal file
View File

@@ -0,0 +1,17 @@
---
title: Classes
localeTitle: Классы
---
## Классы
Класс - это «проект» для создания объектов: запись класса позволяет описывать атрибуты и поведения для всех экземпляров этого класса.
## Создать класс
Для определения класса используется ключевой **класс** , за которым следует имя, определяющее класс и двоеточие. Все следующие строки (код, описывающий атрибуты и поведение / методы) - отступы, как в функции Python. Например, чтобы создать класс с именем Person, мы можем написать:
`class Person: <code describing attributes and behaviors/methods>`
Определения классов должны быть выполнены до того, как они будут иметь какой-либо эффект.
#### Дополнительная информация:

11
guide/russian/python/object-oriented-programming/constructors/index.md Normal file
View File

@@ -0,0 +1,11 @@
---
title: Constructors
localeTitle: Конструкторы
---
## Конструкторы
Это заглушка. [Помогите нашему сообществу расширить его](https://github.com/freecodecamp/guides/tree/master/src/pages/mathematics/area-of-a-parallelogram/index.md) .
[Это руководство по быстрому стилю поможет вам принять ваш запрос на тягу](https://github.com/freecodecamp/guides/blob/master/README.md) .
#### Дополнительная информация:

16
guide/russian/python/object-oriented-programming/index.md Normal file
View File

@@ -0,0 +1,16 @@
---
title: Python Object Oriented Programming
localeTitle: Объектно-ориентированное программирование на Python
---
## Объектно-ориентированное программирование на Python
Python - это язык программирования с несколькими парадигмами, поддерживающий различные подходы к программированию. Одна превосходная парадигма программирования - это объектно-ориентированное программирование или короткое ООП путем создания объектов.
В свойствах ООП и их поведение объединяются в отдельные объекты, характеризующиеся:
* атрибуты
* поведения
Например, объект может представлять человека с атрибутами как имя, возраст, адрес с такими типами поведения, как ходьба, разговор, дыхание и бег.
ООП моделирует объекты реального мира как объекты программного обеспечения, которые имеют некоторые данные, связанные с ними, и могут выполнять определенные функции. Объекты моделируются как **классы** , которые являются своего рода _планом_ .

11
guide/russian/python/object-oriented-programming/inheritance/index.md Normal file
View File

@@ -0,0 +1,11 @@
---
title: Inheritance
localeTitle: наследование
---
## наследование
Это заглушка. [Помогите нашему сообществу расширить его](https://github.com/freecodecamp/guides/tree/master/src/pages/mathematics/area-of-a-parallelogram/index.md) .
[Это руководство по быстрому стилю поможет вам принять ваш запрос на тягу](https://github.com/freecodecamp/guides/blob/master/README.md) .
#### Дополнительная информация:

11
guide/russian/python/object-oriented-programming/methods/index.md Normal file
View File

@@ -0,0 +1,11 @@
---
title: Methods
localeTitle: методы
---
## методы
Это заглушка. [Помогите нашему сообществу расширить его](https://github.com/freecodecamp/guides/tree/master/src/pages/mathematics/area-of-a-parallelogram/index.md) .
[Это руководство по быстрому стилю поможет вам принять ваш запрос на тягу](https://github.com/freecodecamp/guides/blob/master/README.md) .
#### Дополнительная информация:

11
guide/russian/python/object-oriented-programming/operator-overloading/index.md Normal file
View File

@@ -0,0 +1,11 @@
---
title: Operator Overloading
localeTitle: Перегрузка оператора
---
## Перегрузка оператора
Это заглушка. [Помогите нашему сообществу расширить его](https://github.com/freecodecamp/guides/tree/master/src/pages/mathematics/area-of-a-parallelogram/index.md) .
[Это руководство по быстрому стилю поможет вам принять ваш запрос на тягу](https://github.com/freecodecamp/guides/blob/master/README.md) .
#### Дополнительная информация:

11
guide/russian/python/object-oriented-programming/special-comparison-methods/index.md Normal file
View File

@@ -0,0 +1,11 @@
---
title: Special Comparison Methods
localeTitle: Специальные методы сравнения
---
## Специальные методы сравнения
Это заглушка. [Помогите нашему сообществу расширить его](https://github.com/freecodecamp/guides/tree/master/src/pages/mathematics/area-of-a-parallelogram/index.md) .
[Это руководство по быстрому стилю поможет вам принять ваш запрос на тягу](https://github.com/freecodecamp/guides/blob/master/README.md) .
#### Дополнительная информация:

11
guide/russian/python/object-oriented-programming/special-formatting-methods/index.md Normal file
View File

@@ -0,0 +1,11 @@
---
title: Special Formatting Methods
localeTitle: Специальные методы форматирования
---
## Специальные методы форматирования
Это заглушка. [Помогите нашему сообществу расширить его](https://github.com/freecodecamp/guides/tree/master/src/pages/mathematics/area-of-a-parallelogram/index.md) .
[Это руководство по быстрому стилю поможет вам принять ваш запрос на тягу](https://github.com/freecodecamp/guides/blob/master/README.md) .
#### Дополнительная информация:

11
guide/russian/python/object-oriented-programming/special-iteration-methods/index.md Normal file
View File

@@ -0,0 +1,11 @@
---
title: Special Iteration Methods
localeTitle: Специальные методы итерации
---
## Специальные методы итерации
Это заглушка. [Помогите нашему сообществу расширить его](https://github.com/freecodecamp/guides/tree/master/src/pages/mathematics/area-of-a-parallelogram/index.md) .
[Это руководство по быстрому стилю поможет вам принять ваш запрос на тягу](https://github.com/freecodecamp/guides/blob/master/README.md) .
#### Дополнительная информация:

11
guide/russian/python/object-oriented-programming/static-variables/index.md Normal file
View File

@@ -0,0 +1,11 @@
---
title: Static Variables
localeTitle: Статические переменные
---
## Статические переменные
Это заглушка. [Помогите нашему сообществу расширить его](https://github.com/freecodecamp/guides/tree/master/src/pages/mathematics/area-of-a-parallelogram/index.md) .
[Это руководство по быстрому стилю поможет вам принять ваш запрос на тягу](https://github.com/freecodecamp/guides/blob/master/README.md) .
#### Дополнительная информация:

35
guide/russian/python/ord-function/index.md Normal file
View File

@@ -0,0 +1,35 @@
---
title: Python Ord Function
localeTitle: Функция орфографии Python
---
## Функция орда
`ord()` является встроенной функцией в Python 3, чтобы преобразовать строку, представляющую один символ Unicode, в целое число представляющий код Юникода символа.
#### Примеры:
```
>>> ord('d')
100
>>> ord('1')
49
```
## функция chr
`chr()` - встроенная функция в Python 3, чтобы преобразовать целое число представляя код Unicode в строку, представляющую соответствующий символ.
#### Примеры:
```
>>> chr(49)
'1'
```
Следует отметить, что если целочисленное значение, переданное в `chr()` , выходит за допустимый диапазон, то ValueError будет поднят.
```
>>> chr(-10)
'Traceback (most recent call last):
File "<pyshell#24>", line 1, in <module>
chr(-1)
ValueError: chr() arg not in range(0x110000)'
```

17
guide/russian/python/parenthesis-for-boolean-operations/index.md Normal file
View File

@@ -0,0 +1,17 @@
---
title: Python Parenthesis for Boolean Operations
localeTitle: Pinton Parenthesis для булевых операций
---
Как и в математике, скобки могут использоваться для переопределения порядка операций:
```
>>> not True or True
True
>>> not (True or True)
False
>>> True or False and False
True
>>> (True or False) and False
False
```

25
guide/russian/python/powxy/index.md Normal file
View File

@@ -0,0 +1,25 @@
---
title: Python Powxy
localeTitle: Python Powxy
---
`pow(x, y, z)` является встроенной функцией в Python 3 для вычисления `x` до степени `y` , а если `z` присутствует, возвращает `x` в силу `y` [по модулю](https://processing.org/reference/modulo.html) `z` .
## аргументы
Аргументы должны иметь числовые типы. Эта функция принимает два аргумента: `x` и `y` , а также три, `x` , `y` и `z` . Если `z` присутствует, `x` и `y` должны быть целочисленных типов, а y должно быть неотрицательным.
## Вернуть
Если `z` присутствует, он возвращает `x` к мощности `y` по модулю `z` . Если присутствуют только `x` и `y` , он возвращает `x` в силу `y` (то же, что и `x**y` ).
## пример
```python
print(pow(2,4)) # prints 16
print(pow(10,-2)) # prints 0.01
print(pow(4,3,5)) # prints 4
```
[🚀Конкурс](https://repl.it/CTGi)
[Официальная документация](https://docs.python.org/3/library/functions.html#pow)

65
guide/russian/python/python-2-vs-python-3/index.md Normal file
View File

@@ -0,0 +1,65 @@
---
title: Python 2 vs Python 3
localeTitle: Python 2 против Python 3
---
Мы не принимаем сторону в дебатах. Если вам интересно узнать больше об этом в академических целях, возможно, [эта статья, сравнивающая Python 2 и Python 3,](https://wiki.python.org/moin/Python2orPython3) будет вас интриговать.
Но мы также не можем не знать, что есть два основных аромата Python. Почему ты беспокоишься, спросите вы? Поскольку код, написанный для одной версии Python, может привести к синтаксической ошибке в другой версии Python.
Ниже приведен допустимый оператор `print` в Python 2, но он не работает на Python 3:
```py
print "Hello World"
```
В Python 3 тот же оператор выдает такую ​​ошибку:
```
>>> print "hello"
File "<stdin>", line 1
print "hello"
^
SyntaxError: Missing parentheses in call to 'print'
```
В Python 2 «print» рассматривается как оператор, а не как функция. В скобках нет необходимости обертывать текст, который вы хотите распечатать, хотя вы можете, если хотите. Python 3 явно рассматривает «print» как функцию, что означает, что вы должны передавать элементы, которые вам нужно распечатать, в функцию в круглых скобках стандартным образом, или вы получите синтаксическую ошибку
Использование функции `print()` является «безопасным» как в Python 2, так и 3:
```python
print("Hello World")
```
Еще одна разница между Python 2 и Python 3 заключается в том, какую структуру данных они возвращают, когда вы вызываете функцию `map()` .
В Python 2 `map()` возвращает список:
```
>>> result = map(int,['10','20','30','40'])
>>> print result
>>> [10,20,30,40]
```
В Python 3 `map()` возвращает итератор:
```
>>> result = map(int,['10','20','30','40'])
>>> print (result)
>>> <map object at 0x7f40896b4630>
```
Чтобы получить список в Python 3, вам необходимо его преобразовать:
```
>>> result = list(map(int,['10','20','30','40']))
>>> print (result)
>>> [10,20,30,40]
```
Итак, единственный вопрос, который вам нужно сейчас коснуться; какой из них вы должны выбрать? Если вы новичок в Python, вы должны выбрать Python 3. Python 2 в настоящее время имеет дату [окончания жизни,](https://www.python.org/dev/peps/pep-0373/#update) установленную в 2020 году. Значение регулярных исправлений не гарантируется в будущем, и да, требуется время, чтобы даже ознакомиться с наиболее распространенными аспектами с помощью Python; и ваше время важно. Итак, инвестируйте свое время и усилия с умом!
Хотя Python 2 хорошо поддерживается и популярен, большинство распространенных библиотек и фреймворков в Python предпочитают Python 3. Django официально [рекомендует](https://docs.djangoproject.com/en/1.9/faq/install/#faq-python-version-support) Python 3. Flask и все его зависимости также [поддерживаются](http://flask.pocoo.org/docs/0.10/python3/#python3-support) на Python 3.
Оба Python 2 и Python 3 великолепны. Большинство дистрибутивов Linux и macOS поставляются с предустановленной Python 2 в качестве стандартной версии Python. И Python 3 родился из ненасытного поиска более читаемых и более красивых языковых конструкций.
В этой статье используется Python 3 для настройки веб-фреймворков в вашей среде разработки. Но перед этим вам нужно убедиться, что у вас есть Python 3 и знаете, как его использовать!
#### Дополнительная информация:
* [Статьи Python 2 или 3](https://wiki.python.org/moin/Python2orPython3)

30
guide/russian/python/python-coding-standards/index.md Normal file
View File

@@ -0,0 +1,30 @@
---
title: Coding standards
localeTitle: Стандарты кодирования
---
### Контур
* Почему стандарты кодирования?
* Введение в PEP 8
* команды
### Почему стандарты кодирования?
Глобальное сообщество python быстро растет, и почти каждый использует python. Здесь важна читаемость кода и единообразных стандартов. Любой человек на планете должен уметь читать ваш код и понимать, что он делает. Существует много аспектов понимания кода другого пользователя, например комментарии о том, что делает функция, логическое разделение задач между модулями и функциями, хорошие имена переменных и т. Д.
### Введение в PEP 8
Мы любим придерживаться конвенций. Сообщество пользователей python разработало набор стандартов, которые теперь принимаются как конвенции. Любой код уровня отрасли, который вы пишете, запускается через контрольную панель PEP 8. Поэтому хорошей практикой является начало написания docstrings для ваших классов и функций и переименование переменных в нижнем регистре с соответствующими символами подчеркивания. Возможно, стоит взглянуть на эти стандарты, прежде чем начинать кодирование.
[Вот исчерпывающая ссылка](https://www.python.org/dev/peps/pep-0008/ "Стандарты PEP 8")
### команды
Вот как вы проверяете, соответствует ли ваш код Python его стандартам.
```console
:~$ pip install pep8
:~$ pep8 --first myCode.py
```
Это даст все те строки, которые нарушают стандарты, а также краткое описание исправлений.

53
guide/russian/python/python-f-strings/index.md Normal file
View File

@@ -0,0 +1,53 @@
---
title: Python f-strings
localeTitle: Python f-strings
---
# f-строки в Python
В версии Python 3.6 был реализован новый метод форматирования строк. Новый метод называется интерполяцией строк Literal (хотя обычно называется f-строкой).
Использование f-строки позволяет программисту динамически вставлять переменную в строку в чистом и сжатом виде. В дополнение к вставке переменных в строку эта функция также предоставляет возможность программисту оценивать выражения, присоединяться к содержимому коллекции и даже вызывать функции внутри f-строки.
Чтобы выполнить эти динамические поведения внутри f-строки, мы обертываем их внутри фигурных скобок внутри строки и добавляем нижний регистр f к началу строки (перед открывающей цитатой.
### Примеры
1. Динамическая вставка переменной в строку во время выполнения:
```python
name = 'Jon Snow'
greeting = f'Hello! {name}'
print(greeting)
```
2. Вычислить выражение в строке: `python val1 = 2 val2 = 3 expr = f'The sum of {val1} + {val2} is {val1 + val2}' print(expr)`
3. Вызов функции и вставка вывода в строку:
```python
def sum(*args):
result = 0
for arg in args:
result += arg
return result
func = f'The sum of 3 + 5 is {sum(3, 5)}'
print(func)
```
4. Объединение содержимого коллекции в строку:
```python
fruits = ['Apple', 'Banana', 'Pear']
list_str = f'List of fruits: {", ".join(fruits)}'
print(list_str)
```
### источники
https://www.python.org/dev/peps/pep-0498/

69
guide/russian/python/python-resources/index.md Normal file
View File

@@ -0,0 +1,69 @@
---
title: Python Resources
localeTitle: Ресурсы Python
---
## Учебники
* [Официальные руководства Python](https://docs.python.org/3/tutorial/)
* [Автостопом по Python](https://python-guide.readthedocs.org/en/latest/)
* [Класс Google Python](https://developers.google.com/edu/python/)
* [Изучите Python на жестком пути](http://learnpythonthehardway.org/book/)
* [Подумайте о Python](http://www.greenteapress.com/thinkpython/html/index.html)
* [Изучите Python за X минут](https://learnxinyminutes.com/docs/python/)
* [Изучите Python 3 за X минут](https://learnxinyminutes.com/docs/python3/)
* [Погружение в Python 3](http://www.diveintopython3.net/)
* [Полный Stack Python](http://www.fullstackpython.com/)
* [Автоматизация бурения с помощью Python](https://automatetheboringstuff.com/)
* [Python REPL в браузере](https://repl.it/languages/python3)
* [Пошаговое руководство по Visual Python](http://pythontutor.com/)
* [Codecademy Python](https://www.codecademy.com/learn/python)
* [Как думать, как компьютерный ученый](http://interactivepython.org/runestone/static/thinkcspy/index.html) - Интерактивный учебник, который учит программированию с помощью Python
* [Введение в компьютерную науку и программирование с использованием Python](https://www.edx.org/course/introduction-computer-science-mitx-6-00-1x-8) (MIT)
* [CS для всех: введение в компьютерную науку и программирование на Python](https://www.edx.org/course/cs-all-introduction-computer-science-harveymuddx-cs005x-0)
* [Обучение Python](https://www.packtpub.com/packt/free-ebook/learning-python) - Бесплатная электронная книга
* [Новый Coder](http://newcoder.io/) - Учебники / проблемы, чтобы взять вас от новичка до фактического кодера.
* [Придумайте с Python](https://inventwithpython.com/) (плюс две другие книги от Automate the Boring Stuff)
* [Решение проблем с использованием алгоритмов и структур данных с использованием Python](http://interactivepython.org/runestone/static/pythonds/index.html)
* [Шаблоны проектирования Python](https://github.com/faif/python-patterns)
* [Учебник по началу работы с Django](https://www.djangoproject.com/start/)
* [Разработка с использованием Python](http://chimera.labs.oreilly.com/books/1234000000754/index.html)
* [Танго с Django](http://www.tangowithdjango.com/)
* [Учебник для девочек Django](http://tutorial.djangogirls.org/en/) - создайте блог
* [TaskBuster Django Tutorial](http://www.marinamele.com/taskbuster-django-tutorial) - Создайте проект Django с нуля
* [Дерек Банас учит Python в одном видео](https://www.youtube.com/watch?v=N4mEzFDjqtA)
* [pythonprogramming.net Python Baics](https://pythonprogramming.net/introduction-to-python-programming/)
* [thenewboston Python 3.4 Учебники по программированию](https://www.youtube.com/playlist?list=PL6gx4Cwl9DGAcbMi1sH6oAMk4JHw91mC_)
* [Точки обучения - Python](http://www.tutorialspoint.com/python/)
* [Набор стартовых проектов с видеороликами](https://pythonprogramming.net) - начиная с основ.
* [Учебник Flask Mega (Мигель Гринберг)](https://blog.miguelgrinberg.com/post/the-flask-mega-tutorial-part-i-hello-world)
## проблемы
* [Python Koans](https://github.com/gregmalcolm/python_koans)
* [Экстремизм Python](http://exercism.io/languages/python)
* [Проблемы с CodingBat Python](http://codingbat.com/python)
* [Изучите Python в интерактивном режиме](http://www.learnpython.org/)
* [Проект Эйлера](http://projecteuler.net/)
* [Проблемы биоинформатики Розалинды Питона](http://rosalind.info/problems/locations/)
* [Python Elevator Challenge](https://github.com/mshang/python-elevator-challenge)
* [Проблемы с CoderByte](https://coderbyte.com/)
* [CheckiO](https://checkio.org) - игра для кодеров
* [CodeAbbey](http://www.codeabbey.com/)
* [HackerRank - Проблемы с Python](https://hackerrank.com/domains/python/py-introduction)
* [CodeSignal - Подготовьтесь к интервью и продолжите свои навыки программирования](https://codesignal.com/)
* [CodeWars](https://www.codewars.com/)
* [CodeChef](https://www.codechef.com/)
## сообщество
* [Awesome Python](https://github.com/vinta/awesome-python)
* [/ г / Python](https://www.reddit.com/r/python)
* [/ г / LearnPython](https://www.reddit.com/r/learnpython)
* [Планета Python](http://planetpython.org/)
* [PyLadies](http://www.pyladies.com/)
* [DjangoGirls](https://djangogirls.org/)
* [Python-forum.io](https://python-forum.io/)
## Инструменты:
* [PyCharm Edu](https://www.jetbrains.com/pycharm-edu/) - бесплатная образовательная версия PyCharm, которая поставляется с учебниками, чтобы научить вас Python и возможность загружать больше.

13
guide/russian/python/range-function/index.md Normal file
View File

@@ -0,0 +1,13 @@
---
title: Range Method
localeTitle: Метод диапазона
---
# Функция диапазона
Если вам нужно перебирать последовательность чисел, вам может понадобиться встроенный диапазон функций (). Он генерирует арифметические прогрессии:
#### Пример использования
`py for i in range(5): print(i)`
\#### Выход `0 1 2 3 4`

91
guide/russian/python/rest-api-with-falcon/index.md Normal file
View File

@@ -0,0 +1,91 @@
---
title: REST APIs with Falcon
localeTitle: API REST с Falcon
---
## Введение
API RESTful являются основным компонентом любого хорошо продуманного стека, и у Python есть некоторые блестящие рамки для быстрого составления API. Одна из этих фреймов называется [Falcon](https://falconframework.org) - и это здорово! По существу микрокарта, она поставляется с большим количеством преимуществ:
1. Это быстро. Действительно быстро. Проверьте тесты [здесь](https://falconframework.org/#sectionBenchmarks) .
2. Ресурсы HTTP определяются как классы, при этом методы класса используются для разных операций REST на этих ресурсах. Это помогает поддерживать чистую кодовую базу.
3. Это довольно расширяемо - ознакомьтесь с [этим разделом](https://github.com/falconry/falcon/wiki/Complementary-Packages) на своей вики, чтобы почувствовать это.
4. Он основан на WSGI - стандарте Pythonic для веб-приложений, поэтому он работает с Python 2.6, 2.7 и 3.3+. И если вам нужно больше производительности, запустите его с помощью PyPy!
## Начиная
Во-первых, давайте подготовим нашу среду. Лично, всегда здорово работать в виртуальных средах - вы можете использовать `virtualenv` , `virtualenvwrapper` или `venv` . Затем, установите Falcon, используя `pip` : `pip install falcon` .
Мы собираемся разработать небольшой образец API, который делает для нас основные манипуляции с часовыми поясами. Он отображает текущее время в UTC, а также соответствующее время эпохи. Для этого мы возьмем отличную библиотеку со `arrow` : `pip install arrow` .
Вы можете найти готовый образец на [странице https://github.com/rudimk/freecodecamp-guides-rest-api-falcon](https://github.com/rudimk/freecodecamp-guides-rest-api-falcon) .
## Ресурсы
Подумайте о ресурсе как об объекте, которым должен манипулировать ваш API. В нашем случае лучшим ресурсом будет `Timestamp` . Наша маршрутизация обычно будет примерно такой:
```
GET /timestamp
```
Здесь `GET` - это HTTP-глагол, используемый для вызова этой конечной точки, а `/timestamp` - это сам URL. Теперь, когда мы получили это немного, давайте создадим модуль!
`$ touch timestamp.py`
Время для импорта библиотеки Falcon:
```python
import json
import falcon
import arrow
```
Обратите внимание, что мы также импортируем пакет `json` и библиотеку `arrow` . Теперь давайте определим класс для нашего ресурса:
```python
class Timestamp(object):
def on_get(self, req, resp):
payload = {}
payload['utc'] = arrow.utcnow().format('YYYY-MM-DD HH:mm:SS')
payload['unix'] = arrow.utcnow().timestamp
resp.body = json.dumps(payload)
resp.status = falcon.HTTP_200
```
Давайте рассмотрим этот фрагмент. Мы определили класс `Timestamp` и определили метод класса, называемый `on_get` - эта функция сообщает Falcon, что когда `GET` запрос выдается конечной точке для этого ресурса, запустите функцию `on_get` и предоставите объекты запроса и ответа в качестве параметров. После этого плавное плавание - мы создаем пустой словарь, заполняем его текущими отметками времени UTC и UNIX, конвертируем их в JSON и присоединяем к объекту ответа.
Довольно просто, не так ли? Но, к сожалению, это еще не все. Теперь нам нужно создать сервер Falcon и подключить класс ресурсов, который мы только что определили, к фактической конечной точке.
`$ touch app.py`
Теперь добавьте следующий код:
```python
import falcon
from timestamp import Timestamp
api = application = falcon.API()
timestamp = Timestamp()
api.add_route('/timestamp', timestamp)
```
Здесь мы определили API Falcon и инициализировали экземпляр класса ресурсов, который мы создали ранее. Затем мы подключили конечную точку `/timestamp` с экземпляром класса - и теперь мы готовы к работе! Чтобы проверить этот API, установите `gunicorn` ( `pip install gunicorn` ) и запустите `gunicorn app` . Используйте Postman или простую `cURL` чтобы проверить это:
```
$ curl http://localhost:8000/timestamp
{"utc": "2017-10-20 06:03:14", "unix": 1508479437}
```
И это все!
## Перемещение
Как только вы приобретете Falcon, создание мощных API RESTful, которые взаимодействуют с базами данных или очередями обмена сообщениями, очень просто. [Просмотрите документы Falcon](https://falcon.readthedocs.io/en/stable/index.html) , а также PyPI для интересных модулей Falcon, которые продолжают появляться.

91
guide/russian/python/return-statement/index.md Normal file
View File

@@ -0,0 +1,91 @@
---
title: Python Return Statement
localeTitle: Заявление о возврате Python
---
[Документы Python](https://docs.python.org/3/reference/simple_stmts.html#the-return-statement)
Все функции возвращают значение при вызове.
Если за оператором return следует список выражений, этот список выражений вычисляется и возвращается значение:
```
>>> def greater_than_1(n):
... return n > 1
...
>>> print(greater_than_1(1))
False
>>> print(greater_than_1(2))
True
```
Если список выражений не указан, возвращается `None` :
```
>>> def no_expression_list():
... return # No return expression list.
...
>>> print(no_expression_list())
None
```
Если во время выполнения функции достигается оператор return, текущий вызов функции остается в этой точке:
```
>>> def return_middle():
... a = 1
... return a
... a = 2 # This assignment is never reached.
...
>>> print(return_middle())
1
```
Если нет оператора возврата, функция возвращает None при достижении конца:
```
>>> def no_return():
... pass # No return statement.
...
>>> print(no_return())
None
```
Одна функция может иметь несколько операторов `return` . Выполнение функции заканчивается при достижении одного из этих `return` операторов:
```
>>> def multiple_returns(n):
... if(n):
... return "First Return Statement"
... else:
... return "Second Return Statement"
...
>>> print(multiple_returns(True))
First Return Statement
>>> print(multiple_returns(False))
Second Return Statement
```
Одна функция может возвращать различные типы:
```
>>> def various_return_types(n):
... if(n==1):
... return "Hello World." # Return a string
... elif(n==2):
... return 42 # Return a value
... else:
... return True # Return a boolean
...
>>> print(various_return_types(1))
Hello World.
>>> print(various_return_types(2))
42
>>> print(various_return_types(3))
True
```
Возможно даже, что одна функция возвращает несколько значений только с одним возвратом:
```
>>> def return_two_values():
... a = 40
... b = 2
... return a,b
...
>>> print("First value = %d, Second value = %d" %(return_two_values()))
First value = 40, Second value = 2
```

27
guide/russian/python/sequence-types/index.md Normal file
View File

@@ -0,0 +1,27 @@
---
title: Python Sequence Types
localeTitle: Типы последовательности Python
---
Они представляют собой конечные упорядоченные множества, индексированные неотрицательными числами. Встроенная функция `len()` возвращает количество элементов последовательности. Когда длина последовательности равна `n` , набор индексов содержит числа `0, 1, ..., n-1` . Пункт `i` последовательности a выбирается с `a<a href='https://docs.python.org/3/reference/datamodel.html#the-standard-type-hierarchy' target='_blank' rel='nofollow'>i]` .
\[Документы Python - иерархия стандартного типа
## Больше
* Типы встроенных последовательностей:
* `list`
* `tuple`
* `range`
* Встроенные типы последовательностей являются итерируемыми типами (требуется реализовать `__iter__()` ).
* Операции:
* [Общие операции последовательности](https://docs.python.org/3/library/stdtypes.html#common-sequence-operations)
* [Типы управляемых последовательностей](https://docs.python.org/3/library/stdtypes.html#mutable-sequence-types)
* [Неизменяемые типы последовательностей](https://docs.python.org/3/library/stdtypes.html#immutable-sequence-types)

22
guide/russian/python/set-types/index.md Normal file
View File

@@ -0,0 +1,22 @@
---
title: Python Set Types
localeTitle: Типы наборов Python
---
Заданный объект представляет собой неупорядоченный набор различных хешируемых объектов. Обычное использование включает тестирование членства, удаление дубликатов из последовательности и вычисление математических операций, таких как пересечение, объединение, разность и симметричная разность.
[Python Docs - Установить типы Установить Frozenset](https://docs.python.org/3/library/stdtypes.html#set-types-set-frozenset)
**TODO: Объяснить хэш / хешировать** Хэш-таблица представляет собой непрерывный вектор записей, чьи слоты входят в три ароматизаторы:
1. Слоты с парами ключ + значение. Позвоните этим гражданам.
2. Еще не используемые слоты. Назовите этих девственниц.
3. Слоты, которые когда-то были гражданами, но чей ключ был удален, и где другая пара ключей + значение еще не перезаписала слот. Назовите эти turds (это технический термин <0.9 wink>).
Python изменяет размер таблицы, когда количество девственниц падает ниже трети общее количество слотов. В обычном случае Python удваивает размер таблицы (до максимального тока 1,073,741,824 слота). Однако, если многие удалений оставляют за собой много дерьмов, возможно, количество девственниц получить очень низкий уровень, несмотря на то, что осталось мало граждан; в этом случае Python фактически сокращает таблицу (вплоть до текущего минимума в 4 слота).
Во избежание избиения при добавлении и удалении комбинации, когда таблица находится рядом с порогом изменения размера, Python фактически не проверяет # девственники после удаления (в сущности, предполагается, что вы скоро замените турки с гражданами снова). Так что, как ни странно, удаление ключа _никогда_ сжимает стол. Длинная последовательность удалений, за которыми следует добавление, может сжиматься это, однако. Способ принудительной усадки без добавления ключа:
```
dict = dict.copy()
```
dict.copy () всегда возвращает словарь без дерна, самого маленького мощность-2, которая оставляет не менее трети девственных делений.

43
guide/russian/python/setting-up-python-web-framework-django-and-flask/index.md Normal file
View File

@@ -0,0 +1,43 @@
---
title: Setting Up Python Web Framework Django and Flask
localeTitle: Настройка Python Web Framework Django и Flask
---
В этой статье мы обсудим, как установить [Django](https://www.djangoproject.com/) и [Flask](http://flask.pocoo.org/) - две популярные веб-фреймворки, написанные на Python.
Возможно, вы уже знакомы с широким использованием и поддержкой сообщества для Python; в веб-разработке. Вы также можете знать, что такое веб-инфраструктура; и параметры, доступные для Python.
Если эти допущения неверны, вы можете взглянуть на эту статью в вики . Если вы все пойманы, давайте пойдем ахед с настройкой веб-фреймворков Python на вашей локальной машине разработки.
Но было бы несправедливо, если бы мы полностью игнорировали споры [Python 2 и Python 3](http://docs.python-guide.org/en/latest/starting/which-python/#the-state-of-python-2-vs-3) .
## Виртуальная среда
Перед тем, как мы установим Django, мы предложим вам установить чрезвычайно полезный инструмент, который поможет сохранить вашу среду кодирования на вашем компьютере. Пропустить этот шаг можно, но это настоятельно рекомендуется. Начиная с наилучшей настройки, вы сэкономите массу неприятностей в будущем!
Итак, давайте создадим виртуальную среду (также называемую virtualenv). Virtualenv будет изолировать вашу настройку Python / Django для каждого проекта. Это означает, что любые изменения, внесенные вами на один веб-сайт, не будут влиять на других, которые вы также разрабатываете. Неплохо, да?
Для получения дополнительной информации о виртуальных средах смотрите раздел Релевента [здесь](https://guide.freecodecamp.org/python/virtual-environments/) .
## Завершение
Если вы уже установили `pip` просто:
```
$ pip install django
```
После завершения установки мы можем создать новый проект:
```
$ django-admin startproject myproject
$ cd myproject
$ python manage.py runserver
```
Перейдите по `http://localhost:8000` ! : Ракета:
Мы успешно установили веб-структуру нашей потребности. Однако он еще не завершен. Большинство веб-приложений - это контент и данные, поэтому нам нужно хранить данные. Или База данных, если хотите.
В следующей статье мы обсудим, как установить PostgreSQL и использовать его в нашем веб-приложении Python.
Точка для размышлений - мы использовали `pip` сильно, но мы почти ничего не сказали об этом. Ну, на данный момент это просто менеджер пакетов, например, `npm` . Он имеет некоторые отличия от `npm` ; но теперь вам не нужно беспокоиться об этом. Если вы заинтересованы, не проверить [официальную `pip` документации](http://pip-python3.readthedocs.org/en/latest/index.html) .
_Если у вас есть предложения или вопросы, присоединяйтесь к нам на [gitter](https://gitter.im/FreeCodeCamp/FreeCodeCamp)_ .

20
guide/russian/python/share-file-using-python-simple-http-server/index.md Normal file
View File

@@ -0,0 +1,20 @@
---
title: Share File Using Python SimpleHTTPserver
localeTitle: Совместное использование файла с помощью Python SimpleHTTPserver
---
## Для отправки файла необходимо выполнить шаги.
1. Убедитесь, что оба компьютера подключены через одну сеть через LAN или WIFI.
2. Откройте терминал в Ubuntu и убедитесь, что на вашем ПК установлен Python.
3. Если он не установлен, установите его, набрав терминал «sudo apt-get install python» без кавычек.
4. Перейдите в каталог, файл которого вы хотите поделиться, используя команду cd (change directory).
5. Введите эту команду «python -m simpleHTTPserver» без кавычек.
6. Откройте новый терминал и введите ifconfig и найдите свой IP-адрес.
## Теперь на втором компьютере
1. Откройте браузер и введите ip-адрес первого.
2. Не забудьте добавить номер порта в конце ip-адреса, который по умолчанию: 8000
Откроется страница, показывающая структуру типа Directory, и она отобразит все файлы с исходного ПК.
Теперь вы можете получить доступ ко всем файлам.

22
guide/russian/python/sleep-how-can-i-make-a-time-delay-in-python/index.md Normal file
View File

@@ -0,0 +1,22 @@
---
title: Sleep How Can I Make a Time Delay in Python
localeTitle: Sleep Как я могу сделать задержку времени в Python
---
## Sleep Как я могу сделать задержку времени в Python
Модуль `time` в стандартной библиотеке Python содержит функцию `sleep()` которая приостанавливает программу на заданное количество секунд.
Пример:
```
import time
for letter in 'hello, world!':
print(letter)
time.sleep(2) # sleep 2 seconds between each print
```
Числа с плавающей запятой могут быть указаны как аргумент `sleep()` для более точного времени сна.
#### Дополнительная информация:
[Документация](https://docs.python.org/3/library/time.html#time.sleep) модуля времени на функцию сна.

51
guide/russian/python/slicestartstopstep/index.md Normal file
View File

@@ -0,0 +1,51 @@
---
title: Python Slicestartstopstep
localeTitle: Python Slicestartstopstep
---
`slice(start:stop[:step])` - это объект, обычно содержащий часть последовательности. Слайс создается с использованием индексной нотации, \[\] с двоеточиями между числами, когда дано несколько, например, в переменной\_имя \[1: 3: 5\].
## аргументы
Эта функция может использоваться для среза кортежей, массивов и списков.
Значение параметра `start` (или None, если не указано)
Значение параметра `stop` (или последнего индекса последовательности)
Значение параметра `step` (или None, если не указано). Это не может быть 0.
Все три должны быть целочисленного типа.
## Вернуть
Если предусмотрен только `stop` , он генерирует часть последовательности от индекса `0` до `stop` .
Если предусмотрен только `start` , он генерирует часть последовательности после `start` индекса до последнего элемента.
Если предусмотрены обе `start` и `stop` , он генерирует часть последовательности после `start` индекса до `stop` .
Если все три `start` , `stop` и `step` предусмотрен, он генерирует часть последовательности после индекса `start` до `stop` с приростом индекса `step` .
## пример
```
a = [1, 2, 3, 4, 5, 6, 7, 8]
print(a[:5]) # prints [1, 2, 3, 4, 5]
print(a[2:]) # prints [3, 4, 5, 6, 7, 8]
print(a[2:5]) # prints [3, 4, 5]
print(a[2:7:2]) # prints [3, 5, 7]
```
Вы можете индексировать последний индекс последовательности, используя `-1` :
```
a = [1, 2, 3, 4, 5, 6]
print(a[-1]) # prints 6
print(a[2:-1]) # prints [3, 4, 5]
```
Вы можете перевернуть последовательность, используя ноту среза `[::-1]` :
```
a = [1, 2, 3, 4, 5, 6]
print(a[::-1]) # prints [6, 5, 4, 3, 2, 1]
```
[Официальная документация](https://docs.python.org/3/library/functions.html#slice) ![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CT5h)

31
guide/russian/python/string-methods/index.md Normal file
View File

@@ -0,0 +1,31 @@
---
title: String Methods
localeTitle: Строковые методы
---
**TODO: `string` базовая информация**
[Документы Python - Строки](https://docs.python.org/3/library/stdtypes.html#strings)
**Создание:**
Пустая `string` создается с использованием пары кавычек или апострофов:
```shell
>>> new_string = ''
>>> type(new_string)
<class 'string'>
>>> len(new_string)
0
```
[Python Docs - больше о струнах](https://docs.python.org/3/tutorial/datastructures.html#more-on-strings)
* `string.find('you')` Возвращает самую низкую позицию, в которой находится подстрока.
* `str.join(iterable)` Присоединяйте все элементы в `iterable` с указанной строкой.
* `str.replace(old, new, max)` используется для замены подстроки `old` на строку `new` для `max` раз. Этот метод возвращает новую копию строки с заменой, а оригинал `str` неизменно.
* `string.split(separator, maxsplit)` Возвращает список подстрок, разделенных `separator` , необязательное число `maxsplit` , а если не указано, строка будет разбита на все экземпляры `separator` .
* `string.strip(to_strip)` Возвращает строку с `to_strip` как из начала, так и из конца строки. Если `to_strip` не указан, это приведет к `to_strip` всех пробельных символов.

Some files were not shown because too many files have changed in this diff Show More