Python для начинающих

Введение в matplotlib: базовые графики и стильные фишки Matplotlib — это как карандаш для программиста: без него работать можно, но рисовать данные неудобно. Библиотека умеет строить почти любые графики, а начинать лучше с простого: линейных, точечных и столбчатых диаграмм. --- ### Первый график за 5 строк Установите библиотеку (если нужно):

pip install matplotlib

Базовый пример:

import matplotlib.pyplot as plt

x = [1, 2, 3, 4]
y = [2, 3, 5, 7]

plt.plot(x, y)
plt.title("Simple line plot")
plt.xlabel("X axis")
plt.ylabel("Y axis")
plt.show()

plot — линия, title — заголовок, xlabel/ylabel — подписи осей, show — вывод окна с графиком. --- ### Цвета, маркеры и стили линий Matplotlib позволяет легко “приодеть” график:

import matplotlib.pyplot as plt

x = [1, 2, 3, 4]
y1 = [1, 4, 9, 16]
y2 = [2, 3, 2, 3]

plt.plot(x, y1, color="red", linestyle="--", marker="o", label="squares")
plt.plot(x, y2, color="#008080", linestyle="-.", marker="s", label="wavy")

plt.title("Styled lines")
plt.xlabel("X")
plt.ylabel("Y")
plt.legend()
plt.grid(True)
plt.show()

Что полезно запомнить: - color: "red", "green", "black" или HEX "#008080". - linestyle: "-", "--", "-.", ":". - marker: "o", "s", "x", "^" и др. - legend() — показывает легенду по label. --- ### Точечные и столбчатые графики Для разброса точек используйте scatter:

import matplotlib.pyplot as plt

x = [1, 2, 3, 4, 5]
y = [5, 3, 4, 2, 1]

plt.scatter(x, y, color="purple", s=80, alpha=0.7)
plt.title("Scatter plot")
plt.xlabel("X")
plt.ylabel("Y")
plt.grid(True)
plt.show()

Параметры: s — размер точек, alpha — прозрачность. Столбчатая диаграмма:

import matplotlib.pyplot as plt

labels = ["Mon", "Tue", "Wed", "Thu", "Fri"]
values = [10, 12, 9, 15, 11]

plt.bar(labels, values, color="orange")
plt.title("Weekly stats")
plt.ylabel("Value")
plt.show()

--- ### Быстрая смена стиля оформления Matplotlib поддерживает готовые стили:

import matplotlib.pyplot as plt

plt.style.use("ggplot")  # попробуйте также "seaborn-v0_8", "dark_background"

x = [1, 2, 3, 4]
y = [3, 8, 1, 10]

plt.plot(x, y, marker="o")
plt.title("Styled with ggplot")
plt.show()

Один вызов plt.style.use — и у вас другой фон, сетка и палитра. --- Matplotlib хорош тем, что простой код уже даёт читабельные графики, а добавляя по одному параметру — цвет, легенду, стиль — вы постепенно превращаете “сырой” график в понятную визуализацию.

- Введение в matplotlib: базовые графики и настройка их стилей.

Как настроить GitHub Actions для Python-проекта: CI за 10 минут Ты пишешь код, пушишь его в репозиторий… и только потом вспоминаешь, что не запустил тесты. Классика. GitHub Actions решает эту проблему: он запускает проверки автоматически при каждом коммите или pull request. Разберём минимальный, но полезный воркфлоу для Python. --- ### Шаг 1. Структура проекта Допустим, у тебя такой проект:

.
├─ src/
│  └─ main.py
├─ tests/
│  └─ test_main.py
├─ requirements.txt
└─ pyproject.toml (или setup.cfg / setup.py — не критично)

tests/ — место для тестов, requirements.txt — зависимости. --- ### Шаг 2. Пишем простой код и тест src/main.py:

def add(a: int, b: int) -> int:
    return a + b

tests/test_main.py:

from src.main import add


def test_add_positive():
    assert add(2, 3) == 5


