📦 Репозиторий занятия 10

В Python есть встроенные математические функции, которые не требуют подключения библиотек — они доступны «из коробки».
Также есть модуль **math**, который добавляет дополнительные функции и константы.

Давайте разберём всё по шагам:

---

## 1. Встроенные математические функции в Python

К ним относятся:

* **abs(x)** — модуль числа
* **pow(x, y)** — возведение в степень
* **round(x, n)** — округление числа до `n` знаков
* **min() / max()** — минимальное и максимальное значение
* **sum()** — сумма элементов и т.д.

---

## 2. Как посмотреть доступные функции через Python Console?

По команде

```bash
dir(__builtins__)
```

мы увидим список всех встроенный функций и методов.  
Для отображения только функций, эту команду надо немного изменить:

```python
print(*[f for f in dir(__builtins__) if f > 'a'], sep='\n')
```

Для получения справки по конкретной функции (например, `round`) вводим
```python
help(round)
```


---

## 3. Таблица встроенных математических функций

| Функция          | Описание                                  | Пример              | Результат |
| ---------------- |-------------------------------------------| ------------------- | --------- |
| `abs(x)`         | Модуль числа                              | `abs(-5)`           | `5`       |
| `pow(x, y)`      | Возведение в степень                      | `pow(2, 3)`         | `8`       |
| `round(x, n)`    | Округление до `n` знаков                  | `round(3.14159, 2)` | `3.14`    |
| `min(a, b, ...)` | Минимальное значение                      | `min(3, 7, 2)`      | `2`       |
| `max(a, b, ...)` | Максимальное значение                     | `max(3, 7, 2)`      | `7`       |
| `sum(iterable)`  | Сумма элементов **коллекции**             | `sum([1, 2, 3])`    | `6`       |

## Банковское округление

В Python функция `round()` по умолчанию использует так называемое банковское округление   
(или `round half to even`), что отличается от классического округления "0.5 вверх".

### Алгоритма банковского округления

* Если дробная часть `< 0.5`, округляется ↘ (вниз):
  `round(2.3) → 2`
* Если дробная часть `> 0.5`, округляется ↗ (вверх):
  `round(2.7) → 3`
* Если дробная часть `== 0.5`, округление идёт к БЛИЖАЙШЕМУ ЧЁТНОМУ ЧИСЛУ:

  * `round(2.5) → 2`  (2 — чётное)
  * `round(3.5) → 4`  (4 — чётное)

### Какой в этм смысл?

0.5 — это строгая середина.  
Постоянное округление вверх выгодно только одной стороне.  
Поэтому попеременное округление "через одного" то вверх, то вниз  
(что фактические делает банковское округление) уравнивает выгоду сторон.

Иными словами, это правило уменьшает статистическую погрешность при большом количестве округлений,
поэтому его часто используют в банковских расчётах и финансах.

---

### Примеры:

```python
round(1.5)   # 2  (чётное ближе)
round(2.5)   # 2  (чётное ближе)
round(3.5)   # 4  (чётное ближе)
round(4.5)   # 4  (чётное ближе)
round(5.5)   # 6  (чётное ближе)
round(6.5)   # 6  (чётное ближе)
```

## 1. Понятие модуля в Python

**Модуль** — это файл с расширением `.py`, который содержит Python-код.
Главная цель модулей 
- повторное использование кода
- и структурирование проекта.

Примеры модулей:

* Встроенные — идут вместе с Python (`math`, `os`, `sys`).
* Сторонние — устанавливаются через `pip` (например, `numpy`, `pandas`).
* Пользовательские (собственные) — любой `*.py`-файл.

---

## 2. Команда `import`

Чтобы использовать код из модуля, его нужно импортировать.
Синтаксис:

```python
import module_name
```

После этого вы можете использовать функции или переменные из модуля:

```python
import math
print(math.sqrt(16))  # Вывод: 4.0
```

---

## 3. Виды импортов

| Вид импорта                  | Синтаксис                                              | Пример                      | Особенности                                                     |
| ---------------------------- | ------------------------------------------------------ | --------------------------- | --------------------------------------------------------------- |
| **Обычный импорт**           | `import module`                                        | `import math`               | Обращение к функциям через `module.func()`                      |
| **Импорт с псевдонимом**     | `import module as alias`                               | `import numpy as np`        | Удобно для длинных названий                                     |
| **Импорт отдельных функций** | `from module import func1, func2`                      | `from math import sqrt, pi` | Вызываем напрямую `sqrt(16)`, без `math.`                       |
| **Импорт всех объектов**     | `from module import *`                                 | `from math import *`        | Загружает всё, но может привести к конфликтам имён              |
| **Относительный импорт**     | `from . import module` (внутри пакета)                 | `from . import utils`       | Используется в пакетах, внутри одной директории проекта         |

---

## 4. Точка входа (`if __name__ == "__main__"`)

В каждом модуле Python есть специальная переменная `__name__`.

