a = 10
print(f'Значение: {a}, Идентификатор памяти (адрес): {id(a)}')
a = 20
print(f'Новое значение: {a}, Новый идентификатор: {id(a)}')
b = 20
print(f'Значение b: {b}, Идентификатор b: {id(b)}')

user_status = 'active'
user_id = 404

# Получаем доступ к глобальному словарю
global_vars = globals()

print('Проверка наличия переменной в словаре:')
print('user_status' in global_vars)
print(f'Значение из словаря: {global_vars["user_status"]}')

# Динамическое (но не рекомендуемое) создание переменной
global_vars['dynamic_var'] = 'Создано через словарь'
print(dynamic_var) # Переменная магическим образом существует!

import sys

# Создаем новый уникальный объект списка
my_list = [7, 8, 9]

# Проверяем количество ссылок.
# Ожидаем 1 (от переменной my_list), но функция вернет 2,
# так как сама функция getrefcount получает ссылку на объект как аргумент.
print(f'Счетчик ссылок на my_list: {sys.getrefcount(my_list)}')

# Создаем вторую ссылку на тот же объект
alias_list = my_list
print(f'Счетчик ссылок после создания alias_list: {sys.getrefcount(my_list)}')

# Удаляем одну ссылку
del alias_list
print(f'Счетчик ссылок после удаления alias: {sys.getrefcount(my_list)}')

a = '5'
b = 10

try:
    # Эта строка вызовет TypeError из-за СТРОГОЙ типизации Python
    result = a + b
except TypeError as e:
    print(f'Предотвращена критическая ошибка: {e}')

# Явное приведение типов в Python:
explicit_concat = a + str(b)  # Результат: '510'
explicit_math = int(a) + b    # Результат: 15
print('Явная конвертация работает надежно.')

class Duck:
    def quack(self):
        print('Кря-кря!')

class Person:
    def quack(self):
        print('Человек имитирует утку: Кря-кря!')

class Cat:
    def meow(self):
        print('Мяу!')

# Функция, использующая утиную типизацию. Ей не важен класс!
def make_it_quack(entity):
    try:
        entity.quack()
    except AttributeError:
        print('ОШИБКА: Этот объект не умеет крякать!')

# Передаем разные объекты в одну функцию
make_it_quack(Duck())   # Работает
make_it_quack(Person()) # Тоже работает! Человек - 'утка' для этой функции.
make_it_quack(Cat())    # Перехватывает ошибку.

tricky_tuple = (1, [2, 3], 'hello')

print(f'Исходный кортеж: {tricky_tuple}')
print(f'ID списка внутри кортежа: {id(tricky_tuple[1])}')

# Мы не можем сделать так: tricky_tuple[1] = [99, 100] (TypeError)
# НО мы можем изменить сам список, на который указывает ссылка!
tricky_tuple[1].append(4)
tricky_tuple[1][0] = 99

print(f'Измененный кортеж: {tricky_tuple}')
print(f'ID списка остался ПРЕЖНИМ: {id(tricky_tuple[1])}')
# Вывод подтвердит, что ссылка не поменялась, значит кортеж не был нарушен.

# ОПАСНЫЙ (АНТИПАТТЕРН) КОД:
def bad_add_student(name, student_list=[]):
    # student_list инициализируется один раз при определении функции!
    student_list.append(name)
    return student_list

print(bad_add_student('Alice')) # Вывод: ['Alice']
print(bad_add_student('Bob'))   # Вывод: ['Alice', 'Bob'] - ОШИБКА БИЗНЕС-ЛОГИКИ!


# ПРАВИЛЬНЫЙ ПОДХОД (РЕШЕНИЕ ПРОБЛЕМЫ):
def good_add_student(name, student_list=None):
    # Значение по умолчанию - неизменяемый объект None.
    # Мы создаем новый пустой список внутри тела функции (при каждом вызове).
    if student_list is None:
        student_list = []
    student_list.append(name)
    return student_list

print(good_add_student('Charlie')) # Вывод: ['Charlie']
print(good_add_student('David'))   # Вывод: ['David'] - РАБОТАЕТ ВЕРНО!

import copy

# Исходный вложенный список (матрица/инвентарь)
original = [1, 2, ['a', 'b']]

# ПОВЕРХНОСТНАЯ КОПИЯ (Shallow Copy)
shallow = original.copy()  # Или list(original), или original[:]

# ГЛУБОКАЯ КОПИЯ (Deep Copy)
deep = copy.deepcopy(original)

# Модифицируем ВНУТРЕННИЙ (изменяемый) список в поверхностной копии
shallow[2].append('c')

print(f'Original: {original}') # Вывод: [1, 2, [\'a\', \'b\', \'c\']] - ОРИГИНАЛ ИСПОРЧЕН!
print(f'Shallow:  {shallow}')  # Вывод: [1, 2, [\'a\', \'b\', \'c\']]

# Внутренний список в глубокой копии остался нетронутым (он независим)
print(f'Deep:     {deep}')     # Вывод: [1, 2, [\'a\', \'b\']]

from typing import List, Dict, Optional

# Функция с современными аннотациями типов (Type Hints)
# Читателю (и редактору кода) сразу понятно, какие данные ожидаются.
def process_users(users: List[Dict[str, str]], limit: Optional[int] = None) -> List[str]:
    '''
    Обрабатывает список пользователей и возвращает список их email-адресов.
    '''
    emails: List[str] = []
    for i, user in enumerate(users):
        if limit is not None and i >= limit:
            break
        # Статический анализатор (mypy) знает, что user - это словарь,
        # и может проверить правильность использования методов словаря.
        if 'email' in user:
            emails.append(user['email'])
    return emails

# Во время выполнения Python проигнорирует неверный тип ниже и выбросит ошибку
# только когда попытается выполнить операцию 'email' in user.
# Но линтер (mypy) укажет на ошибку еще до запуска программы!
# process_users(users=42) # mypy: Argument 1 to "process_users" has incompatible type "int"; expected "List[Dict[str, str]]"