def test_add_negative():
    assert add(-1, -3) == -4

Добавь pytest в requirements.txt:

pytest==8.3.0

--- ### Шаг 3. Создаём воркфлоу GitHub Actions В репозитории создай папку .github/workflows/ и файл, например python-ci.yml.

name: Python CI

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  tests:
    runs-on: ubuntu-latest

    strategy:
      matrix:
        python-version: ["3.10", "3.11"]

    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: ${{ matrix.python-version }}

      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install -r requirements.txt

      - name: Run tests
        run: pytest -q

Что тут происходит: - on — когда запускать воркфлоу: при push и pull_request в main. - matrix — прогоняем тесты на нескольких версиях Python. - actions/checkout — забирает код из репозитория. - actions/setup-python — ставит нужную версию Python. - Install dependencies — ставим зависимости. - Run tests — запускаем pytest. --- ### Шаг 4. Бонус: проверка стиля Добавим линтер flake8: requirements.txt:

pytest==8.3.0
flake8==7.1.0

И ещё один шаг в воркфлоу:

      - name: Lint with flake8
        run: |
          flake8 src tests

Теперь каждый коммит проходит: 1. Установку зависимостей 2. Линтер 3. Тесты на нескольких версиях Python Если что-то падает — GitHub подсветит это прямо в Pull Request. --- GitHub Actions превращает твой репозиторий в маленький конвейер качества: ты пишешь код — он сам проверяет, что ты ничего не сломал. Настроить один раз — экономить часы и нервы постоянно.

- Как настроить воркфлоу автоматизации на GitHub Actions для Python-проекта.

Создание базового TCP‑сервера с использованием сокетов Python Иногда хочется почувствовать себя чуть ближе к «низам» интернета — туда, где нет Flask и Django, а есть только чистые сокеты и байты. Давайте напишем свой минимальный TCP‑сервер и разберёмся, что вообще происходит «под капотом». ### Что такое сокет? Сокет — это конечная точка сетевого соединения. У простого TCP-сервера есть три основных шага: 1. Создать сокет. 2. Привязать его к адресу и порту. 3. Слушать входящие подключения и обрабатывать клиентов. Используем стандартный модуль socket. ### Самый простой TCP‑сервер Напишем сервер, который принимает соединение и отсылает клиенту приветствие:

import socket

HOST = "127.0.0.1"   # localhost
PORT = 5000          # любой свободный порт > 1024

server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind((HOST, PORT))
server_socket.listen(1)  # максимальная очередь из 1 клиента

print(f"Server is listening on {HOST}:{PORT}...")

conn, addr = server_socket.accept()
print(f"Connected by {addr}")

message = "Hello from TCP server!\n"
conn.sendall(message.encode("utf-8"))

conn.close()
server_socket.close()

Кратко по шагам: - socket.AF_INET — IPv4; - socket.SOCK_STREAM — протокол TCP; - bind — говорим ОС: «Этот сервер живёт на HOST:PORT»; - listen — включаем режим ожидания подключений; - accept — блокируется, пока клиент не подключится, и возвращает новый сокет conn только для этого клиента. Проверить можно через telnet 127.0.0.1 5000 или написать маленького клиента. ### Эхо‑сервер: отвечаем на сообщения Сделаем сервер, который читает данные от клиента и отправляет их обратно:

import socket

HOST = "127.0.0.1"
PORT = 5001

server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind((HOST, PORT))
server_socket.listen(5)
print(f"Echo server on {HOST}:{PORT}")

while True:
    conn, addr = server_socket.accept()
    print(f"Client connected: {addr}")
    with conn:
        while True:
            data = conn.recv(1024)  # читаем до 1024 байт
            if not data:
                break  # клиент закрыл соединение
            print(f"Received: {data!r}")
            conn.sendall(data)  # отправляем назад

