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

## Общая структура распределения памяти процесса

Обычно (в ОС Linux, Windows, macOS, и для Python в частности) процесс получает адресное пространство,  
которое делится на **сегменты**. Схематично это можно изобразить так:

```
Высокие адреса памяти
─────────────────────────────────────
|   Kernel space (ядро ОС)          |  ← процесс сюда напрямую не лезет
─────────────────────────────────────
|   Stack (стек вызовов)            |  ← растёт вниз (к меньшим адресам)
──────────────── ↕ ──────────────────
|                                   |
|   (свободная память)              |
|                                   |
──────────────── ↕ ──────────────────
|                                   |  ← растёт вверх (к большим адресам)
|   Heap (куча)                     |       в Python (в отличии от других языков программирования),
|                                   |       все объекты, созданные пользователем, живут именно здесь.
─────────────────────────────────────
|                                   |  ← глобальные и статические данные 
|   Data segment                    |       У Python-процесса здесь живут переменные 
|                                   |       самого интерпретатора
─────────────────────────────────────
|   Code segment (text segment)     |  ← машинный код программы
─────────────────────────────────────
Низкие адреса памяти
```

---

## Основные сегменты

1. **Code segment (текстовый сегмент)**

   * хранит скомпилированный код программы (в Python это логика интерпретатора и исполняемый байт-код).
   * обычно только для чтения.

2. **Data segment**

   * глобальные и статические переменные.
   * делится на `.data` (инициализированные) и `.bss` (неинициализированные).

3. **Heap (куча)**

   * выделяется динамически во время работы программы.
   * хранит объекты, которые создаются «на лету» (в Python это **все объекты: int, list, dict, class и т.д.**).
   * растёт **вверх** (к большим адресам).
   * управляется сборщиком мусора (GC) или вручную (в C).

4. **Stack (стек вызовов)**

   * хранит **кадры вызовов функций (stack frames)**.
   * в каждом кадре: локальные переменные, аргументы функции, адрес возврата.
   * растёт **вниз** (к меньшим адресам).
   * автоматически очищается при выходе из функции.

---

## Важное уточнение
…

# Изменяемые и неизменяемые типы данных

## Изменяемые (mutable) типы данных

### Примеры

```python
list, dict, set, . . .
```

### Характеристики

| Свойство                               | Описание                                                                                                                          |
| -------------------------------------- |-----------------------------------------------------------------------------------------------------------------------------------|
| **Изменение в месте (in-place)**       | Содержимое объекта можно модифицировать без создания нового объекта. <br>Например, добавление элемента в список через `append()`. |
| **Ссылочная природа**                  | Переменные и аргументы функций хранят ссылки на один объект. <br>Изменение через одну ссылку видно через все остальные.           |
| **Эффективность**                      | Меньше расход памяти и меньше операций копирования, <br>так как используется один объект.                                         |
| **Методы изменения**                   | `append()`, `extend()`, `insert()`, и т.д.                                                                                        |
| **Особенности при передаче в функцию** | Изменения внутри функции сохраняются вне её, <br>так как функция работает с той же ссылкой.                                       |

---

## Неизменяемые (immutable) типы данных

### Примеры

```python
int, float, bool, str, tuple, frozenset, bytes, . . .
```

### Характеристики

| Свойство                               | Описание                                                                                                                                                      |
| -------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Невозможность изменения в месте**    | Любая «модификация» создаёт новый объект, <br>старый остаётся неизменным.                                                                                         |
| **Ссылочная природа**                  | Передача объекта в функцию создаёт ссылку, <br>но любые «изменения» создадут новый объект, старый не изменится.                                                   |
| **Эффективность**                      | Безопасно для многопоточности; <br>меньше неожиданных побочных эффектов, <br>но возможны дополнительные затраты на создание объектов.                                 |
| **Методы изменения**                   | Не имеют методов для изменения содержимого. <br>Доступны только методы, возвращающие новый объект <br>(`replace()`, `upper()`, `+`, `*`, срезы для строк и кортежей). |
| **Особенности при передаче в функцию** | Изменения внутри функции не влияют на объект вне функции.                                                                                                     |

