Работа с emoji и цветными иконками в консоли Python

Консоль не обязана быть скучной. Немного emoji и цвета — и ваш скрипт начинает «разговаривать» с пользователем гораздо живее. Разберём три простых приёма: Unicode-emoji, библиотеку emoji и цветной вывод через colorama.

---

## 1. Emoji по‑простому: через Unicode

Многие emoji — это обычные Unicode-символы. Достаточно вставить их прямо в строку:

print("Task completed ✅")
print("Warning ⚠️")
print("Python is fun 🐍")

Если консоль и шрифт поддерживают Unicode, всё просто заработает.
Иногда полезно использовать кодовую точку:

smile = "\U0001F600"  # 😀
print(f"Hello {smile}")

---

## 2. Библиотека emoji

Когда хочется писать :smile: вместо поиска нужного символа.

Установка:

pip install emoji

Использование:

import emoji

text = emoji.emojize(
    "Server status: :green_circle: Running, :red_circle: Stopped",
    language="alias"
)
print(text)

Полезные фишки:
- emoji.demojize("Hello 😀") → "Hello :grinning_face:"
- Можно хранить «коды» в файлах настроек и подставлять emoji при выводе.

---

## 3. Цветной текст с colorama

colorama кроссплатформенно добавляет цвет в консоль (особенно удобно на Windows).

Установка:

pip install colorama

Минимальный пример:

from colorama import init, Fore, Style

init(autoreset=True)

print(Fore.GREEN + "Success ✅")
print(Fore.YELLOW + "Loading... ⏳")
print(Fore.RED + "Error ❌")
print(Style.DIM + "This is a low-priority message")

Ключевые элементы:
- Fore.RED, Fore.GREEN, Fore.YELLOW и др. — цвет текста.
- Style.BRIGHT, Style.DIM, Style.NORMAL — «стиль» текста.
- autoreset=True избавляет от необходимости вручную сбрасывать цвет.

---

## 4. Комбинируем: мини‑панель статуса

from colorama import init, Fore
import emoji
import time

init(autoreset=True)

def show_status(message, ok=True):
    icon = ":check_mark_button:" if ok else ":cross_mark:"
    icon = emoji.emojize(icon, language="alias")
    color = Fore.GREEN if ok else Fore.RED
    print(color + icon, message)

show_status("Connecting to database...")
time.sleep(1)
show_status("Connected", ok=True)
show_status("Failed to fetch data", ok=False)

Итог: пара библиотек + Unicode — и ваша консоль превращается из серого лога в удобную и наглядную панель. Это особенно выручает в CLI‑утилитах, мини‑играх и учебных проектах, где хочется мгновенно различать успех, ошибку и предупреждения.

Как использовать itertools для нового взгляда на циклы и генераторы

Как использовать itertools: новый взгляд на циклы и генераторы

Если обычные циклы for — это отвертка, то модуль itertools — целый чемодан инструментов. Он позволяет писать короче, читать легче и иногда вообще обходиться без явных циклов.

---

## Бесконечные последовательности без боли

from itertools import count, cycle, repeat

for i in count(10, 2):  # 10, 12, 14, ...
    if i > 20:
        break
    print(i)

count(start, step) создает бесконечный счетчик. Безопасность — на вас: обязательно ставьте break.

colors = ["red", "green", "blue"]
for c, n in zip(cycle(colors), range(5)):
    print(c)

cycle(iterable) зацикливает список. Удобно для повторяющихся паттернов.

for x in repeat("hello", 3):
    print(x)

repeat(obj, times) — ленивый клон объекта.

---

## Перебор сочетаний, перестановок и не только

from itertools import permutations, combinations, product

letters = ["a", "b", "c"]

print(list(permutations(letters, 2)))   # Порядок важен
print(list(combinations(letters, 2)))   # Порядок не важен

Такие функции идеально подходят для перебора вариантов в брутфорс-задачах, тестировании, комбинаторике.

Декартово произведение:

sizes = ["S", "M"]
colors = ["black", "white"]

for combo in product(sizes, colors):
    print(combo)

Это мощнее вложенных циклов и проще читается.

---