Здесь важно: - recv возвращает bytes; пустые b"" означают разрыв соединения; - sendall гарантирует отправку всего буфера; - цикл while True позволяет обслуживать клиентов один за другим. ### О чём стоит помнить - Порт должен быть свободен, иначе будет ошибка OSError: [Errno 98] Address already in use. - При разработке удобно использовать 127.0.0.1, для внешнего доступа — "0.0.0.0". - Такой сервер однопоточен: пока он общается с одним клиентом, другие ждут. Для реальных задач нужны потоки (threading) или asyncio. Через такие простые примеры становится понятнее, что веб‑фреймворки всего лишь надстройка над таким же socket, который вы сейчас написали сами.

- Создание базового TCP-сервера с использованием сокетов Python.

Python для начинающих: как приручить __init__.py и навести порядок в проекте Когда скрипт разрастается до 500+ строк, появляется соблазн «просто дописать еще чуть-чуть». А потом — боль: сложно найти нужную функцию, тестировать, переиспользовать код. Время знакомиться с модульной структурой и файлом __init__.py. --- ### Что такое пакет и зачем нужен __init__.py Пакет — это просто папка с Python-кодом, которую интерпретатор воспринимает как модуль. Классический пакет содержит:

my_app/
    __init__.py
    models.py
    services.py
    utils/
        __init__.py
        validators.py
        formatters.py

Наличие __init__.py говорит Python: «это пакет, его можно импортировать». --- ### Простейший пример: группируем логику Пусть у нас мини-приложение для работы с пользователями. my_app/models.py:

class User:
    def __init__(self, username: str):
        self.username = username

my_app/services.py:

from .models import User

def create_user(username: str) -> User:
    return User(username=username)

Теперь сделаем пакет удобным с помощью __init__.py. my_app/__init__.py:

from .models import User
from .services import create_user

__all__ = ["User", "create_user"]

Теперь в основном скрипте:

from my_app import User, create_user

user = create_user("alice")
print(user.username)

Мы спрятали внутреннюю структуру (файлы models.py, services.py), оставив аккуратный публичный интерфейс. --- ### Вложенные пакеты и точечный импорт Добавим утилиты: my_app/utils/validators.py:

def is_valid_username(username: str) -> bool:
    return len(username) >= 3

my_app/utils/__init__.py:

from .validators import is_valid_username

__all__ = ["is_valid_username"]

И обновим my_app/__init__.py:

from .models import User
from .services import create_user
from .utils import is_valid_username

__all__ = ["User", "create_user", "is_valid_username"]

Теперь в любом месте проекта:

from my_app import is_valid_username

print(is_valid_username("ab"))   # False
print(is_valid_username("alex")) # True

--- ### Зачем вообще заморачиваться с __init__.py 1. Чистый публичный API Через __all__ вы явно решаете, что можно импортировать снаружи, а что считается «внутренней кухней». 2. Сокрытие структуры Можно переименовать файл services.py в logic.py, не ломая внешний код — если __init__.py сохраняет те же имена. 3. Удобные групповые импорты Вместо:

   from my_app.models import User
   from my_app.services import create_user
   

достаточно:

   from my_app import User, create_user
   

4. Инициализация пакета В __init__.py можно разместить код, который выполнится при первом импорте пакета: настройка логгера, загрузка конфигурации (без фанатизма). --- ### Маленькое правило напоследок Если модулей становится слишком много, и __init__.py превращается в свалку импортов — это сигнал, что пакет пора логически разбивать дальше. Хорошая структура проекта — та, где содержимое видно «с первого взгляда», а __init__.py помогает, а не запутывает.

- Как организовать модульную структуру проекта Python с помощью init.py.

- Как организовать модульную структуру проекта Python с помощью init.py.