* Если файл запущен "напрямую":
  * `__name__` будет равно `"__main__"`.
* Если файл импортирован как модуль из исполняемого файла:
  * `__name__` будет равно имени модуля.

Это позволяет отделять код для запуска от кода для импорта:

#### Пример файла `my_module.py`
```python
# file: my_module.py
MY_CONSTANT = "моя очень важная константа"
…

## 1. Что такое стандартная библиотека Python

* Это **набор модулей**, которые устанавливаются вместе с Python 
* Их не нужно специально скачивать.
* Достаточно импортировать (подключить) их через `import`:

  ```python
  import os
  import math
  ```
* Модули написаны либо на Python, либо на C для ускорения.

---

## 2. Основные категории модулей стандартной библиотеки

| Категория                         | Примеры модулей                                                | Что делают                                                               |
| --------------------------------- | -------------------------------------------------------------- | ------------------------------------------------------------------------ |
| **Математика**                    | `math`, `cmath`, `decimal`, `fractions`                        | Математические функции, работа с комплексными числами, точная арифметика |
| **Работа с датой и временем**     | `datetime`, `time`, `calendar`                                 | Даты, время, календари                                                   |
| **Работа с файлами и ОС**         | `os`, `os.path`, `shutil`, `pathlib`, `glob`                   | Работа с путями, файлами, папками                                        |
| **Сериализация данных**           | `json`, `pickle`, `marshal`, `shelve`                          | Чтение/запись данных в разные форматы                                    |
| **Регулярные выражения**          | `re`                                                           | Поиск и замена с шаблонами                                               |
| **Многопоточность и процессы**    | `threading`, `multiprocessing`, `concurrent.futures`           | Параллельное выполнение                                                  |
| **Работа с сетью и интернетом**   | `socket`, `urllib`, `http`, `ftplib`                           | HTTP-запросы, FTP, сокеты                                                |
| **Форматы данных и файлы**        | `csv`, `xml`, `html`, `configparser`                           | Чтение/запись CSV, XML, HTML, конфигов                                   |
| **Утилиты и инструменты**         | `argparse`, `logging`, `functools`, `itertools`, `collections` | Парсинг аргументов, логирование, дополнительные структуры данных         |
| **Тестирование и отладка**        | `unittest`, `doctest`, `pdb`, `traceback`                      | Тестирование, отладка, обработка ошибок                                  |
| **Системные функции**             | `sys`, `platform`, `getpass`, `subprocess`                     | Системная информация, работа с процессами, ввод паролей                  |
| **Безопасность и шифрование**     | `hashlib`, `hmac`, `ssl`                                       | Хеширование, криптография, SSL                                           |
| **Веб-серверы и протоколы**       | `http.server`, `wsgiref`                                       | Встроенный веб-сервер, WSGI-интерфейс                                    |
| **Научные вычисления (частично)** | `statistics`, `random`                                         | Статистика, случайные числа                                              |
| **Модули для разработки**         | `venv`, `pydoc`, `typing`                                      | Виртуальные окружения, документация, аннотации типов                     |

---

## 3. Примеры использования популярных модулей

### Математика

```python
import math
print(math.pi)         # 3.141592653589793
print(math.sqrt(16))   # 4.0
```


## 4. Как посмотреть доступные модули

Через терминал:

```bash
python -m pydoc modules
```

Это выведет список всех модулей библиотек (стандартных и установленных дополнительно)

## 1. Подключение модуля

```python
import math
```

После этого можно использовать его функции, например:

```python
print(math.sqrt(16))  # 4.0
```

---

## 2. Основные группы функций `math`

### 2.1. Константы

| Константа  | Описание                         | Пример     | Результат         |
| ---------- | -------------------------------- | ---------- | ----------------- |
| `math.pi`  | Число π                          | `math.pi`  | 3.141592653589793 |
| `math.e`   | Основание натурального логарифма | `math.e`   | 2.718281828459045 |
| `math.inf` | Бесконечность                    | `math.inf` | inf               |
| `math.nan` | Not-a-Number (не число)          | `math.nan` | nan               |
| `math.tau` | 2π                               | `math.tau` | 6.283185307179586 |

---

### 2.2. Арифметические операции

| Функция             | Описание                     | Пример              | Результат |
| ------------------- | ---------------------------- | ------------------- | --------- |
| `math.sqrt(x)`      | Квадратный корень            | `math.sqrt(9)`      | 3.0       |
| `math.pow(x, y)`    | Возведение в степень         | `math.pow(2, 3)`    | 8.0       |
| `math.fabs(x)`      | Модуль (абсолютное значение) | `math.fabs(-5)`     | 5.0       |
| `math.factorial(x)` | Факториал целого числа       | `math.factorial(5)` | 120       |
| `math.fmod(x, y)`   | Остаток от деления           | `math.fmod(7, 3)`   | 1.0       |

---

### 2.3. Логарифмы и степени

| Функция         | Описание                              | Пример             | Результат   |
| --------------- | ------------------------------------- | ------------------ | ----------- |
| `math.log(x)`   | Натуральный логарифм (по основанию e) | `math.log(math.e)` | 1.0         |
| `math.log10(x)` | Логарифм по основанию 10              | `math.log10(1000)` | 3.0         |
| `math.log2(x)`  | Логарифм по основанию 2               | `math.log2(8)`     | 3.0         |
| `math.exp(x)`   | e^x                                   | `math.exp(1)`      | 2.718281828 |

---

### 2.4. Тригонометрия

| Функция           | Описание                        | Пример                  | Результат          |
| ----------------- | ------------------------------- | ----------------------- | ------------------ |
| `math.sin(x)`     | Синус (x в радианах)            | `math.sin(math.pi/2)`   | 1.0                |
| `math.cos(x)`     | Косинус                         | `math.cos(0)`           | 1.0                |
| `math.tan(x)`     | Тангенс                         | `math.tan(math.pi/4)`   | 1.0                |
| `math.asin(x)`    | Арксинус (результат в радианах) | `math.asin(1)`          | 1.5707963267948966 |
| `math.acos(x)`    | Арккосинус                      | `math.acos(1)`          | 0.0                |
…

### 1. Представление вещественного числа

Число с плавающей точкой в формате [IEEE 754 (double precision, 64 бита)](https://en.wikipedia.org/wiki/IEEE_754) состоит из трёх частей:

| Биты         | Кол-во бит | Что хранят                               |
| ------------ | ---------- | ---------------------------------------- |
| **Знак**     | 1          | 0 — положительное, 1 — отрицательное     |
| **Порядок**  | 11         | Хранит степень числа (с учётом смещения) |
| **Мантисса** | 52         | Дробная часть числа (значащие биты)      |

**Формула числа:**

```
(-1)^{sign}  1.mantissa  2^(exponent)
```

* `bias` для двойной точности = 1023
* `1.mantissa` означает, что перед двоичной точкой всегда идёт 1 (скрытая единица).

---

### 2. Пример хранения

Возьмём число `10.5`:

1. В двоичном виде: `1010.1`
2. Нормализуем: `1.0101 × 2³`
3. Знак: `0` (число положительное)
4. Порядок: `3 + 1023 = 1026` → двоично `10000000010`
5. Мантисса: `0101` + дополняем нулями до 52 бит.

В памяти получится:

```
0 10000000010 0101000000000000000000000000000000000000000000000000
```

---

### 3. Особенности

* **Точность**: 52 бита мантиссы ≈ 15–17 знаков десятичной точности.
* **Проблемы округления**: не все десятичные дроби точно представимы в двоичной системе,
  поэтому, например, `0.1 + 0.2 != 0.3` из-за двоичных погрешностей.
* **Бесконечности и NaN**:

  * `inf`, `-inf` — переполнение.
  * `NaN` (Not a Number) — результат некорректных операций.

---

### 4. В Python

```python
import sys