## Умная фильтрация и группировка

from itertools import compress

data = [10, 20, 30, 40]
selectors = [True, False, True, False]

print(list(compress(data, selectors)))  # [10, 30]

compress фильтрует элементы по маске логических значений.

Группировка подряд идущих одинаковых элементов:

from itertools import groupby

data = "aaabbccccd"

for char, group in groupby(data):
    print(char, len(list(group)))
# a 3, b 2, c 4, d 1

Полезно для простого сжатия или анализа последовательностей.

---

## Комбинирование итераторов как конструктор

from itertools import chain, islice

data1 = [1, 2]
data2 = [3, 4, 5]

merged = chain(data1, data2)          # ленивое "склеивание"
print(list(islice(merged, 0, 4)))     # берём только первые 4

chain объединяет несколько источников, а islice позволяет "отрезать" нужный кусок без создания лишних списков.

---

itertools — про ленивость и композицию. Вместо того чтобы писать сложные циклы, вы собираете поведение из маленьких строительных блоков. Результат — короче код, меньше ошибок и приятное ощущение "Python-стиля".

Работа с collections: полезные структуры данных и где их использовать

Работа с collections: полезные структуры данных и где их использовать

Стандартные списки и словари — отличная вещь, но модуль collections превращает их в инструменты «профессионального уровня». Разберём ключевые структуры, которые реально упрощают код.

---

### Counter: считаем всё подряд

Counter — словарь для подсчёта объектов.

from collections import Counter

text = "banana bandana"
counter = Counter(text)

print(counter)          # сколько раз встречается каждый символ
print(counter.most_common(2))  # два самых частых

Где полезно: подсчёт частоты слов в тексте, статистика действий пользователей, анализ логов.

---

### defaultdict: словарь, который не ругается на новые ключи

Обычный словарь бросит KeyError, если ключа нет. defaultdict автоматически создаёт значение по умолчанию.

from collections import defaultdict

groups = defaultdict(list)

data = [("cat", 1), ("dog", 2), ("cat", 3)]
for animal, value in data:
    groups[animal].append(value)

print(groups)  # {'cat': [1, 3], 'dog': [2]}

Где полезно: группировка данных, инвертирование словарей, построение графов (списки соседей).

---

### namedtuple: читаемые «кортежи с именами»

Обычный кортеж непонятен: user[0], user[1]… namedtuple даёт имена полям.

from collections import namedtuple

User = namedtuple("User", ["name", "age"])
user = User(name="Alice", age=30)

print(user.name)
print(user.age)

Где полезно: лёгкие «объекты без классов» — координаты, настройки, параметры функций. Иммутабельность помогает избежать случайных изменений.

---

### deque: очередь и стек без тормозов

Список плохо работает с pop(0) — это O(n). deque оптимизирован для добавления/удаления с обоих концов.

from collections import deque

queue = deque()

queue.append("task1")
queue.append("task2")
queue.appendleft("urgent")

print(queue.popleft())  # 'urgent'
print(queue.pop())      # 'task2'

Где полезно: очереди задач, реализовать стек/очередь, «скользящее окно» последних N элементов.

---

### OrderedDict: порядок тоже важен

С Python 3.7 обычный dict уже запоминает порядок вставки, но OrderedDict всё ещё полезен там, где нужны дополнительные операции (например, move_to_end). В современных проектах используют реже, но стоит знать о его существовании.

---

Модуль collections — это набор готовых решений для типичных задач работы с данными. Зная эти структуры, вы часто пишете меньше кода, делаете его быстрее и понятнее — и меньше изобретаете велосипеды.

Создание генераторов: экономим память при обработке больших данных

Создание генераторов: экономим память при обработке больших данных

Представьте, что вам нужно обработать файл на 10 ГБ, посчитать суммы, отфильтровать строки, что‑то преобразовать. Если пытаться «затащить» всё в память списками — привет, MemoryError. Здесь на сцену выходят генераторы.

Генератор — это «ленивый» источник данных: он отдаёт элементы по одному, по запросу, не храня весь результат сразу. Именно поэтому генераторы так хорошо подходят для больших данных и потоковой обработки.

