Python : подробный путеводитель с примерами кода 2026 года

Этот материал предназначен для новичков и тех, кто хочет систематизировать знания по языку программирования Python. В статье рассматриваются основные конструкции языка и показаны примеры кода для самых разных задач — от работы со строками до асинхронных запросов и анализа данных. Все примеры снабжены пояснениями, чтобы вы понимали не только как, но и почему.
t.me/ai_machinelearning_big_data – мой телеграм канал, где я объясняю сложные концепции и код с помощью короткий видео и картинок

Переменные и типы данных

Python — язык с динамической типизацией: переменная может хранить данные любого типа, а тип переменной определяется автоматически. Присвоение происходит с помощью оператора =. Например, целые и вещественные числа можно складывать и умножать, а переменные создавать на лету:

# арифметика и присваивания
x = 2 + 3 * 4       # 14
y = (50 - 5 * 6) / 4 # вещественное деление
z = 5 ** 2           # возведение в степень

Документация Python показывает, что присвоение связывает имя с объектом, а правая часть может быть сложным выражением. Вы можете использовать несколько переменных одновременно:

>>> a, b = 0, 1  # множественное присваивание

Работа со строками

Строки в Python заключаются в одиночные (' ') или двойные (" ") кавычки. Спецсимволы, такие как перенос строки (\n), экранируются обратной косой чертой. В документации отмечается, что для сырой строки (raw string) используется префикс r. Примеры:

text = "Hello\nWorld"    # строка с переводом строки
raw  = r"C:\\Users"      # сырая строка, \ не обрабатывается
multi = """Текст 
может занимать
несколько строк"""

# конкатенация и повторение
print("Hello" + " " + "Python")  # Hello Python
print("abc" * 3)                  # abcabcabc

Python поддерживает индексацию (нумерация элементов с нуля) и срезы. Срез [start:stop] возвращает новую строку от start до stop (не включая stop). Если start или stop опущены, используются значения по умолчанию. Например, в документации приведены такие примеры:

word = "Python"
print(word[0])     # 'P'
print(word[-1])    # последняя буква 'n'
print(word[:2])    # 'Py'
print(word[2:5])   # 'tho'
print(word[2:])    # 'thon'

Списки и кортежи

Списки

Список — упорядоченная коллекция произвольных объектов. Создать список можно с помощью квадратных скобок:

fruits = ['orange', 'apple', 'pear', 'banana']

У списков есть множество методов. Например, append() добавляет элемент в конец, pop() удаляет и возвращает последний элемент, а sort() сортирует список. В учебнике есть пример, в котором подсчитываются элементы, ищется позиция и выполняются операции сортировки и удаления. Пример:

fruits.append('grape')    # добавление
print(fruits.count('apple'))  # количество 'apple'
fruits.sort()             # сортировка
last = fruits.pop()       # удалить и вернуть последний элемент

Списки часто используются как стек или очередь. В качестве стека удобно применять методы append() и pop(). Для реализации очереди используют collections.deque, который обеспечивает быструю вставку и извлечение с двух концов.

Список как очередь

from collections import deque
queue = deque([1, 2, 3])
queue.append(4)      # добавить в конец
item = queue.popleft()  # удалить из начала

Компрехеншены списков

Список можно формировать через генераторы списков — компактную конструкцию [выражение for переменная in последовательность if условие]. В документации приводится пример создания списка квадратов чисел от 0 до 9:

# обычный цикл
squares = []
for x in range(10):
    squares.append(x**2)

# эквивалент через генератор списка
squares = [x**2 for x in range(10)]

Генераторы позволяют фильтровать и трансформировать элементы. Например, оставить только чётные числа и умножить на 2:

nums = [1, 2, 3, 4, 5]
filtered = [n*2 for n in nums if n % 2 == 0]  # [4, 8]

Кортежи