Работа с аудиофайлами: основное введение в модуль wave Представьте, что вы хотите прочитать или обработать аудиофайл формата WAV в Python. Где-то на жестком диске томно покоится классическая мелодия “Moonlight.wav”, и вашей задачей становится: узнать её параметры или скопировать пару секунд звука в новый файл. Как это сделать? Представляю простое, но очень полезное оружие из стандартной библиотеки — модуль wave. ### В чём суть формата WAV? WAV — это контейнер для хранения необработанных (raw) аудиоданных, обычно с минимальным сжатием. Как правило, это PCM-звук: каждая секунда — это тысячи отсчётов-чисел, определяющих амплитуду сигнала. ### Простое чтение WAV-файла Модуль wave позволяет безопасно заглянуть внутрь файла и считать метаданные: количество каналов, частоту дискретизации и длину.

import wave

with wave.open('Moonlight.wav', 'rb') as audio:
    n_channels = audio.getnchannels()
    sample_width = audio.getsampwidth()
    frame_rate = audio.getframerate()
    n_frames = audio.getnframes()
    duration = n_frames / frame_rate

    print(f'Channels: {n_channels}')
    print(f'Sample width: {sample_width} bytes')
    print(f'Frame rate: {frame_rate} Hz')
    print(f'Duration: {duration:.2f} seconds')

Всё, что между with ... as audio:, работает с открытым файлом: считаем параметры и даже узнаём длительность! ### Извлечение и сохранение кусочка аудио Допустим, нужно вырезать первые 5 секунд аудио и записать их в новый WAV файл.

import wave

with wave.open('Moonlight.wav', 'rb') as original:
    frame_rate = original.getframerate()
    n_frames_to_copy = frame_rate * 5
    frames = original.readframes(n_frames_to_copy)

    with wave.open('Snippet.wav', 'wb') as snippet:
        snippet.setnchannels(original.getnchannels())
        snippet.setsampwidth(original.getsampwidth())
        snippet.setframerate(frame_rate)
        snippet.writeframes(frames)

Модуль wave работает только с несжатым PCM-звуком, но зато позволяет управлять WAV-файлами без лишних зависимостей. ### Секреты и ограничения модуля wave wave — это абсолютный минималист. Он не умеет работать с mp3/flac и не воспроизводит звук. Но если хочется быстро проанализировать структуру WAV или сделать простейшее редактирование, — это именно ваш инструмент. Используйте wave, если вам нужно: узнать, как устроена “под капотом” музыка, или написать свою первую аудиопрограмму на Python!

Работа с аудиофайлами: основное введение в модуль wave

Работа с аудиофайлами: основное введение в модуль wave

# Использование PEP8: как писать более чистый код Привет, меня зовут Иван, и сегодня мы поговорим о PEP8 — вашем надежном компасе в мире чистого Python-кода. Возможно, вы уже слышали: “Пишите читаемый код!”, “Соблюдайте стиль!”. Но что за стиль, и зачем он вообще нужен? Давайте разберёмся. ## Что такое PEP8? PEP8 — это стиль кодирования, одобренный Python-сообществом. Его цель — сделать код понятным не только вам, но и вашим коллегам. Представьте код с разным отступом, непонятными именами, хаотичными пробелами — это как лабиринт. PEP8 превращает этот лабиринт в аккуратную дорогу. ## Главные правила PEP8 ### Отступы Используйте 4 пробела на каждый уровень вложенности. Табуляции? Забываем! Python обожает пробелы:

def greet(name):
    print(f"Hello, {name}!")

### Имена переменных и функций Функции и переменные — маленькие змейки: snake_case. Классы — CamelCase:

def calculate_area(radius):
    return 3.14 * radius ** 2

class CircleAreaCalculator:
    pass

### Пробелы Пробел — не просто украшение. Он помогает глазам быстро читать код, но перебарщивать не стоит:

x = 1  # правильно
y=2    # неправильно!
z = y+1  # тоже нехорошо

### Длина строки PEP8 рекомендует не превышать 79 символов в строке. Во-первых, код помещается на экран. Во-вторых, не приходится горизонтально скроллить:

result = magic_function(param1, param2, param3, param4, param5, param6)

Если длинно — переносим:

result = magic_function(
    param1, param2, param3, param4,
    param5, param6
)