---

### Ключевые различия

| Признак             | Mutable                        | Immutable                                         |
| ------------------- |--------------------------------|---------------------------------------------------|
| Модификация объекта | Да, in-place                   | Нет, создаётся новый объект                       |
| Видимость изменений | Видно через все ссылки         | Нет, изменения локальны <br>(создан новый объект) |
| Методы              | Методы изменяют текущий объект | Методы возвращают новый объект                    |
| Пример              | `list`, `dict`, `set`          | `int`, `str`, `tuple`                             |

## Функция `id()`

`id(object)` — встроенная функция Python, которая возвращает  
**уникальный идентификатор объекта** в текущей сессии.

* В CPython этот идентификатор обычно совпадает с **адресом объекта в памяти (heap)**.
* Идентификатор **не меняется** в течение жизни объекта.
* **object** — любой объект Python (изменяемый или неизменяемый).
* Возвращает **целое число** (обычно адрес объекта в памяти).
* 
---

## Неизменяемые (`immutable`) типы данных

```python
a = b = 10000

print(a)  # 10000
print(b)  # 10000
print(id(a))  # 140698800665872
print(id(b))  # 140698800665872
print(id(a) == id(b))   # True, объекты одинаковые
print(a is b)           # True, a и b ссылаются на один и тот же объект

b += 1

print(a)  # 10000
print(b)  # 10001
print(id(a))  # 140698800665872
print(id(b))  # 140465933987088
print(id(a) == id(b))  # False, объекты разные
print(a is b)          # False, a и b ссылаются на РАЗНЫЕ объекты
```

---

## Изменяемые (`mutable`) типы данных

```python
a = b = [1]

print(a)  # [1]
print(b)  # [1]
print(id(a))  # 140017577855744
print(id(b))  # 140017577855744
print(id(a) == id(b))   # True, объекты одинаковые
print(a is b)           # True, a и b ссылаются на один и тот же объект

b += [1]

print(a)  # [1, 1]  --> объект a отражает изменения объекта b
print(b)  # [1, 1]
print(id(a))  # 140017577855744
print(id(b))  # 140017577855744
print(id(a) == id(b))  # True, объекты одинаковые
print(a is b)          # True, a и b ссылаются на один и тот же объект
```

## Оператор `del`


**`del`** — это встроенный оператор Python, который удаляет объект или ссылку на объект.

* Универсальный оператор, который применяется ко всем типам данных, включая 
  * переменные, 
  * элементы контейнеров, 
  * срезы, 
  * атрибуты объектов 
  * и ключи словарей.
* После удаления переменной сам объект может быть удалён из памяти, 
  * если на него больше нет других ссылок (срабатывает сборщик мусора).

## Синтаксис:

```python
del obj
```

или

```python
del obj[index]         # удалить элемент по индексу
del obj[start:end]     # удалить срез
del obj.attr           # удалить атрибут объекта
```

---

## Примеры

```python
numbers = [10, 20, 30, 40, 50]

# Удаление элемента по индексу
del numbers[2]        # удаляем 30
print(numbers)        # [10, 20, 40, 50]

# Удаление среза
del numbers[1:3]      # удаляем элементы 20, 40
print(numbers)        # [10, 50]

# Удаляем все элементы списка (аналог метода .clear()
del numbers[:]        # удаляем элементы 10, 50
print(numbers)        # []

# Удаление всей переменной
del numbers
# print(numbers)      # NameError, переменная больше не существует
```

## Выводы

1. `del` может удалять:

   * отдельные элементы списка по индексу,
   * диапазон элементов списка (слайсинг или срезы),
   * все элементы списка,
   * переменные целиком.
…