Кортеж (tuple) — неизменяемая последовательность. Элементы записываются через запятую, а скобки необязательны. В уроке отмечается, что кортежи удобны для упаковки и распаковки значений:

t = 12345, 54321, 'hello!'
u = t, (1, 2, 3, 4, 5)  # вложенный кортеж
x, y, z = t            # распаковка

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

Множества (set)

Множество — неупорядоченная коллекция уникальных элементов. Создать множество можно при помощи фигурных скобок или функции set(). Документация показывает, что дубликаты автоматически удаляются и поддерживаются математические операции объединения, пересечения и разности:

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(basket)        # {'orange', 'banana', 'pear', 'apple'}
print('orange' in basket)  # проверка принадлежности

# множество из букв в слове
a = set('abracadabra')
b = set('alacazam')
print(a - b)  # буквы в a, но не в b
print(a | b)  # буквы в a или b (объединение)
print(a & b)  # буквы в обоих множествах (пересечение)
print(a ^ b)  # буквы в a или b, но не одновременно

# генератор множества
s = {x for x in 'abracadabra' if x not in 'abc'}

Словари (dict)

Словарь — структура, где элементы хранятся как пары ключ : значение. Ключи должны быть неизменяемыми (строки, числа, кортежи). Словари удобны для быстрого поиска по ключу. В Python 3.7+ сохраняется порядок добавления. Пример создания и манипуляций словарём приведён в документации:

tel = {'jack': 4098, 'sape': 4139}
tel['guido'] = 4127      # добавление
print(tel['jack'])       # получение значения по ключу
print(tel.get('irv'))    # безопасное получение (None, если ключа нет)
del tel['sape']          # удаление ключа
print(list(tel))         # список ключей
print('guido' in tel)    # проверка наличия ключа

Словарь можно создать из списка пар или с помощью генератора словаря:

pairs = [('sape', 4139), ('guido', 4127), ('jack', 4098)]
d = dict(pairs)
d2 = {x: x**2 for x in (2, 4, 6)}

Перебор словаря и функций enumerate, zip

При обходе словаря удобно использовать метод items(), возвращающий пары ключ, значение. Для последовательностей (список, строка) применяется enumerate(), который даёт индекс и значение:

knights = {'gallahad': 'the pure', 'robin': 'the brave'}
for key, value in knights.items():
    print(key, value)  # gallahad the pure

# enumerate
for i, v in enumerate(['tic', 'tac', 'toe']):
    print(i, v)       # 0 tic, 1 tac, 2 toe

# одновременный обход двух списков
questions = ['name', 'quest', 'favorite color']
answers = ['lancelot', 'the holy grail', 'blue']
for q, a in zip(questions, answers):
    print(f"What is your {q}?  It is {a}.")

Управляющие конструкции

Условные операторы

Условный оператор if/elif/else позволяет выполнять код в зависимости от условий. Пример из руководства показывает использование ввода пользователя и сравнения целых чисел:

x = int(input("Введите целое число: "))
if x < 0:
    x = 0
    print('Отрицательное число заменено на 0')
elif x == 0:
    print('Ноль')
elif x == 1:
    print('Один')
else:
    print('Больше одного')

Цикл for и range()

Цикл for проходит по элементам последовательности. В документации есть пример, где для каждого слова из списка печатается его длина. Диапазоны удобно создавать с помощью функции range(start, stop, step).

words = ['cat', 'window', 'defenestrate']
for w in words:
    print(w, len(w))

# диапазон от 0 до 4
for i in range(5):
    print(i)

# диапазон с шагом
for i in range(5, 10, 2):  # 5,7,9
    print(i)

Встроенные функции для итераций

Помимо enumerate() и zip(), есть ещё sorted() (возвращает новый отсортированный список), reversed() (обратный итератор) и set() (получить уникальные элементы). Например:

for x in reversed(range(1, 4)):  # 3,2,1
    print(x)

for element in sorted(set('abracadabra')):
    print(element)