### Импортируем красиво Импорты — с новых строк. Сначала стандартные модули, потом сторонние, потом ваши собственные:

import os
import sys

import requests

from mymodule import my_function

## Проверяем себя Хватит ли помнить все правила наизусть? Нет. Используйте автоматические инструменты: - flake8 — проверяет стиль кода - black — автоматически форматирует код ## Заключение PEP8 — не занудное ограничение, а инструмент вашего профессионализма. Чистый код экономит время, спасает нервы и даже делает друзей! Не стесняйтесь открывать PEP8 чаще обычного — и ваш Python будет не только работать, но и радовать глаз.

- Использование PEP8: как писать более чистый код.

Введение во фреймворк Streamlit: создание интерактивных веб-приложений Привет! С вами Иван, и сегодня я расскажу о Streamlit — фреймворке, который способен превратить ваш скрипт на Python в работающую веб-страницу буквально за пару минут. Если вы часто работаете с анализом данных или машинным обучением, но идея разбираться с HTML/CSS/JS вас пугает, Streamlit — это глоток свежего воздуха. Что такое Streamlit? Это библиотека, позволяющая создавать веб-приложения на Python без глубокой веб-разработки. Всё, что нужно — обычный питоновский скрипт! Streamlit автоматически создает интерфейс, позволяя спокойно тестировать гипотезы и делиться результатами с коллегами. ### Как начать? Установите библиотеку:

pip install streamlit

Создайте файл, например app.py, и добавьте простой код:

import streamlit as st

st.title("Streamlit Demo")
st.write("Hello, world! This is my first Streamlit app.")

Затем запускаем командой:

streamlit run app.py

Откроется браузер — и вы уже видите свой первый веб-апп! ### Немного интерактива Допустим, хочется интерактивных элементов. Добавим слайдер, чтобы управлять числом, и кнопку для действия:

import streamlit as st

st.header("Simple Calculator")
num = st.slider("Choose a number", 1, 100, 25)
st.write(f"Square of your number: {num ** 2}")

if st.button("Show Magic!"):
    st.balloons()

Каждое изменение значения слайдера сразу вызывает перерасчет — никакого обновления страницы! А если нажать кнопку, экран украсится анимацией шариков. ### Загрузка и визуализация данных Streamlit отлично дружит с Pandas и Matplotlib. Вот пример, как загрузить CSV-файл и построить график:

import streamlit as st
import pandas as pd
import matplotlib.pyplot as plt

uploaded_file = st.file_uploader("Upload CSV", type="csv")
if uploaded_file:
    df = pd.read_csv(uploaded_file)
    st.write(df.head())

    fig, ax = plt.subplots()
    df.hist(ax=ax)
    st.pyplot(fig)

Пользователь загружает файл, таблица и гистограмма появляются тут же — попробуйте сами! --- Streamlit — это быстрый старт, минимум кода и максимум наглядности. Отличный инструмент, чтобы показывать результаты работы или делать прототипы. Не тратьте время на фронтенд там, где важнее суть данных!

- Введение во фреймворк Streamlit: создание интерактивных веб-приложений.

# Создаем ToDo-лист на Python с хранением задач в JSON Привет, на связи Иван — сегодня мы напишем небольшую, но полезную систему управления задачами, используя Python и формат хранения данных JSON. Не секрет, что ToDo-листы неизменно помогают держать свои дела под контролем, а JSON — отличный выбор для простой и эффективной работы с данными. ## Почему JSON? JSON (JavaScript Object Notation) — универсальный текстовый формат, который легко читается как человеком, так и машиной. В Python работа с JSON реализована модулем json из стандартной библиотеки. Все гениальное — просто! ## Минимальный проект ToDo manager Сделаем простое CLI-приложение: можно добавить, отметить выполненной или удалить задачу. Начнем с хранилища — файл todo.json. 1. Считываем задачи:

import json
import os

def load_tasks(filename):
    if not os.path.exists(filename):
        return []
    with open(filename, 'r') as f:
        return json.load(f)