### Генераторные выражения

Список:

nums = [i * 2 for i in range(10_000_000)]

держит в памяти все 10 млн элементов.

Генератор:

nums_gen = (i * 2 for i in range(10_000_000))

хранит только текущее состояние итерации. Память почти не растёт, пока вы не начинаете обходить nums_gen:

total = 0
for value in nums_gen:
    total += value

### Собственные генераторные функции

Ключевое слово yield превращает функцию в генератор:

def read_large_file(path):
    with open(path, 'r', encoding='utf-8') as f:
        for line in f:
            yield line.strip()

Здесь не создаётся список строк файла — каждая строка обрабатывается по мере чтения:

def iter_error_lines(path):
    for line in read_large_file(path):
        if 'ERROR' in line:
            yield line

for err_line in iter_error_lines('app.log'):
    print(err_line)

Файл может быть гигантским — программа использует почти столько же памяти, как и при чтении маленького файла.

### Конвейер из генераторов

Самое интересное начинается, когда вы соединяете генераторы в цепочку — получается «конвейер»:

def iter_numbers(path):
    for line in read_large_file(path):
        if line and line[0].isdigit():
            yield int(line)

def filter_even(seq):
    for n in seq:
        if n % 2 == 0:
            yield n

def sum_limited(seq, limit):
    total = 0
    for n in seq:
        total += n
        if total > limit:
            break
    return total

numbers = iter_numbers('numbers.txt')
even_numbers = filter_even(numbers)
result = sum_limited(even_numbers, limit=1_000_000)
print(result)

Каждый шаг обрабатывает элементы по одному: прочитали строку → превратили в число → отфильтровали → учли в сумме. Никаких огромных временных списков.

### Когда использовать генераторы

- Обработка больших файлов и потоков данных.
- Длинные вычисления, результат которых нужен по частям.
- Организация удобных «ленивых» API (итераторы вместо списков).

Генераторы — это простой способ сделать код и аккуратнее, и экономичнее по памяти, не усложняя архитектуру. Если вы уже пишете списковые включения, вы почти готовы использовать генераторы — достаточно заменить [] на ().

Как применять enum для улучшения читаемости кода

Python для начинающих: как enum делает код понятнее

Когда в коде появляются «магические числа» и странные строки, читаемость падает. Встречали что‑то вроде:

if status == 3:
    send_email()

Через неделю уже непонятно, что такое 3. Ошибка не в логике — ошибка в обозначениях. Здесь на сцену выходит модуль enum.

---

## Что такое Enum?

Enum (перечисление) — это способ задать набор именованных констант. Вместо чисел и строк, разбросанных по коду, вы используете говорящие имена.

from enum import Enum

class OrderStatus(Enum):
    NEW = 1
    PAID = 2
    SHIPPED = 3
    CANCELED = 4

Теперь вместо 3 у вас есть OrderStatus.SHIPPED. Код сразу объясняет сам себя.

---

## Пример: читаемый if

До:

def handle_order(status):
    if status == 1:
        print("Create invoice")
    elif status == 2:
        print("Prepare shipment")
    elif status == 3:
        print("Send tracking code")

После:

from enum import Enum

class OrderStatus(Enum):
    NEW = 1
    PAID = 2
    SHIPPED = 3

def handle_order(status: OrderStatus):
    if status is OrderStatus.NEW:
        print("Create invoice")
    elif status is OrderStatus.PAID:
        print("Prepare shipment")
    elif status is OrderStatus.SHIPPED:
        print("Send tracking code")

Что улучшилось:

- код сам документирует возможные статусы;
- меньше шансов перепутать значения;
- IDE подсказывает варианты (OrderStatus. → список).

---

## Enum вместо строк

Частая ловушка — сравнение со строками:

if role == "admin":
    ...

Опечатка — и проверка ломается. С Enum:

from enum import Enum, auto

class UserRole(Enum):
    ADMIN = auto()
    EDITOR = auto()
    VIEWER = auto()

def can_delete(user_role: UserRole) -> bool:
    return user_role is UserRole.ADMIN

auto() сам проставит уникальные значения — нас интересуют не числа, а имена.