Функции

Функции объявляются с помощью def. В Python функции — объекты первого класса: их можно присваивать переменным, передавать как аргументы и возвращать из других функций. Рассмотрим основные моменты.

Функции с параметрами и значениями по умолчанию

Пример функции Фибоначчи, возвращающей список, показывает использование параметров и возвращаемого значения:

def fib2(n):  # вернуть список чисел Фибоначчи до n
    result = []
    a, b = 0, 1
    while a < n:
        result.append(a)
        a, b = b, a + b
    return result

print(fib2(10))  # [0, 1, 1, 2, 3, 5, 8]

По умолчанию аргументы задаются в определении функции. Функция ask_ok использует аргументы retries и reminder с дефолтными значениями, которые можно переопределить при вызове:

def ask_ok(prompt, retries=4, reminder='Пожалуйста, ответьте да или нет!'):
    while True:
        ok = input(prompt)
        if ok.lower() in ('y', 'ye', 'yes'):
            return True
        if ok.lower() in ('n', 'no', 'nop', 'nope'):
            return False
        retries -= 1
        if retries < 0:
            raise ValueError('Неверный ответ')
        print(reminder)

Важно помнить, что значение по умолчанию вычисляется один раз. Использование изменяемых объектов (например, списков) в качестве значения по умолчанию может привести к неожиданным последствиям. Пример документации демонстрирует проблему и корректное решение:

# неправильный подход
def f(a, L=[]):
    L.append(a)
    return L

print(f(1))  # [1]
print(f(2))  # [1, 2] — список накапливается

# правильный подход
def f(a, L=None):
    if L is None:
        L = []
    L.append(a)
    return L

Именованные аргументы и произвольное число параметров

Можно передавать аргументы по имени (keyword arguments) и использовать *args и **kwargs для произвольного числа позиционных и именованных аргументов. Например, функция parrot демонстрирует, как передавать параметры и обрабатывать их через *args и **kwargs.

def parrot(voltage, state='vooltage', action='voom', size='huge'):
    print(f"-- This parrot wouldn't {action}", end=' ')
    print(f"if you put {voltage} volts through it.")
    print(f"-- Lovely plumage! The {size} Norwegian Blue.")
    print(f"-- It's {state}!")

parrot(1000)                           # позиционный аргумент
parrot(action="jump", voltage=5)        # именованные аргументы
parrot(*[1000, 'bleedin'], **{'action': 'VOOOOM'})  # распаковка

Классы и объектно‑ориентированное программирование

Python поддерживает объектно‑ориентированный стиль. Класс определяет тип объекта, его свойства (атрибуты) и методы (функции). Простой пример класса приведён в руководстве:

class Complex:
    def __init__(self, real, imag):
        self.r = real
        self.i = imag

    def __repr__(self):
        return f"{self.r}+{self.i}j"

num = Complex(3.0, -4.5)
print(num)  # 3.0-4.5j

В примере класса Dog показано различие между атрибутами класса и атрибутами экземпляра. Атрибуты класса общие для всех объектов, а атрибуты экземпляра уникальны для каждого объекта. Это важно помнить, чтобы не разделять изменяемые объекты между экземплярами:

class Dog:
    tricks = []  # атрибут класса

    def __init__(self, name):
        self.name = name  # атрибут экземпляра

    def add_trick(self, trick):
        self.tricks.append(trick)

# неправильное использование: все собаки будут иметь общий список tricks
# правильнее инициализировать список в __init__

Модули и пакеты

Модуль — файл с расширением .py, содержащий определения функций, классов и переменных. Чтобы использовать модуль, его нужно импортировать. В руководстве показано, как создать модуль fibo.py с функциями fib и fib2 и затем импортировать его. Пример:

# fibo.py
# Функции для последовательности Фибоначчи

def fib(n):
    a, b = 0, 1
    while a < n:
        print(a, end=' ')
        a, b = b, a + b
    print()