2. Сохраняем задачи:

def save_tasks(filename, tasks):
    with open(filename, 'w') as f:
        json.dump(tasks, f, indent=2)

3. Добавляем задачу:

def add_task(tasks, text):
    tasks.append({'task': text, 'done': False})

4. Отмечаем задачу завершенной:

def complete_task(tasks, index):
    if 0 <= index < len(tasks):
        tasks[index]['done'] = True

5. Удаляем задачу:

def delete_task(tasks, index):
    if 0 <= index < len(tasks):
        del tasks[index]

## Пример использования

FILENAME = 'todo.json'
tasks = load_tasks(FILENAME)

add_task(tasks, 'Learn about JSON module')
add_task(tasks, 'Write a ToDo app')
complete_task(tasks, 0)
delete_task(tasks, 1)

save_tasks(FILENAME, tasks)

## А что внутри файла? После выполнения этих команд, в todo.json будет что-то вроде:

[
  {
    "task": "Learn about JSON module",
    "done": true
  }
]

## Почему это классно? - Наглядно: структура данных проста. - Легко расширять: можно добавлять даты, приоритеты, теги. - Удобно использовать в локальных проектах. Попробуйте изменить код задачи: реализуйте фильтрацию по невыполненным задачам, добавьте сортировку или поиск. Модуль json открывает простор для экспериментов — и это отличная практика для начинающих питонистов!

- Создание системы управления задачами с помощью ToDo-листов на JSON.

# Минимальные и максимальные кучи в Python: магия модуля heapq Привет, я Иван! Сегодня разберём, как быстро манипулировать минимальными и максимальными кучами на Python с помощью стандартного модуля heapq. Если выражаться проще — этот модуль превращает обычный список в эффективную структуру для извлечения самого маленького (или большого) элемента за минимальное время. ## Как это работает? heapq реализует минимальную кучу (min-heap). Это значит, что первый элемент списка (heap[0]) — всегда наименьший. Максимальная куча (max-heap) не поддерживается "из коробки", но её легко построить самому — об этом расскажу чуть дальше. ### Пример 1: Базовые операции с min-heap

import heapq

numbers = [7, 2, 5, 1, 8, 3]
heapq.heapify(numbers)
print(numbers)           # Видим преобразованный список: [1, 2, 3, 7, 8, 5]

smallest = heapq.heappop(numbers)
print(smallest)          # 1 (минимальный элемент)
print(numbers)           # [2, 5, 3, 7, 8]

- heapify: превращает обычный список в кучу O(n) - heappop: извлекает и удаляет минимальный элемент O(log n) - heappush: добавляет новый элемент и поддерживает кучу O(log n) ### Пример 2: Получаем k минимальных элементов Например, хотим топ-3 наименьших числа:

import heapq

data = [6, 14, 3, 8, 2, 10]
top3 = heapq.nsmallest(3, data)
print(top3)   # [2, 3, 6]

Аналогично можно получить k наибольших элементов — но тут весь фокус в "max-heap". ### Пример 3: Max-heap через отрицание Чтобы использовать кучу как максимальную, инвертируйте значения:

import heapq

data = [4, 7, 1, 8, 5]
max_heap = [-x for x in data]
heapq.heapify(max_heap)
largest = -heapq.heappop(max_heap)
print(largest)  # 8

Таким образом, heapq станет "думать", что -8 минимален; отрицаем обратно при извлечении — и получаем максимум! ## Когда применять кучи? - При поиске k наименьших/наибольших элементов в массиве - Для реализации приоритетных очередей - В задачах типа "онлайн сортировки" (например: постоянно поступают числа, нужен минимум в любой момент) heapq работает быстро и сразу же доступен в стандартной библиотеке Python. Так что, если вы ещё не пробовали кучи на практике — пришло время потренироваться! На этом всё — экспериментируйте!

- Основы работы с модулями heapq для минимальных и максимальных куч.