---

## Небольшой бонус: словари с Enum

Enum удобно использовать как ключи:

from enum import Enum, auto

class LogLevel(Enum):
    DEBUG = auto()
    INFO = auto()
    ERROR = auto()

LOG_PREFIXES = {
    LogLevel.DEBUG: "[DEBUG]",
    LogLevel.INFO: "[INFO]",
    LogLevel.ERROR: "[ERROR]",
}

def log(level: LogLevel, message: str) -> None:
    prefix = LOG_PREFIXES[level]
    print(prefix, message)

Здесь невозможно случайно обратиться к "DBG" вместо "DEBUG" — только валидные значения перечисления.

---

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

Подключение и использование конфигурационных файлов с configparser

Python для начинающих: configparser — приручаем конфиги как профи

Жёстко прописывать настройки прямо в коде — плохая идея. Захочется сменить пароль к базе или лог‑уровень — и вы уже лазите по файлам Python, рискуя всё сломать. Гораздо удобнее хранить настройки в конфигурационных файлах. Для этого в стандартной библиотеке есть модуль configparser.

---

### Как выглядит конфиг

Создадим файл settings.ini:

[database]
host = localhost
port = 5432
user = admin
password = secret

[logging]
level = DEBUG
file = app.log

Структура проста: секции в квадратных скобках и пары ключ = значение.

---

### Чтение конфигурации

from configparser import ConfigParser

config = ConfigParser()
config.read("settings.ini")

db_host = config["database"]["host"]
db_port = config.getint("database", "port")
log_level = config.get("logging", "level", fallback="INFO")

print(db_host, db_port, log_level)

Ключевые моменты:

- config["section"]["option"] — базовый доступ.
- getint, getfloat, getboolean — сразу приводят к нужному типу.
- fallback спасает, если ключа нет.

---

### Изменение и сохранение конфига

from configparser import ConfigParser

config = ConfigParser()
config.read("settings.ini")

config["database"]["host"] = "db.mycompany.com"

if "feature_flags" not in config:
    config["feature_flags"] = {}
config["feature_flags"]["new_ui"] = "true"

with open("settings.ini", "w") as configfile:
    config.write(configfile)

Так можно не только читать, но и аккуратно обновлять настройки.

---

### Конфиг по умолчанию

Иногда нужно задать значения «на всякий случай»:

from configparser import ConfigParser

config = ConfigParser(
    defaults={
        "level": "INFO",
        "file": "app.log"
    }
)

config.read("settings.ini")

log_level = config["logging"]["level"]     # если нет в секции, возьмёт из defaults
log_file = config["logging"]["file"]

---

### Когда это полезно

- разные настройки для dev / prod без изменения кода;
- хранение секретов вне репозитория (через отдельный local_settings.ini);
- быстрое переключение фич через флаги.

configparser — простой, но мощный способ отделить код от настроек. Один раз настроили структуру .ini — и дальше ваш код становится гораздо чище и гибче.

Использование pathlib для работы с путями и файлами

Python для начинающих: как pathlib спасет вас от хаоса с путями

Если вы хоть раз писали что-то вроде:

file_path = "C:\\Users\\user\\projects\\data\\file.txt"

и ловили ошибки из‑за слэшей и кодировок, то модуль pathlib — ваш новый лучший друг. Он превращает работу с путями и файлами в аккуратные объектные операции, вместо бесконечной возни со строками.

---

### Базовая идея: Path вместо строк

Главный герой — класс Path:

from pathlib import Path

base_dir = Path.home() / "projects" / "demo"
print(base_dir)

Оператор / здесь не делит, а красиво склеивает части пути, независимо от ОС (Windows, Linux, macOS). Никаких os.path.join, никаких ручных слэшей.

---

### Проверка существования и типа

pathlib сразу умеет отвечать на важные вопросы:

from pathlib import Path

path = Path("data/example.txt")

print(path.exists())     # файл или папка есть?
print(path.is_file())    # это файл?
print(path.is_dir())     # это папка?

Можно безопасно проверять перед чтением или удалением.

---

### Чтение и запись файлов

Чтение и запись — это методы объекта пути:

from pathlib import Path

file_path = Path("data/notes.txt")

# запись текста
file_path.write_text("Hello, pathlib!", encoding="utf-8")

# чтение текста
content = file_path.read_text(encoding="utf-8")
print(content)

Не нужно вручную открывать и закрывать файлы — Path делает это за вас.

---

### Создание папок и обход директорий

Создать дерево каталогов и пройтись по файлам — одна строка:

from pathlib import Path

base = Path("logs/app")

# создаем все недостающие каталоги
base.mkdir(parents=True, exist_ok=True)

# ищем все .log файлы в подпапках
for log_file in base.rglob("*.log"):
    print(log_file.name, log_file.stat().st_size, "bytes")

Метод rglob рекурсивно ищет файлы по шаблону, stat() дает информацию о файле.

---

### Работа с именами, расширениями и родителями

Разбирать путь по частям стало легко:

from pathlib import Path

path = Path("data/archive/report_2024.csv")

print(path.name)        # report_2024.csv
print(path.stem)        # report_2024
print(path.suffix)      # .csv
print(path.parent)      # data/archive

new_path = path.with_suffix(".xlsx")
print(new_path)         # data/archive/report_2024.xlsx

---

### Почему стоит перейти на pathlib уже сейчас

- Кроссплатформенно: один и тот же код под Windows и Linux.
- Читаемо: Path‑объекты ведут себя как реальные объекты, а не как странные строки.
- Богатый функционал: от обхода директорий до смены расширений.

Если вы еще работаете с путями как со строками — попробуйте переписать небольшой скрипт на pathlib. Скорее всего, назад уже не захочется.

Создание простых HTTP-запросов вручную с модулем http.client

Создание простых HTTP-запросов вручную с модулем http.client

Большинство новичков начинают работу с сетью через библиотеку requests. Она удобная и «магическая». Но если хочется понять, что реально происходит под капотом, полезно познакомиться с модулем стандартной библиотеки http.client.

http.client работает на более низком уровне: вы сами открываете соединение, отправляете строку запроса, заголовки, читаете ответ. Немного «олдскул», зато отлично прокачивает понимание HTTP.

---

### Простой GET-запрос

Сделаем обычный GET-запрос к публичному API:

import http.client
import json

conn = http.client.HTTPSConnection("api.github.com")

headers = {
    "User-Agent": "python-http.client-demo",
    "Accept": "application/vnd.github.v3+json"
}

conn.request("GET", "/repos/python/cpython", headers=headers)
response = conn.getresponse()

print("Status:", response.status, response.reason)

data = response.read()
payload = json.loads(data)

print("Full name:", payload["full_name"])
print("Stars:", payload["stargazers_count"])

conn.close()

Что здесь важно:

- HTTPSConnection — шифрованное соединение (TLS).
- request(method, url, body=None, headers={}) — отправка запроса.
- getresponse() — возвращает объект ответа.
- status, reason, read() — статус-код, текстовое описание и тело ответа.

Без обязательного заголовка User-Agent GitHub может ответить ошибкой — это хороший пример, почему заголовки критичны.

---

### Отправка POST-запроса с данными

Теперь отправим POST с JSON-данными на тестовый сервис httpbin.org:

import http.client
import json

conn = http.client.HTTPSConnection("httpbin.org")

payload = {"name": "Alice", "lang": "Python"}
body = json.dumps(payload)

headers = {
    "Content-Type": "application/json",
    "Content-Length": str(len(body))
}

conn.request("POST", "/post", body=body, headers=headers)
response = conn.getresponse()

print("Status:", response.status)
response_data = response.read().decode("utf-8")

print("Response body:", response_data[:200], "...")
conn.close()

Здесь уже видно «ручную работу»:

- Сериализуем данные сами (json.dumps).
- Указываем Content-Type и Content-Length вручную.
- Сами кодируем/декодируем текст (decode("utf-8")).

---

### Зачем это нужно?

- Понимание того, как устроен HTTP «на проводе».
- Возможность тонко контролировать заголовки и поведение соединения.
- Умение работать только со стандартной библиотекой, без внешних зависимостей.