def fib2(n):
    result = []
    a, b = 0, 1
    while a < n:
        result.append(a)
        a, b = b, a + b
    return result

Использование модуля:

import fibo
fibo.fib(100)
print(fibo.fib2(100))

from fibo import fib, fib2  # импорт отдельных функций
fib(50)

import fibo as f  # псевдоним
f.fib(50)

Работа с файлами

Чтение и запись текстовых файлов

Файлы открываются функцией open(filename, mode), где mode определяет режим: 'r' — чтение, 'w' — запись (перезаписывает файл), 'a' — дозапись. Лучше использовать конструкцию with, которая автоматически закрывает файл. Документация подчёркивает, что это безопаснее и чище:

# чтение файла
with open('data.txt', 'r', encoding='utf-8') as f:
    contents = f.read()  # вся строка

# построчное чтение
with open('data.txt', 'r', encoding='utf-8') as f:
    for line in f:
        print(line.strip())

# запись файла
with open('output.txt', 'w', encoding='utf-8') as f:
    f.write('Hello, file!\n')

Функции tell() и seek() показывают текущую позицию и позволяют перемещаться по файлу:

f = open('data.txt', 'rb')
print(f.tell())    # позиция в файле
f.seek(5)          # перейти к байту 5

Чтение и запись CSV

Для работы с CSV-форматом можно использовать библиотеку pandas (быстро и удобно) или встроенный модуль csv.

Pandas

Быстро импортировать CSV в таблицу (DataFrame) позволяет функция pd.read_csv(). В руководстве «10 минут с pandas» показан пример: DataFrame записывается в CSV и читается обратно:

import pandas as pd
import numpy as np

# создадим таблицу из случайных чисел и запишем в файл
df = pd.DataFrame(np.random.randint(0, 5, (10, 5)))
df.to_csv('foo.csv')

# считываем файл обратно
new_df = pd.read_csv('foo.csv')
print(new_df.head())

Модуль csv

Встроенный модуль csv предоставляет классы csv.reader и csv.writer. В документации приводится короткий пример чтения файла и вывода строк:

import csv
with open('eggs.csv', newline='') as csvfile:
    reader = csv.reader(csvfile, delimiter=' ', quotechar='|')
    for row in reader:
        print(', '.join(row))

Для записи данных создают объект csv.writer и вызывают writerow():

with open('eggs.csv', 'w', newline='') as csvfile:
    writer = csv.writer(csvfile, delimiter=' ', quotechar='|', quoting=csv.QUOTE_MINIMAL)
    writer.writerow(['Spam'] * 5 + ['Baked Beans'])
    writer.writerow(['Spam', 'Lovely Spam', 'Wonderful Spam'])

Если удобнее работать с полями по именам, используйте csv.DictReader и csv.DictWriter для чтения/записи словаря.

Чтение и запись JSON

Для работы с форматом JSON существует стандартный модуль json. Real Python демонстрирует, как сериализовать словарь в файл с помощью json.dump():

import json

dog_data = {
    "name": "Frieda",
    "age": 8,
    "hobbies": ["eating", "sleeping"],
    "is_dog": True,
}

with open("hello_frieda.json", mode="w", encoding="utf-8") as f:
    json.dump(dog_data, f)

Для чтения JSON-файла используйте json.load(). Документация Real Python подчёркивает важность использования контекстного менеджера и правильной кодировки:

import json

with open("hello_frieda.json", mode="r", encoding="utf-8") as f:
    data = json.load(f)
print(type(data))  # <class 'dict'>
print(data["name"])    # 'Frieda'

Для сериализации в строку используйте json.dumps(), а для чтения из строки — json.loads(). Параметр indent позволяет красиво форматировать вывод.

Исключения и обработка ошибок

При возникновении ошибки Python возбуждает исключение. Для его перехвата используется конструкция try/except. В примере из документации программа продолжает спрашивать у пользователя число до тех пор, пока ввод не будет корректным:

while True:
    try:
        x = int(input("Введите число: "))
        break
    except ValueError:
        print("Это не число!")

Можно перехватывать несколько типов исключений, добавляя несколько блоков except. Пример обработки исключений OSError и ValueError приведён в документации. Блок else выполняется, если исключение не возникло, а finally — всегда (удобно для закрытия ресурсов).

Чтобы вызвать исключение вручную, используется оператор raise.

Асинхронное программирование с asyncio

Модуль asyncio позволяет писать неблокирующий код, выполняющийся конкурентно. Короутины объявляются с помощью async def. Пример в документации демонстрирует простую корутину, которая печатает «hello», ждёт 1 секунду и затем печатает «world»:

import asyncio

async def main():
    print('hello')
    await asyncio.sleep(1)
    print('world')

asyncio.run(main())

Чтобы запускать несколько задач параллельно, используйте asyncio.create_task() и ожидайте их завершения. В документации показано, как функция say_after вызывается с разными задержками, а обе задачи запускаются одновременно:

import asyncio, time

async def say_after(delay, what):
    await asyncio.sleep(delay)
    print(what)

async def main():
    task1 = asyncio.create_task(say_after(1, 'hello'))
    task2 = asyncio.create_task(say_after(2, 'world'))
    print(f"started at {time.strftime('%X')}")
    await task1
    await task2
    print(f"finished at {time.strftime('%X')}")

asyncio.run(main())

Этот пример показывает, что обе задачи выполняются параллельно: общее время работы меньше суммы задержек. Вместо create_task() с Python 3.11 можно использовать TaskGroup, обеспечивающий автоматическое ожидание всех задач.

HTTP-запросы с библиотекой requests

Для взаимодействия с веб‑API удобна библиотека requests. В руководстве по быстрым запросам показано, как выполнять GET‑запрос и работать с параметрами. Сначала импортируется библиотека и выполняется запрос: response = requests.get('https://api.github.com/events') . Ответ содержит текст (response.text) и JSON (response.json()).

Передавать параметры удобно через аргумент params:

import requests

url = 'https://api.github.com/search/repositories'
params = {'q': 'language:python', 'sort': 'stars', 'order': 'desc'}
resp = requests.get(url, params=params)
data = resp.json()
for repo in data['items'][:5]:
    print(repo['full_name'], repo['stargazers_count'])

Библиотека requests также поддерживает методы post, put, delete, head и options.

Анализ данных с Pandas

Библиотека pandas предоставляет мощные инструменты для работы с табличными данными. В кратком руководстве «10 минут с pandas» рассмотрены основные структуры:

• Series — одномерный labeled‑массив.
• DataFrame — двумерная таблица с индексами строк и именами столбцов.

Создание DataFrame из массива NumPy с датами в качестве индекса:

import pandas as pd
import numpy as np

dates = pd.date_range("20130101", periods=6)
df = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=list("ABCD"))
print(df)

Для чтения файлов используется read_csv(), read_excel(), read_parquet() и др. Пример чтения CSV уже был приведён выше. Pandas позволяет фильтровать строки, выбирать столбцы, группировать данные и строить графики.

Заключение

Python — язык с богатой стандартной библиотекой и огромным количеством сторонних пакетов. В этой статье мы рассмотрели:

• основы работы с переменными, строками, списками, кортежами, множествами и словарями;
• управление потоком выполнения (условия и циклы) и полезные функции для итераций;
• определение функций, передачу аргументов и особенности изменяемых значений по умолчанию;
• создание классов и различие между атрибутами класса и экземпляра;
• использование модулей и пакетов;
• чтение и запись файлов (текстовых, CSV и JSON);
• обработку исключений;
• асинхронное программирование с asyncio;
• выполнение HTTP‑запросов с библиотекой requests;
• базовые операции анализа данных в pandas.

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