x = 10.5
print(type(x))      # <class 'float'>
print(sys.float_info)  # Информация о формате float в Python
```
…

### 1. Что такое `decimal`

Модуль `decimal` предоставляет **десятичные числа с плавающей точкой** с произвольной точностью.
В отличие от `float`, которые хранят числа в двоичной форме (IEEE 754),  
`Decimal` хранит **десятичные цифры напрямую**, что позволяет:

* исключить типичные ошибки округления (`0.1 + 0.2` будет точно `0.3`),
* задавать точность и правила округления вручную,
* использовать числа очень большой длины (много цифр после запятой).

```python
from decimal import Decimal

a = Decimal('0.1')
b = Decimal('0.2')
print(a + b)  # 0.3 точно
```

---

### 2. За счёт чего получается точность

Точность `Decimal` обеспечивается **фиксированной или произвольной десятичной точкой**:

* Число хранится как целое число (`significand`) и десятичная степень (`exponent`).
  Формула:

```
value = significand x 10^(exponent)
```

* Так как цифры хранятся в **десятичном виде**, нет ошибок перевода из десятичной системы в двоичную (как у `float`).

* Это похоже на **фиксированную точку**, где мы можем заранее задать, сколько цифр после запятой нужно хранить.

---

### 3. Стандартная точность

* По умолчанию `Decimal` использует **28 значащих цифр** (это стандартная точность в Python).
* Можно посмотреть/изменить через `getcontext()`:

```python
from decimal import getcontext

print(getcontext().prec)  # 28
getcontext().prec = 50    # увеличиваем точность до 50 цифр
```

---

### 4. Максимальная точность

* Теоретически ограничена только **доступной памятью**, потому что `Decimal` может хранить **произвольное количество цифр**.
* На практике в Python это число может достигать **миллионов знаков после запятой**, если хватает оперативной памяти.

---

### 5. Пример высокой точности

…