После таких упражнений любые высокоуровневые библиотеки кажутся гораздо понятнее: вы уже знаете, какую именно «рутину» они берут на себя.

Понимание работы контекстных менеджеров и создание своих с помощью contextlib

Понимание работы контекстных менеджеров и создание своих с помощью contextlib

Если вы когда‑нибудь писали:

with open("data.txt") as f:
    content = f.read()

то уже пользовались контекстным менеджером — просто, возможно, не задумывались об этом. Давайте разберёмся, что там происходит под капотом и как писать свои.

---

### Что такое контекстный менеджер?

Контекстный менеджер — это объект, который знает, что делать до и после блока with.

Под капотом Python делает примерно так:

manager = open("data.txt")
f = manager.__enter__()
try:
    content = f.read()
finally:
    manager.__exit__(None, None, None)

Два ключевых метода:

- __enter__(self) — подготавливает ресурс, возвращает объект, который попадёт в as.
- __exit__(self, exc_type, exc_val, exc_tb) — освобождает ресурс, даже если возникло исключение.

---

### Пишем свой контекстный менеджер “вручную”

Простой пример — измерение времени работы блока кода:

import time

class Timer:
    def __enter__(self):
        self.start = time.perf_counter()
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.end = time.perf_counter()
        self.elapsed = self.end - self.start
        print(f"Elapsed: {self.elapsed:.4f} seconds")

with Timer() as t:
    total = sum(range(1_000_000))

Плюсы: полный контроль, можно хранить состояние в атрибутах объекта. Минус: много шаблонного кода.

---

### contextlib.contextmanager: контекстный менеджер из функции

Модуль contextlib позволяет писать их короче, с помощью генераторов:

from contextlib import contextmanager

@contextmanager
def open_file(path, mode="r"):
    f = open(path, mode)
    try:
        yield f        # то, что вернётся в "as"
    finally:
        f.close()      # выполнится всегда

with open_file("data.txt") as f:
    data = f.read()

Всё, что до yield, — это логика __enter__, а всё после — __exit__.

---

### Практический пример: временная смена текущей директории

import os
from contextlib import contextmanager

@contextmanager
def change_dir(path):
    old_dir = os.getcwd()
    os.chdir(path)
    try:
        yield
    finally:
        os.chdir(old_dir)

print(os.getcwd())
with change_dir("/tmp"):
    print(os.getcwd())
print(os.getcwd())

Контекст гарантирует, что директория вернётся к исходной даже при ошибках внутри блока with.

---

### Когда стоит использовать контекстные менеджеры

- работа с файлами и сетевыми соединениями;
- блокировки потоков и транзакции в БД;
- временные настройки (логирование, окружение, директории);
- любые ресурсы, которые надо обязательно освободить.

Контекстный менеджер — это способ формально описать жизненный цикл ресурса: “взял → поработал → убрал за собой”, и contextlib делает это описание максимально коротким и наглядным.

Мини-проекты с модулем turtle: обучаемся, рисуя

Мини-проекты с модулем turtle: обучаемся, рисуя

Если стандартный «учебник по Python» навевает зевоту, попробуем другой путь: будем учиться, рисуя. Модуль turtle входит в стандартную библиотеку Python, так что ничего дополнительно устанавливать не нужно — только открыть воображение.

---

### 1. Старт: первые линии

Минимальный пример — уже маленький проект:

import turtle

t = turtle.Turtle()
t.speed(3)

t.forward(100)
t.left(90)
t.forward(100)

turtle.done()

Ключевые команды:
- forward(n) — черепашка едет вперед на n пикселей
- left(angle) / right(angle) — поворот
- penup() / pendown() — перо вверх/вниз (рисовать или нет)

Этого уже достаточно, чтобы строить геометрию и тренировать циклы.

---

### 2. Мини-проект: генератор квадратных мандал

Потренируемся в циклах и функциях: нарисуем «мандалу» из квадратов.

import turtle

t = turtle.Turtle()
t.speed(0)
t.color("blue")

def draw_square(side):
    for _ in range(4):
        t.forward(side)
        t.left(90)

