@@ -84,7 +84,7 @@ n - размер структуры данных
|Получение элемента|`l[i]`|O(1)|
|Присваивание значения элементу|`l[i] = 0`|O(1)|
|Размер списка|`len(l)`|O(1)|
-|Добавление элемента в конец списка|`l.append(5)`|O(1)|**Скорее всего это неверно**|
+|Добавление элемента в конец списка|`l.append(5)`|O(1)|**Скорее всего это неверно**|
|Удаление последнего элемента|`l.pop()`|O(1)|Аналогично `l.pop(-1)`|
|Очищение списка|`l.clear()`|O(1)|Аналогично `l = []`|
|Добавление нескольких элементов|`l1.extend(l2)`|O(len(n))|Прямая зависимость с размером l2|
@@ -105,7 +105,7 @@ n - размер структуры данных
---
### Кортежи:
-Нет смысла составлять таблицу, т.к. **кортежи** - те же самые списки, только неизменяемые. Поэтому к ним применимы все операции, не изменяют структуру данных, и они имеют такие же нотации сложности, как и списки.
+Нет смысла составлять таблицу, т.к. **кортежи** - те же самые списки, только неизменяемые. Поэтому к ним применимы все операции, не изменяющие структуру данных, и они имеют такие же нотации сложности, как и списки.
---
### Множества:
diff --git a/content/posts/collections/index.md b/content/posts/collections/index.md
index 9decdaa..a2b5667 100644
--- a/content/posts/collections/index.md
+++ b/content/posts/collections/index.md
@@ -23,7 +23,7 @@ series_order: 1
`print(("NO", "YES")[num1.issuperset(num2)])` - в квадратных скобках мы получаем результат логического выражения (`True` - 1 или `False` - 0). Значит после кортежа будет либо `[0]`, либо `[1]` - индекс элемента, который мы выберем из самого кортежа.
-Чтобы не использовать экранирование при работе с текстом, можно воспользоваться **raw strings**, т.е. вместо такого кода: `path = 'C:\\new\\text.txt'`, использовать такой: `path = r'C:\new\text.txt'`.
+Чтобы не использовать экранирование при работе с текстом, можно воспользоваться **raw strings**, т.е. вместо такого кода: `path = 'C:\\new\\text.txt'`, использовать код: `path = r'C:\new\text.txt'`.
При вызове метода мы используем скобки: (например) `close()`, а при вызове свойства (атрибута) скобок нет `closed`. Методы совершают действия, а свойства возвращают информацию об объекте.
@@ -34,14 +34,18 @@ series_order: 1
---
## **Списки**
-**Списки изменяемы**; в них допускается выход на границы, просто возьмется весь список до конца; список может содержать элементы **разных типов данных**, списки - ссылочный тип даных.
+ **Списки изменяемы**; в них допускается выход на границы, просто возьмется весь список до конца; список может содержать элементы **разных типов данных**; списки - ссылочный тип даных.
+
Если мы хотим копировать список `letters = ['a', 'b', 'c', 'd']`, мы можем сделать это следующими способами:
1. `new_letters = letters[:]`
2. `new_letters = list(letters)`
-3. `new_letters = letters.copy()`
-Чтобы вывести список в одну строку, можно восползоваться методом `join()` или сделать так: `print(*student)`
+3. `new_letters = letters.copy()`
+
+{{< alert "circle-info">}}
+Чтобы вывести список в одну строку, можно восползоваться методом `join()` или распаковать `print(*student)`
+{{< /alert >}}
-Списочные методы:
+Списочные методы и операторы:
* метод `append()` добавляет новый элемент в конец списка;
* метод `extend()` расширяет один список другим списком;
* метод `insert()` вставляет значение в список в заданной позиции;
@@ -55,21 +59,22 @@ series_order: 1
* оператор `del` позволяет удалять элементы списка по определенному индексу.
Методы строк, работающие со списками:
-* метод split() разбивает строку на слова, используя в качестве разделителя последовательность пробельных символов, символ табуляции (\t) или символ новой строки (\n).
-* метод join() собирает строку из элементов списка, используя в качестве разделителя строку, к которой применяется метод.
+* Метод `split()` разбивает строку на слова, используя в качестве разделителя последовательность пробельных символов, символ табуляции (`\t`) или символ новой строки (`\n`).
+* Метод `join()` собирает строку из элементов списка, используя в качестве разделителя строку, к которой применяется метод.
-* Если нужно получить очищенную от знаков препинания и заглавных букв строку, можно воспользоваться этим кодом: `text = [word.strip('.,!?:;-') for word in input().lower().split()]`
+{{< alert "circle-info">}}
+Если нужно получить очищенную от знаков препинания и заглавных букв строку, можно воспользоваться следующей конструкцией: `text = [word.strip('.,!?:;-') for word in input().lower().split()]`
+{{< /alert >}}
---
## **Матрицы**
-Индексы i и j элементов на главной диагонали квадратной матрицы связаны соотношением i = j. Индексы i и j элементов на побочной диагонали связаны соотношением i + j + 1 = n (или j = n - i - 1), где n — размерность матрицы.
+Индексы i и j элементов на главной диагонали квадратной матрицы связаны соотношением i = j. На побочной диагонали: i + j + 1 = n (или j = n - i - 1), где n — размерность матрицы.
Заметим также, что:
-- если элемент находится выше главной диагонали, то i < j, если ниже - i > j.
+- если элемент находится выше главной диагонали, то i < j, если ниже – i > j.
- если элемент находится выше побочной диагонали, то i + j + 1 < n, если ниже - i + j + 1 > n.
-Способы задать матрицы:
-Если вводим элементы построчно
+Если мы вводим элементы построчно, то может задать матрицу так:
```py
n, m = [int(i) for i in input().split()]
matrix = [[int(i) for i in input().split()] for _ in range(n)]
@@ -78,19 +83,21 @@ matrix = [[int(i) for i in input().split()] for _ in range(n)]
---
## **Кортежи**
-Кортежи ялвяются неизменяемыми списками. В литеральной форме кортеж записывается в виде последовательности элементов в круглых скобках, а список – в квадратных.
-Для создания кортежа с единственным элементом после значения элемента ставят замыкающую запятую:
-`my_tuple = (1,)`
-Функции, возвращающие несколько значений, возвращают кортеж.
+Кортежи являются неизменяемыми списками. В литеральной форме кортеж записывается в виде последовательности элементов в круглых скобках, а список – в квадратных.
+Для создания кортежа с единственным элементом после значения элемента ставят замыкающую запятую: `my_tuple = (1,)`.
Важно понимать: список внутри кортежа можно изменить. Списки являются ссылочными типами данных, поэтому в кортеже хранится ссылка на список, которая не меняется при изменении самого списка.
+{{< alert "circle-info" >}}
+Функции, возвращающие несколько значений, возвращают кортеж.
+{{< /alert >}}
+
Кортежи поддерживают:
* доступ к элементу по индексу (только для получения значений элементов);
-* методы, в частности index(), count();
-* встроенные функции, в частности len(), sum(), min() и max();
+* методы, в частности `index()`, `count()`;
+* встроенные функции, в частности `len()`, `sum()`, `min()` и `max()`;
* срезы;
-* оператор принадлежности in;
-* операторы конкатенации (+) и повторения (*).
+* оператор принадлежности `in`;
+* операторы конкатенации (`+`) и повторения (`*`).
Чтобы присвоить переменным значения элементов кортежа, можно воспользоваться следующим кодом (кол-во переменных должно совпадать с кол-вом элементов кортежа):
```py
@@ -98,35 +105,37 @@ colors = ('red', 'green', 'blue', 'cyan')
(a, b, c, d) = colors # Скобки можно опустить
```
-Однако, если необходимо получить лишь какие-то отдельные значения, то в качестве "ненужных" переменных позволено использовать символ нижнего подчеркивания _.
+Однако, если необходимо получить лишь какие-то отдельные значения, то в качестве "ненужных" переменных позволено использовать символ нижнего подчеркивания `_`.
Есть способ собрать сразу несколько значений в одну переменную. Это делается при помощи звездочки перед именем переменной.
-`a, b, *tail = 1, 2, 3, 4, 5, 6` - в этом случае в переменной a будет записана единица, в переменной b — двойка, а в переменной tail — **список**, состоящий из всех аргументов, которые не попали в предыдущие переменные. В данном случае tail будет равен [3, 4, 5, 6]. **tail всегда будет списком, даже когда в него попадает лишь один элемент или даже ноль.**
+`a, b, *tail = 1, 2, 3, 4, 5, 6` - в этом случае в переменной `a` будет записана единица, в переменной `b` — двойка, а в переменной `tail` — **список**, состоящий из всех аргументов, которые не попали в предыдущие переменные. В данном случае `tail` будет равен `[3, 4, 5, 6]`. **`tail` всегда будет списком, даже когда в него попадает лишь один элемент или даже ноль.**
Звездочка может быть только у одного аргумента, но необязательно у последнего.
-Если нужно распаковать единственной значение в кортеже, после имени переменной должна идти запятая. Приведенный ниже код:
+Если нужно распаковать единственное значение в кортеже, после имени переменной должна идти запятая. Приведенный ниже код:
```py
-a = 1, # не распаковка, а просто присвоение
-b, = 1, # распаковка
+a = 1, # не распаковка, а просто присвоение
+b, = 1, # распаковка
print(a)
print(b)
```
-выводит:
-```py
+
+```
+# Вывод:
(1,)
1
```
-**Также можно распаковывать и список, и строку**
+{{< alert "circle-info" >}}
+Таким же образом можно распаковывать и список, и строку
+{{< /alert >}}
---
## **Множества**
### Общая информация
Множество – структура данных, организованная так же, как математические множества.
-Важно знать:
-
+Особенности:
- все элементы множества различны (уникальны), два элемента не могут иметь одинаковое значение;
- множества неупорядочены, то есть элементы не хранятся в каком-то определенном порядке;
- элементы множества должны относиться к неизменяемым типам данных;
@@ -138,28 +147,33 @@ numbers = {2, 4, 6, 8, 10}
languages = {"Python", "C#", "C++", "Java"}
```
Пустое множество создаётся, например, через `set()`.
-При выводе множества порядок элементов может отличаться от существовавшего при его создании, поскольку множества — неупорядоченные коллекции данных.
+При выводе множества порядок элементов может отличаться от существовавшего при его создании, поскольку множества — неупорядоченные коллекции данных.
-Встроенная функция set() помимо создания пустого множества может преобразовывать некоторые типы объектов в множества.
-В функцию set() можно передать один аргумент. Передаваемый аргумент должен быть итерируемым объектом, таким как список, кортеж или строковое значение. Отдельные элементы объекта, передаваемого в качестве аргумента, становятся элементами множества:
+Встроенная функция `set()` помимо создания пустого множества может преобразовывать некоторые типы объектов в множества.
+В неё можно передать один аргумент, который, в свою очередь, должен быть итерируемым объектом (таким как список, кортеж или строковое значение). Отдельные элементы объекта, передаваемого в качестве аргумента, становятся элементами множества:
```py
-myset1 = set(range(10)) # множество из элементов последовательности
-myset2 = set([1, 2, 3, 4, 5]) # множество из элементов списка
-myset3 = set('abcd') # множество из элементов строки
-myset4 = set((10, 20, 30, 40)) # множество из элементов кортежа
+myset1 = set(range(10)) # множество из элементов последовательности
+myset2 = set([1, 2, 3, 4, 5]) # множество из элементов списка
+myset3 = set('abcd') # множество из элементов строки
+myset4 = set((10, 20, 30, 40)) # множество из элементов кортежа
```
-Попытка добавить в множество кортеж со списком приведёт к ошибке:
+
+{{< alert icon="fire" cardColor="#e63946" iconColor="#1d3557" textColor="#f1faee" >}}
+Попытка добавить в множество кортеж со списком приведёт к ошибке!
+{{< /alert >}}
```py
mytuple = ([1, 2, 3], [4, 5, 6])
myset = set(mytuple)
+```
+```
# Вывод:
TypeError: unhashable type: 'list'
```
Если требуется создать множество, в котором каждый элемент — строковое значение, содержащее более одного символа, то используем код: `myset = set(['aaa', 'bbbb', 'cc'])`.
-Проверить принадлежит ли какой-либо объект множеству можно с помощью оператора `in`.
+Проверить принадлежит ли какой-либо объект множеству можно с помощью оператора `in`:
```py
tremendously_huge_set = {"red", "green", "blue"}
@@ -168,11 +182,10 @@ if "green" in tremendously_huge_set:
else:
print("Unfortunately, there is no green...")
-# Вывод:
-Green is there!
+# Вывод: Green is there!
```
-**Индексация, конкатенация, умножение на число и срезы недоступны для множеств**, а значит перебор элементов по индексу не получится, поэтому в цикле, например, мы должны перебирать сами элементы из множества.
+**Индексация, конкатенация, умножение на число и срезы недоступны для множеств**, а значит перебор элементов по индексу не получится, поэтому, например, в цикле, мы должны перебирать сами элементы из множества.
Чтобы вывести все элементы множества, мы можем его распаковать (при этом не гарантируется, что вывод будет упорядоченным):
```py
numbers = {0, 1, 1, 2, 3, 3, 3, 5, 6, 7, 7}
@@ -181,7 +194,7 @@ print(*numbers, end=' ')
# Вывод: 0 1 1 2 3 3 3 5 6 7 7
```
-Если мы хотим упорядочить вывод множества, можем воспользоваться встроенной функцией `sorted()` (которая возвращает список):
+Если мы хотим упорядочить вывод множества, можем воспользоваться встроенной функцией `sorted()` (возвращает список):
```py
numbers = {0, 1, 1, 2, 3, 3, 3, 5, 6, 7, 7}
@@ -199,7 +212,7 @@ print(*sorted_numbers, end=' ')
- Метод `pop()` удаляет и возвращает случайный элемент из множества с генерацией исключения (ошибки) при попытке удаления из пустого множества;
- Метод `clear()` удаляет все элементы из множества.
-#### Методы, НЕ изменяющие множества
+#### Методы, НЕ изменяющие сами множества
1. `union()` - объединение множеств.
```py
myset1 = {1, 2, 3, 4, 5}
@@ -219,13 +232,13 @@ print(myset3)
```
2. `intersection()` - пересечение множеств.
-Для пересечения двух множеств можно также использовать оператор `&`.
+Альтернатива: оператор `&`.
3. `difference()` - разность множеств.
-Для разности двух множеств можно также использовать оператор `-`.
+Альтернатива: оператор `-`.
4. `symmetric_difference()` - симметрическая разность множеств.
-Для симметрической разности двух множеств можно также использовать оператор `^`.
+Альтернатива: оператор `^`.
#### Методы, ИЗМЕНЯЮЩИЕ множества
1. `update()` - изменяет исходное множество по объединению.
@@ -240,7 +253,7 @@ print(myset3)
4. `symmetric_difference_update()` - изменяет исходное множество по симметрической разности.
Аналогичный результат получается, если использовать оператор `^=`.
-Все основные операции над множествами выполняются двумя способами: при помощи метода или соответствующего ему оператора. Различие заключается в том, что метод может принимать в качестве аргумента не только множество (тип данных `set`), но и любой итерируемый объект (список, строку, кортеж..).
+Все основные операции над множествами выполняются двумя способами: при помощи метода или соответствующего ему оператора. Различие заключается в том, что метод может принимать в качестве аргумента не только множество (тип данных `set`), но и любой итерируемый объект (список, строку, кортеж и т.д.)
```py
mylist = [2021, 2020, 2019, 2018, 2017, 2016]
mytuple = (2021, 2020, 2016)
@@ -248,18 +261,20 @@ mystr = 'abcd'
myset = {2009, 2010, 2016}
-print(myset.union(mystr)) # объединяем со строкой
-print(myset.intersection(mylist)) # пересекаем со списком
-print(myset.difference(mytuple)) # находим разность с кортежем
+print(myset.union(mystr)) # объединяем со строкой
+print(myset.intersection(mylist)) # пересекаем со списком
+print(myset.difference(mytuple)) # находим разность с кортежем
+```
+```
# Вывод:
{2016, 'c', 'b', 'a', 'd', 2009, 2010}
{2016}
{2009, 2010}
```
-Некоторые методы (union(), intersection(), difference()) и операторы (|, &, -, ^) позволяют совершать операции над несколькими множествами сразу.
-Оператор ^ симметрической разности позволяет использовать несколько множеств, а метод symmetric_difference() – нет.
+Некоторые методы (`union()`, `intersection()`, `difference()`) и операторы (`|`, `&`, `-`, `^`) позволяют совершать операции над несколькими множествами сразу.
+Оператор `^` симметрической разности позволяет использовать несколько множеств, а метод `symmetric_difference()` – нет.
Приоритет операторов в порядке убывания (верхние операторы имеют более высокий приоритет, чем нижние):
|Оператор|Описание|
@@ -269,18 +284,17 @@ print(myset.difference(mytuple)) # находим разность
|`^`|симметрическая разность|
|`\|`|объединение|
-#### Методы, связанные с подмножествами и пр.
+#### Другие методы
* `issubset()` - используется для определения, является ли одно из множеств подмножеством другого. Возвращает `True` или `False`.
```py
set1 = {2, 3}
set2 = {1, 2, 3, 4, 5, 6}
print(set1.issubset(set2))
-# Вывод:
-True
+# Вывод: True
```
-Для определения, является ли одно из множеств подмножеством другого, также применяются операторы `<=` (нестрогое подмножество) и `<` (строгое подмножество). Следующий код аналогичен предыдущему:
+Для определения, является ли одно из множеств подмножеством другого, также применяются операторы `<=` (нестрогое подмножество) и `<` (строгое подмножество). Следующий код аналогичен предыдущему по функционалу:
```py
set1 = {2, 3}
set2 = {1, 2, 3, 4, 5, 6}
@@ -288,11 +302,11 @@ print(set1 <= set2)
```
* `issuperset()` - используется для определения, является ли одно из множеств надмножеством другого. Возвращает `True` или `False`.
-Для определения, является ли одно из множеств надмножеством другого, также применяются операторы `>=` (нестрогое надмножество) и `>` (строгое надмножество).
+В качестве альтернативы используются операторы `>=` (нестрогое надмножество) и `>` (строгое надмножество).
* `isdisjoint()` - используется для определения отсутствия общих элементов в множествах. Возвращает `True` или `False`.
-Эти методы могут принимать в качестве аргумента не только `set()`, но и любой итерируемый объект (список, строку, кортеж...). Сами же эти методы могут применяться только к `set()` или неизменяемому множеству (тип данных `frozenset`). При этом операторы `>`, `<`, `>=`, `<=` требуют наличия в качестве операндов множества.
+Данные методы могут принимать в качестве аргумента не только `set()`, но и любой итерируемый объект (список, строку, кортеж...). В то же время они могут применяться только к `set()` или неизменяемому множеству (тип данных `frozenset`). При этом операторы `>`, `<`, `>=`, `<=` требуют наличия в качестве операндов множества.
---
### Генератор множеств
@@ -301,11 +315,10 @@ print(set1 <= set2)
`{выражение for переменная in последовательность}`,
-где выражение — некоторое выражение, как правило, зависящее от использованной в списочном выражении переменной, которым будут заполнены элементы множества переменная — имя некоторой переменной, последовательность — последовательность значений, которые она принимает (любой итерируемый объект).
+где выражение – некоторое выражение, как правило, зависящее от использованной в списочном выражении переменной, которым будут заполнены элементы множества; переменная – имя некоторой переменной; последовательность – последовательность значений, которые она принимает (любой итерируемый объект).
-В генераторах множеств можно использовать условный оператор. Например, если требуется создать множество, заполненное только цифрами некоторой строки, то мы можем написать такой код:
-`digits = {int(d) for d in 'abcd12ef78ghj90' if d.isdigit()}`
-Если же нужно включить `else`, то условие нужно включить до самого цикла:
+В генераторах множеств можно использовать условный оператор. Например, если требуется создать множество, заполненное только цифрами некоторой строки, то мы можем написать такой код: `digits = {int(d) for d in 'abcd12ef78ghj90' if d.isdigit()}`
+Если же нужно включить `else`, то используется тернарный условный опреатор:
`alnums = {int(d) if d.isdigit() else ord(d) for d in 'abcd12ef78ghj90'}`
---
@@ -317,15 +330,21 @@ myset2 = frozenset([1, 1, 2, 3, 4, 4, 4, 5, 6, 6]) # на основе спи
myset3 = frozenset('aabcccddee') # на основе строки
```
-Над замороженными множествами можно производить все операции, которые можно производить над обычными множествами (конечно, если операция не изменяет исходное множество). Результатом операций над замороженными множествами будут тоже замороженные множества.
-Будучи изменяемыми, обычные множества не могут быть элементами других множеств. Замороженные множества являются неизменяемыми, а значит могут быть элементами других множеств. \
+Над замороженными множествами можно производить все операции, которые можно производить над обычными множествами (само собой, если операция не изменяет исходное множество). Результатом операций над замороженными множествами будут также замороженные множества.
+Будучи изменяемыми, обычные множества не могут быть элементами других множеств. Замороженные множества являются неизменяемыми, а значит могут быть элементами других множеств.
+
+{{< alert "circle-info" >}}
Сравнивать обычные и неизменяемые множества **можно**.
+{{< /alert >}}
---
## **Словари**
### Общая информация
Словари (тип данных `dict`) – изменяемые коллекции элементов с произвольными индексами – **ключами**. Если в списках элементы индексируются целыми числами, начиная с 0, то в словарях — уникальными ключами, в том числе в виде строк.
+
+{{< alert icon="bars" >}}
Словарь — реализация структуры данных "ассоциативный массив" или "хеш таблица".
+{{< /alert >}}
В словорях **нет** привычных индексов (0, 1, 2, ...)!
@@ -333,7 +352,7 @@ myset3 = frozenset('aabcccddee') # на основе стр
Словари принципиально отличаются от списков по структуре хранения в памяти. Список — последовательная область памяти, то есть все его элементы (указатели на элементы) действительно хранятся в указанном порядке, расположены последовательно. Благодаря этому и можно быстро «прыгнуть» к элементу по его индексу. В словаре же используется специальная структура данных — хеш-таблица. Она позволяет вычислять числовой хеш от ключа и использовать обычные списки, где в качестве индекса элемента берется этот хеш.
-Чтобы создать словарь, нужно перечислить его элементы – пары ключ-значение – через запятую в фигурных скобках, как и элементы множества. Первым указывается ключ, после двоеточия — значение, доступное в словаре по этому ключу. Приведенный ниже код создает словарь, в котором ключом служит строка — название языка программирования, а значением — имя создателя языка.
+Чтобы создать словарь, нужно перечислить его элементы (пары ключ-значение) через запятую в фигурных скобках, как и элементы множества. Первым указывается ключ, после двоеточия – значение, доступное в словаре по этому ключу. Приведенный ниже код создает словарь, в котором ключом служит строка – название языка программирования, а значением – имя создателя языка.
```py
languages = {'Python': 'Гвидо ван Россум',
'C#': 'Андерс Хейлсберг',
@@ -346,12 +365,12 @@ languages = {'Python': 'Гвидо ван Россум',
print('Создателем языка C# является', languages['C#'])
```
-В качестве ключа можно указать выражение: Python вычислит его значение и обратится к искомому элементу.
+В качестве ключа можно указать выражение. Python вычислит его значение и обратится к искомому элементу:
```py
print('Создателем языка C# является', languages['C' + '#'])
```
-Если ключи словаря — строки без каких-либо специальных символов, то для создания словаря можно использовать функцию `dict()`. Приведённый ниже код создает словарь с тремя элементами, ключами которого служат строки 'name', 'age', 'job', а значениями – 'Timur', 28, 'Teacher'.
+Если ключи словаря – строки без каких-либо специальных символов, то для создания словаря можно использовать функцию `dict()`. Приведённый ниже код создает словарь с тремя элементами, ключами которого служат строки 'name', 'age', 'job', а значениями – 'Timur', 28, 'Teacher'.
```py
info = dict(name = 'Timur', age = 28, job = 'Teacher')
```
@@ -401,7 +420,9 @@ for key in capitals:
```py
for key in capitals.keys(): # итерируем по списку ["Россия", "Франция", "Чехия"]
print(key)
+```
+```
# Вывод:
Россия
Франция
@@ -412,7 +433,9 @@ for key in capitals.keys(): # итерируем по списку ["Росси
* Словарный метод `items()` возвращает список всех элементов словаря, состоящий из кортежей пар (ключ, значение).
-Примечание: Словарные методы `items()`, `keys()`, `values()` возвращают не совсем обычные списки. Типы этих списков – `dict_items`, `dict_keys`, `dict_values`, соответственно, в отличие от обычных списков `list`. Методы обычных списков недоступны для списков типа `dict_items`, `dict_keys`, `dict_values`. Нужно использовать явное преобразование с помощью функции `list()` для получения доступа к методам списков.
+{{< alert "circle-info" >}}
+Словарные методы `items()`, `keys()`, `values()` возвращают не совсем обычные списки. Типы этих списков – `dict_items`, `dict_keys`, `dict_values`, соответственно, в отличие от обычных списков `list`. Методы обычных списков недоступны для списков типа `dict_items`, `dict_keys`, `dict_values`. Нужно использовать явное преобразование с помощью функции `list()` для получения доступа к методам списков.
+{{< /alert >}}
Если требуется вывести только ключи словаря, то мы так же можем использовать операцию распаковки словаря: `print(*capitals, sep="\n")`
@@ -429,7 +452,7 @@ for key, value in sorted(capitals.items(), key=lambda x: x[1]):
```
---
-### Методы словарей
+### Методы и операторы словарей
Чтобы изменить значение по определенному ключу в словаре, достаточно использовать индексацию вместе с оператором присваивания. При этом если ключ уже присутствует в словаре, его значение заменяется новым, если же ключ отсутствует – то в словарь будет добавлен новый элемент.
```py
info = {'name': 'Sam',
@@ -442,7 +465,7 @@ info['email'] = 'timyr-guev@yandex.ru' # добавляем в словарь
print(info)
```
-* Для того чтобы избежать возникновения ошибки в случае отсутствия ключа в словаре, можно использовать метод `get()`, способный кроме ключа принимать и второй аргумент — значение, которое вернется, если заданного ключа нет. Когда второй аргумент не указан, то метод в случае отсутствия ключа возвращает `None`.
+* Для того чтобы избежать возникновения ошибки в случае отсутствия ключа в словаре, можно использовать метод `get()`, способный кроме ключа принимать и второй аргумент – значение, которое вернется, если заданного ключа нет. Когда второй аргумент не указан, то метод в случае отсутствия ключа возвращает `None`.
```py
info = {'name': 'Bob',
'age': 25,
@@ -453,7 +476,9 @@ item2 = info.get('salary', 'Информации о зарплате нет')
print(item1)
print(item2)
+```
+```
# Вывод:
None
Информации о зарплате нет
@@ -473,16 +498,21 @@ info1.update(info2)
print(info1)
-# Вывод
-{'name': 'Bob', 'age': 30, 'job': 'Dev', 'city': 'New York', 'email': 'bob@web.com'}
+# Вывод: {'name': 'Bob', 'age': 30, 'job': 'Dev', 'city': 'New York', 'email': 'bob@web.com'}
+
```
+{{< alert "circle-info" >}}
В Python 3.9 появились операторы | и |=, которые реализуют операцию конкатенации словарей.
+{{< /alert >}}
* Метод `setdefault()` позволяет получить значение из словаря по заданному ключу, автоматически добавляя элемент словаря, если он отсутствует.
Метод принимает два аргумента:
1. key: ключ, значение по которому следует получить, если таковое имеется в словаре, либо создать.
2. default: значение, которое будет использовано при добавлении нового элемента в словарь.
-**Важно:** `get()` только получает значение, не меняя словарь, в то время как `setdefault()` не только получает значение, но и изменяет словарь.
+
+{{< alert >}}
+**Важно!** `get()` только получает значение, не меняя словарь, в то время как `setdefault()` не только получает значение, но и изменяет словарь.
+{{< /alert >}}
* С помощью оператора `del` можно удалять элементы словаря по ключу: `del info['email']` (если удаляемого ключа в словаре нет, возникнет ошибка `KeyError`).
* Метод `pop()` удаляет элемент словаря по ключу, возвращая его значение: `email = info.pop('email')` (при отутствии ключа также возвращает ошибку, если не передать второй аргумент).
@@ -499,7 +529,7 @@ print(info1)
Общий вид: `{ключ: значение for переменная in последовательность}`
**Примеры использования:**
-* Чтобы создать словарь, где ключи - числа от 0 до 5, а значения - квадраты ключей, можем воспользоваться след. кодом: `squares = {i: i**2 for i in range(6)}`;
+* Чтобы создать словарь, где ключи – числа от 0 до 5, а значения – квадраты ключей, можем воспользоваться следующим кодом: `squares = {i: i**2 for i in range(6)}`;
* Для вычисления ключа и значения в генераторе словаря могут быть использованы выражения:
```py
lst = ['ReD', 'GrEeN', 'BlUe']
@@ -507,8 +537,7 @@ dct = {c.lower(): c.upper() for c in lst}
print(dct)
-# Вывод
-{'red': 'RED', 'green': 'GREEN', 'blue': 'BLUE'}
+# Вывод: {'red': 'RED', 'green': 'GREEN', 'blue': 'BLUE'}
```
* Извлечение из словаря элементов с определенными ключами:
@@ -520,8 +549,7 @@ dict2 = {k: dict1[k] for k in selected_keys}
print(dict2)
-# Вывод
-{0: 'A', 2: 'C', 5: 'F'}
+# Вывод: {0: 'A', 2: 'C', 5: 'F'}
```
* Мы также можем использовать генераторы словарей для создания вложенных словарей:
@@ -530,8 +558,10 @@ squares = {i: {j: j**2 for j in range(i + 1)} for i in range(5)}
for value in squares.values():
print(value)
+```
-# Вывод
+```
+# Вывод:
{0: 0}
{0: 0, 1: 1}
{0: 0, 1: 1, 2: 4}
diff --git a/content/posts/frac_dec_compl/index.md b/content/posts/frac_dec_compl/index.md
index a2de26d..309c3c4 100644
--- a/content/posts/frac_dec_compl/index.md
+++ b/content/posts/frac_dec_compl/index.md
@@ -18,28 +18,28 @@ series_order: 3
Если мы хотим сравнить два числа `float`, то нужно воспользоваться кодом ниже вместо обычного сравнения `==`, так как существуют ограничения в сохранении точного значения чисел:
```py
num = 0.1 + 0.1 + 0.1
-eps = 0.000000001 # точность сравнения
+eps = 0.000000001 # точность сравнения
-if abs(num - 0.3) < eps: # число num отличается от числа 0.3 менее чем 0.000000001
+if abs(num - 0.3) < eps: # число num отличается от числа 0.3 менее чем 0.000000001
print('YES')
else:
print('NO')
```
Особенности и характеристики:
-* Тип данных `Decimal` - класс из модуля decimal, который тоже представляет собой число с плавающей точкой, и служит для того, чтобы выполнять операции над вещественными числами точно.
-* С ними работают все привычные операции (сложение, умножение и т.д., но не реккомендуется оперировать между `Decimal` и `float`), их можно передавать как аргумент в математические функции (при этом вернётся `float`), их можно сравнивать между собой (также допускается точное равенство), можно формировать списки из `Decimal` и искать среди них `min` и `max`.
+* Тип данных `Decimal` - класс из модуля `decimal`, который тоже представляет собой число с плавающей точкой, и служит для того, чтобы выполнять операции над вещественными числами без ошибок.
+* С ними работают все привычные операции (сложение, умножение и т.д., но не реккомендуется оперировать между `Decimal` и `float`), их можно передавать как аргумент в математические функции (при этом вернётся `float`), их можно сравнивать между собой (также допускается точное равенство), можно формировать списки из `Decimal` и искать среди них `min` и `max`.
* Тип данных `Decimal` является **неизменяемым**.
Отличие `float` и `Decimal`:
В Python тип данных `float` реализован по стандарту IEEE-754 как число с плавающей точкой двойной точности (64 бита) с основанием экспоненты равным 2. Так как `float` поддерживается аппаратно, быстродействие при использовании этого типа данных сравнительно велико.
-Тип данных `Decimal` – число с плавающей точкой с основанием экспоненты 10 Он реализован по стандарту IBM: General Decimal Arithmetic Specification, в свою очередь основанному на стандартах IEEE. Тип данных `Decimal` реализован программно, поэтому он в разы медленнее типа данных `float`, реализованного аппаратно. Сам тип данных `Decimal` написан на языке `С`.
+Тип данных `Decimal` – число с плавающей точкой с основанием экспоненты 10 Он реализован по стандарту IBM: General Decimal Arithmetic Specification, в свою очередь основанному на стандартах IEEE. Тип данных `Decimal` реализован программно, поэтому он в разы медленнее типа данных `float`. Сам тип данных `Decimal` написан на языке `С`.
| Характеристика / тип | float | Decimal |
-| :--: | :---: | :---: |
+| :-- | :---: | :---: |
| Реализация | аппаратная | программная |
| Размер | 64 бит | не ограничен |
-| Основные экспоненты | 2 | 10 |
+| Основание экспоненты | 2 | 10 |
| Скорость | ✔️ | ❌ |
| Настриваемость | ❌ | ✔️ |
| Для высокоточных вычислений | ❌ | ✔️ |
@@ -60,7 +60,7 @@ d4 = Decimal('12345')
d5 = Decimal('52.198')
```
-При создании Decimal чисел из чисел с плавающей точкой (float) возникают проблемы, так как float числа округляются внутри до ближайшего возможного, а Decimal об этом ничего не знает и копирует содержимое float:
+При создании `Decimal` чисел из чисел с плавающей точкой (`float`) возникают проблемы, так как `float` числа округляются внутри до ближайшего возможного, а `Decimal` об этом ничего не знает и копирует содержимое `float`:
```py
from decimal import *
@@ -68,8 +68,7 @@ num = Decimal(0.1)
print(num)
-# Вывод:
-0.1000000000000000055511151231257827021181583404541015625
+# Вывод: 0.1000000000000000055511151231257827021181583404541015625
```
---
@@ -77,22 +76,11 @@ print(num)
* У `Decimal` есть некоторые встроенные математические методы:
|Функция|Описание|
-|:--:|:--:|
+|:--:|:--|
|`sqrt()`|вычисляет квадратный корень из `Decimal` числа|
-|`exp()`|озвращает $e^x$ для `Decimal` числа|
-|`ln()`|вычисляет натуральный логарифм (по основанию e) `Decimal` числа|
-|`log10()`|вычисляет десятичный логарифм (по основанию 10) `Decimal` числа|
-
-```py
-from decimal import *
-
-num = Decimal('10.0')
-
-print(num.sqrt())
-print(num.exp())
-print(num.ln())
-print(num.log10())
-```
+|`exp()`|возвращает e^x для `Decimal` числа|
+|`ln()`|вычисляет натуральный логарифм `Decimal` числа|
+|`log10()`|вычисляет десятичный логарифм `Decimal` числа|
* `as_tuple()` - возвращает кортеж из 3-ёх элементов:
* `sign` – знак числа (0 для положительного числа и 1 для отрицательного числа);
@@ -111,8 +99,10 @@ print(num2.as_tuple())
print(num1_tuple.sign)
print(num1_tuple.digits)
print(num1_tuple.exponent)
+```
-# Вывод
+```
+# Вывод:
DecimalTuple(sign=1, digits=(1, 4, 5, 6, 8, 7, 6, 9, 0, 1, 7), exponent=-10)
DecimalTuple(sign=0, digits=(5, 2, 3), exponent=-3)
1
@@ -126,29 +116,32 @@ from decimal import *
print(getcontext())
-# Вывод:
-Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0,
-flags=[], traps=[InvalidOperation, DivisionByZero, Overflow])
+# Вывод: Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[InvalidOperation, DivisionByZero, Overflow])
```
* `quantize()` - принимает в качетсве аргумента объект `Decimal`, указывающий на формат округления:
```py
from decimal import *
-getcontext().prec = 4 # устанавливаем точность числа
+getcontext().prec = 4 # устанавливаем точность числа
num = Decimal('3.1415926535')
-print(num.quantize(Decimal('1.000'))) # округление до 3 цифр в дробной части
-print(num.quantize(Decimal('1.00'))) # округление до 2 цифр в дробной части
-print(num.quantize(Decimal('1.0'))) # округление до 1 цифр в дробной части
+print(num.quantize(Decimal('1.000'))) # округление до 3 цифр в дробной части
+print(num.quantize(Decimal('1.00'))) # округление до 2 цифр в дробной части
+print(num.quantize(Decimal('1.0'))) # округление до 1 цифр в дробной части
```
+
+{{< alert icon="fire" cardColor="#e63946" iconColor="#1d3557" textColor="#f1faee" >}}
При этом, если точность числа установлена в 2, а формат округления `Decimal('1.00')`, то возникнет ошибка.
+{{< /alert >}}
+
+
В качетсве второго параметра этот метод принимает стратегию округления:
-`ROUND_CEILING` – округление в направлении бесконечности (Infinity);
-`ROUND_FLOOR` – округляет в направлении минус бесконечности (- Infinity);
-`ROUND_DOWN` – округление в направлении нуля;
+`ROUND_CEILING` – округление в сторону бесконечности (Infinity);
+`ROUND_FLOOR` – округляет в сторону минус бесконечности (- Infinity);
+`ROUND_DOWN` – округление в сторону нуля;
`ROUND_HALF_EVEN` – округление до ближайшего четного числа, число 6.5 округлится не до 7, а до 6;
`ROUND_HALF_DOWN` – округление до ближайшего нуля;
`ROUND_UP` – округление от нуля;
@@ -160,7 +153,9 @@ num = Decimal('3.456')
print(num.quantize(Decimal('1.00'), ROUND_CEILING))
print(num.quantize(Decimal('1.00'), ROUND_FLOOR))
+```
+```
# Вывод:
3.46
3.45
@@ -170,15 +165,17 @@ print(num.quantize(Decimal('1.00'), ROUND_FLOOR))
## **Модуль fractions**
Для использования: `from fractions import Fraction`
+Тип данных `Fraction` представляет из себя рациональное число в виде дроби.
+
Особенности и характеристики:
-* `Fraction` - тип данных для работы с рациональными числами в Python. Он, как и `Decimal`, реализован программно, поэтому он в разы медленнее встроенных числовых типов данных `int` и `float`.
+* `Fraction`, как и `Decimal`, реализован программно, поэтому он в разы медленнее встроенных числовых типов данных `int` и `float`.
* Тип данных `Fraction` неизменяемый.
* Операции над данными этого типа приводят к созданию новых объектов, при этом старые не меняются. `Fraction` числа можно сравнивать между собой точно так же, как и любые другие числа (также можно сравнить `Fraction` и целые числа без явного приведения типов); с ним работат все арифметические операции (возведение в степень может вернуть `float`).
* При создании рационального числа Fraction, автоматически происходит сокращение числителя и знаменателя дроби, а если результат - целое число, то оно и будет выведено.
* `Fraction` числа можно передавать как аргументы функций, ожидающих `float`. Тогда они будут преобразованы во `float`. К примеру, модуль `math`, оперирующий `float` числами, может работать и с `Fraction` числами (возвращать функции будут `float`).
-Создать Fraction число можно несколькими способами:
-- из целых чисел, передав значения числителя и знаменателя дроби,
+Создать `Fraction` число можно несколькими способами:
+- из целых чисел, передав значения числителя и знаменателя дроби;
- из строки на основании десятичного представления;
- из строки на основании обыкновенной дроби;
- из числа с плавающей точкой (не рекомендуется, так как в `Fraction` попадет уже неправильно округленное число).
@@ -186,7 +183,7 @@ print(num.quantize(Decimal('1.00'), ROUND_FLOOR))
```py
from fractions import Fraction
-num1 = Fraction(3, 4) # 3 - числитель, 4 - знаменатель
+num1 = Fraction(3, 4) # 3 – числитель, 4 – знаменатель
num2 = Fraction('0.55')
num3 = Fraction('1/9')
```
@@ -201,14 +198,16 @@ num = Fraction('5/16')
print('Числитель дроби равен:', num.numerator)
print('Знаменатель дроби равен:', num.denominator)
+```
+```
# Вывод:
Числитель дроби равен: 5
Знаменатель дроби равен: 16
```
-* `as_integer_ratio()` - возвращает кортеж, состоящий из числителя и знаменателя данного `Fraction` числа.
-* `limit_denominator()` - возвращает самую близкую к данному числу рациональную дробь, чей знаменатель не превосходит переданного аргумента:
+* `as_integer_ratio()` – возвращает кортеж, состоящий из числителя и знаменателя данного `Fraction` числа.
+* `limit_denominator()` – возвращает самую близкую к данному числу рациональную дробь, чей знаменатель не превосходит переданного аргумента:
```py
from fractions import Fraction
import math
@@ -222,7 +221,9 @@ print('No limit =', num)
for d in [1, 5, 50, 90, 100, 500, 1000000]:
limited = num.limit_denominator(d)
print(limited)
+```
+```
# Вывод:
PI = 3.141592653589793
No limit = 3141592653589793/1000000000000000
@@ -235,7 +236,9 @@ No limit = 3141592653589793/1000000000000000
3126535/995207
```
-В Python нельзя совершать арифметические операции (+, -, *, /) между типами Decimal и Fraction.**
+{{< alert "circle-info" >}}
+В Python нельзя совершать арифметические операции (+, -, *, /) между типами Decimal и Fraction.
+{{< /alert >}}
---
## **Комплексные числа в Python**
@@ -255,7 +258,9 @@ z4 = 1.5 + 3.2j
print(z1, z2, z3, z4, sep='\n')
print(type(z1))
+```
+```
# Вывод:
(5+7j)
1j
@@ -264,7 +269,7 @@ print(type(z1))
```
-Комплексные числа можно создать с помощью литерала, как выше, а можно с помощью функции `complex()`, которая принимает два аргумента: вещественную и мнимую часть числа, либо строковое представление числа.
+Комплексные числа можно создать с помощью литерала, как выше, а можно с помощью функции `complex()`, которая принимает два аргумента: вещественную и мнимую часть числа, либо строковое представление числа:
```py
z1 = -3 + 2j # создание на основе литерала
z2 = complex(6, -8) # z2 = 6 - 8j
@@ -273,7 +278,9 @@ z4 = complex(5, 0) # z4 = 5 + 0j
z5 = complex('3+4j') # создание на основе строки
print(z1, z2, z3, z4, z5, sep='\n')
+```
+```
# Вывод:
(-3+2j)
(6-8j)
@@ -290,7 +297,9 @@ z = 3+4j
print('Действительная часть =', z.real)
print('Мнимая часть =', z.imag)
+```
+```
# Вывод:
Действительная часть = 3.0
Мнимая часть = 4.0
diff --git a/content/posts/functions2/featurelavalamp.svg b/content/posts/functions/featurelavalamp.svg
similarity index 100%
rename from content/posts/functions2/featurelavalamp.svg
rename to content/posts/functions/featurelavalamp.svg
diff --git a/content/posts/functions2/index.md b/content/posts/functions/index.md
similarity index 74%
rename from content/posts/functions2/index.md
rename to content/posts/functions/index.md
index bd91536..5aa2866 100644
--- a/content/posts/functions2/index.md
+++ b/content/posts/functions/index.md
@@ -14,13 +14,13 @@ series_order: 5
## **Необязательные и именованные аргументы**
### Позиционные аргументы
-Когда мы вызываем функции c позиционными аргументами, значения в их аргументы подставляются согласно позиции их имен в определении функции. Например Такой код выведет число 7 При вызове функции `diff()` первому параметру x будет соответствовать первый переданный аргумент — 10, а второму параметру y — второй аргумент — 3.
+Когда мы вызываем функции c позиционными аргументами, значения в них подставляются согласно позиции их имен в определении функции. Например код ниже выведет число 7. При вызове функции `diff()` первому параметру x будет соответствовать первый переданный аргумент – 10, а второму параметру y – второй аргумент – 3.
```py
def diff(x, y):
return x - y
-res = diff(10, 3) # используем позиционные аргументы
+res = diff(10, 3) # используем позиционные аргументы
print(res)
```
@@ -41,7 +41,9 @@ print(bar(char2='*', length=3, char1='-'))
При вызове функции меняется порядок передаваемых аргументов. Когда функции назначаются соответствующие значения именованных аргументов, Python учитывает их имена, а не позиции. В результате функция будет всегда выводить одно и то же значение независимо от позиций переданных ей аргументов.
+{{< alert "circle-info" >}}
**Рекомендация** по тому, когда стоит использовать именованные аргументы: если функция принимает больше трёх аргументов, нужно хотя бы часть из них указать по имени.
+{{< /alert >}}
```py
def make_circle(x, y, radius, line_width, fill):
# тело функции
@@ -49,12 +51,14 @@ def make_circle(x, y, radius, line_width, fill):
make_circle(x=200, y=300, radius=17, line_width=2.5, fill=True)
```
-Мы можем вызывать функции, используя именованные и позиционные аргументы одновременно. Но позиционные значения должны быть указаны до любых именованных!
+{{< alert >}}
+Мы можем вызывать функции, используя именованные и позиционные аргументы одновременно. Но позиционные значения должны быть указаны до любых именованных!
+{{< /alert >}}
---
### Необязательные аргументы
Бывает, что какой-то параметр функции часто принимает одно и то же значение. Например, для функции `print()` установили значения параметров `sep` и `end` равными символу пробела и символу перевода строки, поскольку эти значения используют наиболее часто.
-Другим примером служит функция `int()`, преобразующая строку в число. Она принимает два аргумента: первый аргумент — строка, которую нужно преобразовать в число, второй аргумент — основание системы счисления, значение по умолчению которого — 10.
+Другим примером служит функция `int()`, преобразующая строку в число. Она принимает два аргумента: первый аргумент – строка, которую нужно преобразовать в число, второй аргумент – основание системы счисления, значение по умолчению которого равно 10.
Чтобы задать значение параметра по умолчанию, в списке параметров функции достаточно после имени переменной написать знак равенства и нужное значение.
Параметры со значением по умолчанию идут последними.
@@ -72,15 +76,17 @@ def append(element, seq=[]):
print(append(10))
print(append(5))
print(append(1))
+```
+```
# Вывод:
[10]
[10, 5]
[10, 5, 1]
```
-Значение по умолчанию для параметра создается **единожды** при определении функции (обычно при загрузке модуля) и становится атрибутом (свойством) функции. Поэтому, если значение по умолчанию изменяемый объект, то его изменение повлияет на каждый следующий вызов функции.
-Для решения проблемы можно использовать константу None в качестве значения параметра по умолчанию, а в теле функции устанавливать нужное значение:
+Значение по умолчанию для параметра создается **единожды** при определении функции (обычно при загрузке модуля) и становится её атрибутом (свойством). Поэтому, если значение по умолчанию изменяемый объект, то его изменение повлияет на каждый следующий вызов функции.
+Для решения проблемы можно использовать константу `None` в качестве значения параметра по умолчанию, а в теле функции устанавливать нужное значение:
```py
def append(element, seq=None):
if seq is None:
@@ -91,7 +97,9 @@ def append(element, seq=None):
print(append(10))
print(append(5))
print(append(1))
+```
+```
# Вывод:
[10]
[5]
@@ -100,7 +108,7 @@ print(append(1))
---
## **Функции с переменным количеством аргументов**
-### Позиционные аргументы - *args
+### Позиционные аргументы – *args
Рассмотрим определение функции `my_func()`:
```py
def my_func(*args):
@@ -111,8 +119,10 @@ def my_func(*args):
my_func()
my_func(1, 2, 3)
my_func('a', 'b')
+```
-# Вывод
+```
+# Вывод:
()
@@ -132,12 +142,11 @@ def my_sum(*args):
print(my_sum(1, 2, *[3, 4, 5], *(7, 8, 9), 10))
-# Вывод
-49
+# Вывод: 49
```
---
-### Именованные аргументы - **kwargs
+### Именованные аргументы – **kwargs
```py
def my_func(**kwargs):
print(type(kwargs))
@@ -146,7 +155,9 @@ def my_func(**kwargs):
my_func()
my_func(a=1, b=2)
my_func(name='Timur', job='Teacher')
+```
+```
# Вывод:
{}
@@ -169,7 +180,9 @@ def my_func(a, b, *args, name='Gvido', age=17, **kwargs):
my_func(1, 2, 3, 4, name='Timur', age=28, job='Teacher', language='Python')
my_func(1, 2, name='Timur', age=28, job='Teacher', language='Python')
my_func(1, 2, 3, 4, job='Teacher', language='Python')
+```
+```
# Вывод:
1 2
(3, 4)
@@ -189,15 +202,15 @@ Gvido 17
---
## **Keyword-only аргументы**
-В Python 3 добавили возможность пометить именованные аргументы функции так, чтобы вызвать функцию можно было, только передав эти аргументы по именам. Такие аргументы называются `keyword-only` и их нельзя передать в функцию в виде позиционных.
+В Python 3 добавили возможность пометить именованные аргументы функции так, чтобы вызвать функцию можно было, только передав эти аргументы по именам. Такие аргументы называются `keyword-only` и их нельзя передать в функцию в виде позиционных:
```py
def make_circle(x, y, radius, *, line_width=1, fill=True):
#код
-make_circle(10, 20, 5) # x=10, y=20, radius=5, line_width=1, fill=True
-make_circle(x=10, y=20, radius=7) # x=10, y=20, radius=7, line_width=1, fill=True
-make_circle(10, 20, radius=10, line_width=2, fill=False) # x=10, y=20, radius=10, line_width=2, fill=False
-make_circle(x=10, y=20, radius=17, line_width=3) # x=10, y=20, radius=17, line_width=3, fill=True
+make_circle(10, 20, 5) # x=10, y=20, radius=5, line_width=1, fill=True
+make_circle(x=10, y=20, radius=7) # x=10, y=20, radius=7, line_width=1, fill=True
+make_circle(10, 20, radius=10, line_width=2, fill=False) # x=10, y=20, radius=10, line_width=2, fill=False
+make_circle(x=10, y=20, radius=17, line_width=3) # x=10, y=20, radius=17, line_width=3, fill=True
```
Здесь `*` выступает разделителем: отделяет обычные аргументы (их можно указывать по имени и позиционно) от строго именованных.
То есть аргументы `x`, `y` и `radius` могут быть переданы в качестве как позиционных, так и именованных аргументов. При этом аргументы `line_width` и `fill` могут быть переданы только как именованные аргументы.
@@ -220,8 +233,8 @@ def hello():
print('Hello from function')
-func = hello # присваиваем переменной func функцию hello
-func() # вызываем функцию
+func = hello # присваиваем переменной func функцию hello
+func() # вызываем функцию
# Вывод: Hello from function
```
@@ -231,13 +244,15 @@ writeln = print
writeln('Hello world!')
writeln('Python')
+```
+```
# Вывод:
Hello world!
Python
```
-Присваивоение переменной списка функций:
+Присваивание переменной списка функций:
```py
def f(x):
return x**2
@@ -253,20 +268,24 @@ print(funcs[0](5), funcs[1](5))
# Вывод: 25 125
```
+{{< alert "circle-info" >}}
Функции, способные в качестве аргумента принимать или/и возвращать другие функции, называются функциями **высшего порядка**.
Функция, определяющая условия сравнения элементов, называется **компаратор**.
+{{< /alert >}}
-Такие встроенные функции, как `min()`, `max()`, `sorted()` могут принимать необязательный аргумент `key` - функцию, определяющую, по какому правилу будут сравниваться элементы (значение `key` должно быть функцией, принимающей один аргумент и возвращающей на его основе ключ для сравнения).
+Такие встроенные функции, как `min()`, `max()`, `sorted()` могут принимать необязательный аргумент `key` – функцию, определяющую, по какому правилу будут сравниваться элементы (значение `key` должно быть функцией, принимающей один аргумент и возвращающей на его основе ключ для сравнения).
```py
numbers = [10, -7, 8, -100, -50, 32, 87, 117, -210]
print(max(numbers, key=abs))
print(min(numbers, key=abs))
print(sorted(numbers, key=abs))
+```
+```
# Вывод:
--210 # максимальный по модулю элемент
--7 # минимальный по модулю элемент
+-210 # максимальный по модулю элемент
+-7 # минимальный по модулю элемент
[-7, 8, 10, 32, -50, 87, -100, 117, -210]
```
@@ -281,8 +300,8 @@ def compare_by_sum(point):
points = [(1, -1), (2, 3), (-10, 15), (10, 9), (7, 18), (1, 5), (2, -4)]
-print(sorted(points, key=compare_by_second)) # сортируем по второму значению кортежа
-print(sorted(points, key=compare_by_sum)) # сортируем по сумме кортежа
+print(sorted(points, key=compare_by_second)) # сортируем по второму значению кортежа
+print(sorted(points, key=compare_by_sum)) # сортируем по сумме кортежа
```
---
@@ -315,7 +334,9 @@ h = generator_square_polynom(a=-3, b=-10, c=50)
print(f(1))
print(g(2))
print(h(-1))
+```
+```
# Вывод:
4
5
@@ -329,7 +350,7 @@ print(h(-1))
Функции, которые принимают и/или возвращают другие функции, называются **функциями высшего порядка**.
### Функция `map()`
-Функция, преобразующая каждый элемент переданного итерируемого объекта (можно воспринимать как классическое представление функции в математике - отображение множества в другое множество).
+Функция, преобразующая каждый элемент переданного итерируемого объекта (можно воспринимать как классическое представление функции в математике – отображение множества в другое множество).
Возможная реализация:
```py
def map(function, items):
@@ -353,17 +374,19 @@ def cube(x):
numbers = [1, 2, -3, 4, -5, 6, -9, 0]
-strings = map(str, numbers) # используем в качестве преобразователя - функцию str
-abs_numbers = map(abs, numbers) # используем в качестве преобразователя - функцию abs
+strings = map(str, numbers) # используем в качестве преобразователя функцию str
+abs_numbers = map(abs, numbers) # используем в качестве преобразователя функцию abs
-squares = map(square, numbers) # используем в качестве преобразователя - функцию square
-cubes = map(cube, numbers) # используем в качестве преобразователя - функцию cube
+squares = map(square, numbers) # используем в качестве преобразователя функцию square
+cubes = map(cube, numbers) # используем в качестве преобразователя функцию cube
print(strings)
print(abs_numbers)
print(squares)
print(cubes)
+```
+```
# Вывод:
['1', '2', '-3', '4', '-5', '6', '-9', '0']
[1, 2, 3, 4, 5, 6, 9, 0]
@@ -377,8 +400,7 @@ numbers = ['-1', '20', '3', '-94', '65', '6', '-970', '8']
new_numbers = map(abs, map(int, numbers))
print(new_numbers)
-# Вывод:
-[1, 20, 3, 94, 65, 6, 970, 8]
+# Вывод: [1, 20, 3, 94, 65, 6, 970, 8]
```
---
@@ -413,7 +435,9 @@ large_words = filter(is_word_long, words)
print(odd_numbers)
print(large_words)
+```
+```
# Вывод:
[1, 3, 5, 7, 9, 11, 13]
['останутся', 'длинные']
@@ -448,7 +472,9 @@ product = reduce(mult, numbers, 1)
print(total)
print(product)
+```
+```
# Вывод:
15
120
@@ -458,22 +484,21 @@ print(product)
## **Встроенные функции map(), filter(), reduce()**
### Встроенная функция `map()`
-Функция, применяющая другую функцию к итерируемому объекту. Имеет сигнатуру `map(func, *iterables)`. В отличии от нашей реализации функция она может принимать сразу несколько последовательностей, переменное количество аргументов. Под подследовательностями имеются ввиду списки, строки, кортежи, множества, словари.
+Функция, применяющая другую функцию к итерируемому объекту. Имеет сигнатуру `map(func, *iterables)`. В отличии от нашей реализации она может принимать сразу несколько последовательностей, переменное количество аргументов. Под подследовательностями имеются ввиду списки, строки, кортежи, множества, словари.
```py
def increase(num):
return num + 7
numbers = [1, 2, 3, 4, 5, 6]
-new_numbers = map(increase, numbers) # используем встроенную функцию map()
+new_numbers = map(increase, numbers) # используем встроенную функцию map()
print(new_numbers)
-# Вывод:
-