## Виды копирования двумерных изменяемых объектов

1. **Копирование (`shallow copy`, поверхностное копирование)**

   * Создаёт новый объект **верхнего уровня**, но **вложенные объекты остаются ссылками на исходные**.
   * Любое изменение вложенных объектов отражается в обеих копиях.
   * Используется:

     * 1.1. встроенный метод `.copy()` (для списков, словарей, set)
     * 1.2. слайсинг (срезы) `[:]` (для списков)
     * 1.3. функция `copy.copy()` из модуля `copy`
     * 1.3. функция `list()`

2. **Глубокое копирование (deep copy)**

   * Создаёт **новый объект и рекурсивно копирует все вложенные объекты**.
   * Изменение в одном объекте **не влияет на другой**.
   * Используется:

     * функция `copy.deepcopy()` из модуля `copy`.

---

## Примеры

### 1 Поверхностное копирование (`shallow copy`)

```python
import copy

original = [[1, 2], [3, 4]]

# Способ 1: через срез
shallow1 = original[:]

# Способ 2: .copy()
shallow2 = original.copy()

# Способ 3: через copy.copy()
shallow3 = copy.copy(original)

# Способ 4: через list()
shallow4 = list(original)

# Изменение верхнего уровня
original.append([5,6])
print(shallow1)   # [[1,2], [3,4]] — верхний уровень копии не изменился
print(shallow2)   # [[1,2], [3,4]] — верхний уровень копии не изменился
print(shallow3)   # [[1,2], [3,4]] — верхний уровень копии не изменился
print(shallow3)   # [[1,2], [3,4]] — верхний уровень копии не изменился

# Изменение вложенного объекта
original[0][0] = 0
print(shallow1)   # [[0, 2], [3, 4]] — вложенный объект копии изменился
print(shallow2)   # [[0, 2], [3, 4]] — вложенный объект копии изменился
print(shallow3)   # [[0, 2], [3, 4]] — вложенный объект копии изменился
print(shallow4)   # [[0, 2], [3, 4]] — вложенный объект копии изменился
```

---
…

## Что именно удаляет объект?

## 1. Что такое переменная в Python?

Переменная `x` — это **имя (ссылка)**, которое хранится в *пространстве имён* (namespace).  
Она указывает на объект (в памяти).

```python
x = [1, 2, 3]   # x → ссылка на объект "список"
y = 10          # y → ссылка на объект "число 10"
```

---

## 2. Что именно хранится в переменной для разных типов данных?

* **Изменяемые типы (mutable)** хранит **ссылку на объект в памяти**.
  Объект можно менять через эту ссылку:

  ```python
  x = [1, 2, 3]
  x.append(4)   # меняется объект, а не ссылка
  ```

* **Неизменяемые типы (immutable)** — ТОЖЕ хранит ссылку, но сам объект изменить нельзя.  
* При "изменении" создаётся **новый объект**, а переменная начинает ссылаться на него:

  ```python
  x = "hello"
  x = x + "!"
  # Теперь x указывает на новый объект "hello!"
  ```

⚠️ МЕГА Важно: для Python **разницы нет** — всегда хранится **ссылка**.    
Различие только в том, можно ли менять объект по этой ссылке.

---

## 3. Где хранятся переменные?

* В Python переменные (`x`, `y`, `my_list`) живут в **пространстве имён** (namespace).

  * Внутри функции — в **локальном пространстве имён** (словарь `locals()`).
  * В модуле — в **глобальном пространстве имён** (словарь `globals()`).
* Сами **объекты** (списки, строки, числа) хранятся в **куче (heap)**.

То есть схема такая:

```
namespace (словарь)
 ├── "x" ──► [1, 2, 3]
 └── "y" ──► 10
```

---

## 4. Что делает `del x`?

* Удаляет имя `x` из пространства имён.
* Сам объект **не удаляется сразу**, если на него ещё есть другие ссылки.
…