for angle in range(0, 360, 10):
    t.setheading(angle)
    draw_square(100)

turtle.done()

Что мы закрепляем:
- функции (def draw_square)
- цикл for с шагом 10
- setheading(angle) — задаём абсолютный угол поворота

Измените шаг 10 на 5 или 20, длину стороны, цвет — наглядное «чувство кода» появляется очень быстро.

---

### 3. Мини-проект: случайный фейерверк

Теперь подключим случайность и познакомимся с модулем random.

import turtle
import random

t = turtle.Turtle()
t.speed(0)
turtle.bgcolor("black")

colors = ["red", "yellow", "orange", "cyan", "magenta", "white"]

def draw_burst(radius):
    t.color(random.choice(colors))
    for _ in range(12):
        t.forward(radius)
        t.backward(radius)
        t.right(360 / 12)

for _ in range(20):
    t.penup()
    x = random.randint(-300, 300)
    y = random.randint(-200, 200)
    t.goto(x, y)
    t.pendown()
    draw_burst(random.randint(30, 80))

turtle.done()

Что осваиваем:
- random.randint и random.choice
- работу с координатами goto(x, y)
- фон окна bgcolor

---

### 4. Зачем это всё?

Такие мини-проекты:
- снимают «страх кода» — результат видно сразу;
- закрепляют основы: циклы, функции, модули, случайные числа;
- развивают интуицию: меняете одну строку — картина меняется заметно.

Попробуйте усложнить проекты: добавить управление с клавиатуры, анимацию движения, счётчик шагов. turtle — отличный полигон, чтобы сделать первые шаги в Python творческими, а не скучными.

Применение Counter и defaultdict в задачах подсчета данных

Применение Counter и defaultdict в задачах подсчета данных

В Python есть два маленьких, но очень мощных инструмента для подсчета данных: Counter и defaultdict из модуля collections. Они экономят десятки строк кода и делают задачи подсчета почти «одноходовками».

---

## Counter: карманный статистик

Counter — это специализированный словарь для подсчета количества объектов. Внутри — обычный dict, но с удобным интерфейсом.

### Подсчет слов в тексте

from collections import Counter

text = "python is great and python is simple"
words = text.split()

word_counts = Counter(words)

print(word_counts)
print(word_counts.most_common(2))  # 2 самых частых слова

Что удобно:
- Counter сам инициализирует счетчики с нуля;
- метод most_common() сразу выдает топ-N элементов;
- можно складывать, вычитать, объединять счетчики как числа.

### Подсчет символов в строке

from collections import Counter

s = "abracadabra"
char_counts = Counter(s)

for char, count in char_counts.items():
    print(char, count)

Ни одного if key not in dict — всё уже встроено.

---

## defaultdict: умный словарь с «значением по умолчанию»

Обычный словарь при обращении к несуществующему ключу вызывает ошибку. defaultdict сам создает значение, используя функцию, которую вы ему передадите.

### Группировка по ключу

Допустим, нужно сгруппировать студентов по курсу:

from collections import defaultdict

students = [
    ("Alice", 1),
    ("Bob", 2),
    ("Charlie", 1),
    ("Diana", 3),
]

by_course = defaultdict(list)

for name, course in students:
    by_course[course].append(name)

print(by_course)

Без defaultdict пришлось бы каждый раз проверять, есть ли уже такой курс в словаре.

### Словарь-счетчик на defaultdict

defaultdict легко превращается в счетчик:

from collections import defaultdict

nums = [1, 2, 1, 3, 2, 1]
counts = defaultdict(int)

for n in nums:
    counts[n] += 1

print(counts)

По сути, это «ручная версия» Counter, но зато более гибкая.

---

## Когда что использовать

- Нужен простой подсчет частот + топы, суммы, комбинации — Counter.
- Нужна сложная структура вроде «ключ → список», «ключ → множество» или нестандартная логика инициализации — defaultdict.

Оба инструмента отлично заходят в задачах обработки логов, текста, статистики, простых аналитических вычислений. Освоив их, вы перестанете писать однообразные шаблоны с проверками «а есть ли уже этот ключ» и сосредоточитесь на самой задаче.