Этот материал объясняет ООП на Python последовательно и без «магии». Разберём разницу между классом и объектом, принципы ООП, синтаксис class, конструктор __init__ и роль self, атрибуты и методы, уровни доступа по соглашениям, наследование, множественное наследование и порядок разрешения методов (MRO), полиморфизм, инкапсуляцию через @property и дескрипторы, dataclasses, спецметоды data model, перегрузку операторов, сравнение и хеширование, __slots__, __new__ и метаклассы, сериализацию, контекстные менеджеры, а также ошибки и стили кодирования. Примеры даны в минималистичной форме, чтобы вы могли сразу переносить их в рабочие проекты.

1. Объекты и классы

Класс — шаблон, описывающий состояние (атрибуты) и поведение (методы). Объект — экземпляр класса, содержащий конкретные данные. В Python «всё — объект»: числа, функции, модули, классы.

class Car:
    pass

car = Car()
print(isinstance(car, Car))  # True 

Класс определяет контракт: какие поля и методы доступны, какие значения допустимы, какие инварианты должны сохраняться.

2. Четыре принципа ООП

• Абстракция: скрываем детали реализации, оставляем существенное.
• Инкапсуляция: ограничиваем прямой доступ к состоянию, используем методы/свойства.
• Наследование: переиспользуем код предков.
• Полиморфизм: единый интерфейс — разные реализации.

class Animal:
    def sound(self) -> str:
        raise NotImplementedError

class Dog(Animal):
def sound(self) -> str:
return "woof"

class Cat(Animal):
def sound(self) -> str:
return "meow"

def speak(x: Animal) -> None:
print(x.sound())

speak(Dog())
speak(Cat()) 

3. Синтаксис class и структура класса

Класс можно объявить без скобок наследования или с ними. Докстрока кратко фиксирует назначение и инварианты.

class ClassName(Base1, Base2):
    """Краткое описание, инварианты и ожидания по использованию."""
    VERSION = 1  # атрибут класса

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

def method(self) -> int:
    return self.x * self.VERSION
```

• Имена классов — CapWords: HttpClient, OrderService.
• Методы и поля — snake_case: max_items, load_data.
• Старайтесь создавать атрибуты только в __init__, чтобы структура экземпляра была очевидной.

4. Конструктор __init__ и self

__init__ инициализирует состояние, self — ссылка на текущий объект.

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

u = User("alice")
print(u.username, u.is_active) 

Не путайте __init__ и __new__: первый настраивает уже созданный объект, второй создаёт его (чаще нужен для неизменяемых типов).

class Percentage:
    def __init__(self, value: float):
        if not (0.0 <= value <= 100.0):
            raise ValueError("Процент от 0 до 100")
        self.value = value

• Не используйте изменяемые объекты как значения по умолчанию. Паттерн: items=None и внутри self.items = [] if items is None else list(items).
• Держите конструктор коротким: валидация + присваивания. Тяжёлую инициализацию выносите в методы-фабрики/класса.

5. Атрибуты: уровня класса и уровня экземпляра

Атрибуты класса общие для всех экземпляров. Атрибуты экземпляра — уникальны для объекта.

class Config:
    DEFAULT_TIMEOUT = 5  # статическое поле (уровень класса)

```
def __init__(self, timeout: int | None = None):
    self.timeout = timeout if timeout is not None else Config.DEFAULT_TIMEOUT
```

a = Config()
b = Config(timeout=10)
print(a.timeout, b.timeout, Config.DEFAULT_TIMEOUT)  # 5 10 5 

Если вам нужно общее для всех экземпляров, держите на уровне класса. Если значение зависит от конкретного объекта — храните на self.

6. Методы экземпляра, @classmethod и @staticmethod

class Path:
    def __init__(self, parts: list[str]):
        self.parts = parts

```
def join(self, *parts: str) -> "Path":      # метод экземпляра
    return Path(self.parts + list(parts))

@classmethod
def from_str(cls, s: str) -> "Path":        # альтернативный конструктор
    return cls(s.split("/"))

@staticmethod
def is_abs(s: str) -> bool:                 # логически относится к классу
    return s.startswith("/")
```

7. Уровни доступа: public, protected, private (соглашения)

В Python нет строгих модификаторов, используются соглашения:

• public: name — обычный атрибут.
• protected: _name — «для внутреннего использования» и классов-наследников.
• private: __name — включает name mangling в _Class__name.

class BankAccount:
    def __init__(self, owner: str, balance: int = 0):
        self.owner = owner
        self._currency = "RUB"
        self.__balance = balance

```
def deposit(self, amount: int) -> None:
    if amount <= 0:
        raise ValueError("Amount must be positive")
    self.__balance += amount

def get_balance(self) -> int:
    return self.__balance
```

8. Наследование, множественное наследование и MRO

Наследование устраняет дублирование кода. При множественном наследовании порядок поиска атрибутов задаёт MRO (C3-линеаризация). Правильный стиль — «кооперативные» методы с super(), согласованные сигнатуры и отказ от «жёстких» вызовов предков.

class A:
    def who(self) -> str:
        return "A"

class B(A):
def who(self) -> str:
return super().who() + "→B"

class C(A):
def who(self) -> str:
return super().who() + "→C"

class D(B, C):
def who(self) -> str:
return super().who() + "→D"

print(D().who())   # A→C→B→D
print(D.**mro**)   # порядок разрешения 

Миксины добавляют небольшое, локальное поведение без самостоятельной предметной роли.

class LoggingMixin:
    def log(self, msg: str) -> None:
        print(f"[{self.__class__.__name__}] {msg}")

class Service(LoggingMixin):
def run(self) -> None:
self.log("start")
# ...
self.log("done") 

9. Полиморфизм: утиная типизация и singledispatch

from functools import singledispatch

@singledispatch
def area(shape):
raise NotImplementedError

@area.register
def _(shape: tuple):   # прямоугольник (w, h)
w, h = shape
return w * h

@area.register
def _(shape: float):   # радиус круга
import math
return math.pi * shape * shape 

10. Инкапсуляция через @property и дескрипторы

@property позволяет валидировать доступ, сохраняя внешний интерфейс.

class Celsius:
    def __init__(self, value: float = 0.0):
        self._value = float(value)

```
@property
def value(self) -> float:
    return self._value

@value.setter
def value(self, new: float) -> None:
    if new < -273.15:
        raise ValueError("Ниже абсолютного нуля")
    self._value = float(new)
```

Дескриптор реализует протокол __get__/__set__/__delete__ и управляет атрибутом на уровне класса.

class NonEmptyStr:
    def __set_name__(self, owner, name):
        self.private_name = "_" + name
    def __get__(self, obj, objtype=None):
        return getattr(obj, self.private_name)
    def __set__(self, obj, value):
        if not isinstance(value, str) or not value.strip():
            raise ValueError("Строка должна быть непустой")
        setattr(obj, self.private_name, value)

class Person:
name = NonEmptyStr()
def **init**(self, name: str):
self.name = name 

11. Dataclasses: field(), default_factory, post_init, frozen

dataclasses генерируют конструктор, __repr__, сравнение и др. по аннотациям полей. frozen=True делает объект иммутабельным, order=True — добавляет упорядочивание.

from dataclasses import dataclass, field

@dataclass(order=True, frozen=True)
class Point:
x: int
y: int
tags: list[str] = field(default_factory=list, compare=False)

p = Point(1, 2)
print(p)                     # Point(x=1, y=2, tags=[])

# p.x = 5  # ошибка: объект заморожен

from dataclasses import dataclass

@dataclass
class Rect:
    w: float
    h: float
    def __post_init__(self):
        if self.w <= 0 or self.h <= 0:
            raise ValueError("Положительные размеры")

12. Data Model: спецметоды и перегрузка операторов

Спецметоды делают объекты «нативными» для языка: итерация, сравнение, арифметика, контекстный менеджмент.

class Vector:
    def __init__(self, *coords):
        self._c = tuple(coords)
    def __repr__(self):
        return f"Vector{self._c!r}"
    def __str__(self):
        return "⟨" + ", ".join(map(str, self._c)) + "⟩"
    def __len__(self):
        return len(self._c)
    def __iter__(self):
        return iter(self._c)
    def __add__(self, other):
        return Vector(*[a+b for a, b in zip(self._c, other._c)])
    def __eq__(self, other):
        return self._c == other._c
    def __hash__(self):
        return hash(self._c)

13. Абстрактные классы (abc) и протоколы (typing.Protocol)

from abc import ABC, abstractmethod

class Shape(ABC):
@abstractmethod
def area(self) -> float: ... 

from typing import Protocol

class Sized(Protocol):
    def __len__(self) -> int: ...

def total(x: Sized) -> int:
    return len(x)

Протоколы не требуют наследования — достаточно «утино» совместимого интерфейса.

14. __slots__: экономия памяти и запрет динамических атрибутов

class PackedPoint:
    __slots__ = ("x", "y")  # нет __dict__
    def __init__(self, x: float, y: float):
        self.x, self.y = x, y

Ограничения: нельзя добавлять произвольные атрибуты; наследование со __slots__ требует аккуратности.

15. __new__ и метаклассы

__new__ создаёт объект; полезен для неизменяемых типов и фабрикации. Метакласс — «класс для классов», позволяет перехватывать создание классов.

class Singleton(type):
    def __call__(cls, *a, **kw):
        if not hasattr(cls, "_inst"):
            cls._inst = super().__call__(*a, **kw)
        return cls._inst

class Config(metaclass=Singleton):
pass 

16. Сериализация и копирование

import copy, json, pickle

class Node:
def **init**(self, v, child=None):
self.v, self.child = v, child

root = Node(1, Node(2))
deep = copy.deepcopy(root)
blob = pickle.dumps(root)
data = json.dumps({"v": root.v}) 

17. Контекстные менеджеры

class Resource:
    def __enter__(self):
        print("acquire"); return self
    def __exit__(self, exc_type, exc, tb):
        print("release"); return False

with Resource() as r:
print("use") 

18. Композиция против наследования

Композицию выбирайте, когда «имеет» лучше, чем «является». Наследование — когда новый тип сохраняет контракт предка и расширяет поведение.

class Engine:
    def start(self): print("engine on")

class Vehicle:
def **init**(self, engine: Engine):
self.engine = engine

```
def go(self):
    self.engine.start()
    print("moving...")
```

19. Практический пример: Human, House, SmallHouse

class Human:
    def __init__(self, name: str, money: int = 0, house: "House | None" = None):
        self.name = name
        self._money = money
        self.house = house

```
def earn(self, amount: int) -> None:
    if amount <= 0:
        raise ValueError("amount must be positive")
    self._money += amount

def buy_house(self, house: "House", discount: float = 0.0) -> bool:
    price = house.final_price(discount)
    if self._money >= price:
        self._money -= price
        self.house = house
        return True
    return False

@property
def money(self) -> int:
    return self._money
```

class House:
def **init**(self, area: int, price: int):
if area <= 0 or price <= 0:
raise ValueError("area/price must be positive")
self.area = area
self.price = price

```
def final_price(self, discount: float = 0.0) -> int:
    return int(self.price * (1.0 - discount))
```

class SmallHouse(House):
DEFAULT_AREA = 40
def **init**(self, price: int):
super().**init**(area=SmallHouse.DEFAULT_AREA, price=price)

h = Human("Alex", money=100_000)
small = SmallHouse(price=90_000)
print(h.buy_house(small, discount=0.05))  # True
print(h.house.area, h.money)              # 40 14500 

20. Расширения примера

• Добавьте @property с проверкой, чтобы площадь и цена были положительными, скидка — в [0, 1).
• Сделайте CountryHouse с дополнительным полем plot_area и переопределением final_price.
• Реализуйте сравнение домов по цене и площади через functools.total_ordering.
• Сериализуйте список домов в JSON и восстановите его.

21. Типичные ошибки и приёмы

• Создание атрибутов «на лету» в методах, а не в __init__. Симптом: неоднозначная структура экземпляров.
• Отсутствие super() при множественном наследовании. Это ломает кооперативные цепочки.
• Смешение ответственности: «боже-объект» с десятками методов. Делите на небольшие классы.
• Неверное равенство/хеш: если определили __eq__, подумайте о согласованном __hash__ и иммутабельных полях.
• Злоупотребление наследованием там, где нужна композиция или делегирование.

22. Короткий чек-лист

• Определите контракт класса словом и кодом: докстрока, аннотации, инварианты.
• Создавайте все поля в __init__. Валидацию — сразу в конструкторе.
• Отдельно решайте «что является чем» (наследование) и «что содержит что» (композиция).
• Для согласованной иерархии используйте super() и единые сигнатуры.
• Инкапсуляция: @property и дескрипторы вместо «жёстких» публичных полей.
• Когда данные преобладают — подумайте о dataclasses.

Структура и акценты согласованы с учебными материалами по ООП (темы: «классы и объекты», «атрибуты/поля», «методы», «уровни доступа», «конструктор __init__», «практика»).

Сообщение Классы и объекты в Python: полное руководство по ООП с примерами для практики появились сначала на Системный блог.

Работа с файлами — это одна из самых важных и распространённых задач в программировании. В Python для эффективного взаимодействия с файловой системой используется встроенный модуль os. С помощью этого модуля можно легко выполнять множество операций, таких как создание, переименование, удаление, перемещение файлов, работа с путями, каталогами, а также получение информации о файлах. В этой статье мы подробно рассмотрим, как использовать модуль os для выполнения этих операций, а также рассмотрим дополнительные особенности работы с файловой системой в Python.

Зачем работать с файлами в Python?

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

Этот модуль значительно облегчает взаимодействие с операционной системой, предоставляя кроссплатформенные инструменты. То есть код, написанный с использованием модуля os, будет работать как на Windows, так и на Linux или macOS без изменений. В этой статье мы подробнее рассмотрим все ключевые возможности модуля os, которые позволяют работать с файлами и каталогами, а также управлять путями и атрибутами файлов.

Основные операции с файлами в Python

Модуль os предоставляет множество полезных функций для работы с файлами. Давайте разберем самые важные и часто используемые из них, которые помогут вам эффективно взаимодействовать с файлами в вашем коде.

Создание и открытие файлов

Для работы с файлами в Python используется встроенная функция open(), которая предоставляет несколько режимов доступа к файлам. Однако, с помощью модуля os, можно расширить возможности, выполняя дополнительные операции с файлами и каталогами на уровне операционной системы.

При использовании open() важно уметь правильно выбирать режимы открытия файлов:

• 'r' — режим чтения (по умолчанию). Если файл не существует, будет выброшено исключение FileNotFoundError.
• 'w' — режим записи. Если файл уже существует, его содержимое будет перезаписано.
• 'a' — режим добавления данных в конец файла. Если файл не существует, он будет создан.
• 'rb' — режим чтения бинарного файла.
• 'wb' — режим записи в бинарный файл.

После того как файл создан или открыт, его необходимо правильно закрывать, чтобы не возникало утечек памяти. Для этого можно использовать метод close(). Однако лучший способ — это использовать контекстный менеджер with, который гарантирует закрытие файла после завершения работы с ним.

import os

# Пример создания и записи в файл
file_path = 'example_file.txt'
with open(file_path, 'w') as file:
    file.write("Hello, world!")

# Проверка, существует ли файл
if os.path.exists(file_path):
    print(f"{file_path} существует")
else:
    print(f"{file_path} не существует")

В этом примере мы создаем файл, записываем в него строку и проверяем его существование с помощью функции os.path.exists().

Переименование и перемещение файлов

С помощью функции os.rename() можно не только переименовывать файлы, но и перемещать их между каталогами. Эта функция очень полезна, когда нужно организовать файлы в структуре папок или при изменении имени файла.

Если файл с новым именем уже существует, его содержимое будет перезаписано. Важно помнить, что переименование и перемещение файла может привести к потере данных, если целевой файл уже существует в указанном месте.

# Переименование файла
os.rename('example_file.txt', 'new_example_file.txt')

Также можно использовать этот метод для перемещения файла между папками, указав в качестве нового имени путь к целевому каталогу:

# Перемещение файла в другой каталог
os.rename('example_file.txt', '/new_directory/example_file.txt')

Удаление файлов

Для удаления файлов используется функция os.remove(). Это довольно простая и полезная операция, однако следует быть осторожными, так как файлы удаляются без возможности восстановления. Если файл не существует, будет вызвано исключение FileNotFoundError.

# Удаление файла
os.remove('new_example_file.txt')

Важно, что функция os.remove() работает только с файлами. Если вы хотите удалить каталог, используйте os.rmdir() для удаления пустых каталогов или shutil.rmtree() для удаления каталогов с содержимым.

Перемещение файлов с использованием shutil

Для более сложных операций перемещения, таких как копирование или перемещение файлов, можно использовать модуль shutil, который расширяет функциональность модуля os и предоставляет функции для перемещения и копирования файлов и каталогов.

import shutil

# Перемещение файла

shutil.move('example_file.txt', '/new_directory/example_file.txt')

# Копирование файла

shutil.copy('example_file.txt', '/new_directory/example_file.txt') 

Работа с каталогами в Python

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

Получение списка файлов и каталогов

Для того чтобы получить список всех файлов и каталогов в указанной директории, можно использовать функцию os.listdir(), которая возвращает список имен всех объектов в указанной директории. Это могут быть как файлы, так и подкаталоги.

# Получение списка файлов и каталогов в текущем каталоге
files = os.listdir('.')
print(files)

Для фильтрации результатов можно использовать такие функции, как os.path.isfile() для получения списка только файлов или os.path.isdir() для получения списка только каталогов.

Создание и удаление каталогов

Для создания нового каталога используйте функцию os.mkdir(). Эта функция создает каталог в текущем рабочем каталоге. Если необходимо создать несколько уровней каталогов, используйте os.makedirs().

# Создание каталога
os.mkdir('new_directory')

# Создание нескольких вложенных каталогов

os.makedirs('parent_directory/child_directory') 

Для удаления каталога используется функция os.rmdir(), которая удаляет только пустые каталоги. Чтобы удалить каталог с содержимым, используйте shutil.rmtree().

import shutil

# Удаление каталога с содержимым
shutil.rmtree('new_directory')

Абсолютные и относительные пути в Python

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

Абсолютный путь — это полный путь к файлу, начиная с корня файловой системы. Относительный путь указывает путь, который относительно текущего местоположения файла или программы.

# Абсолютный путь
absolute_path = os.path.abspath('example.txt')
print(absolute_path)

# Относительный путь
relative_path = os.path.join('folder', 'example.txt')
print(relative_path)

Функция os.path.abspath() позволяет получить абсолютный путь к файлу, а os.path.join() помогает легко соединять пути, обеспечивая кроссплатформенность кода (например, правильный разделитель пути для разных операционных систем).

Ошибки при работе с файлами и каталогами

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

try:
    os.remove('nonexistent_file.txt')
except FileNotFoundError:
    print("Файл не найден!")
except PermissionError:
    print("Нет прав для удаления файла.")

Практические примеры работы с модулями OS

Пример создания и работы с файлами для использования в различных проектах:

# Пример создания и работы с файлами
def create_and_write_file(filename, content):
    with open(filename, 'w') as file:
        file.write(content)
    print(f"Файл {filename} успешно создан и записан.")

create_and_write_file('test_file.txt', 'Hello, Python!')

В этом примере мы создаём новый файл, записываем в него данные и выводим сообщение о том, что операция выполнена успешно.

Заключение

Модуль os является неотъемлемой частью работы с файловой системой в Python. Он предоставляет все необходимые инструменты для работы с файлами и каталогами, управления путями и атрибутами файлов, а также для выполнения системных операций с файлами. Использование этого модуля значительно облегчает взаимодействие с операционной системой и помогает делать код более переносимым и надежным.

Часто задаваемые вопросы (FAQ)

Сообщение Работа с файлами в Python с помощью модуля OS: Полный гид появились сначала на Системный блог.

Типы файлов, с которыми можно работать в Python

Python поддерживает два основных типа файлов: текстовые и бинарные.

• Текстовые файлы: Эти файлы содержат текстовую информацию, такую как .txt, .csv, .log, .xml. Эти файлы можно легко открыть и прочитать с помощью стандартных текстовых методов, потому что их содержимое представлено в виде строк, кодируемых в определённой кодировке (чаще всего UTF-8).
• Бинарные файлы: Это файлы, содержащие данные в двоичной форме, такие как изображения (.png, .jpg), видео (.mp4), исполнимые файлы (.exe) и т.д. Эти файлы требуют специальной обработки, так как их содержимое представлено в виде байтов, а не строк.

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

Открытие и закрытие файлов в Python

Для работы с файлом в Python необходимо его сначала открыть. Открытие файла осуществляется с помощью функции open(), в которую передаётся путь к файлу и режим доступа к файлу.

Режимы работы с файлом:

• 'r' — чтение файла (по умолчанию). Если файл не существует, будет вызвана ошибка.
• 'w' — запись в файл. Если файл уже существует, его содержимое будет перезаписано.
• 'a' — добавление данных в файл. Новые данные будут добавлены в конец файла.
• 'rb' — чтение бинарного файла.
• 'wb' — запись в бинарный файл.

После завершения работы с файлом его нужно закрыть с помощью метода close(). Однако гораздо удобнее и безопаснее использовать контекстный менеджер with, который автоматически закроет файл, даже если в процессе работы возникнут ошибки.

# Пример открытия и закрытия файла с использованием контекстного менеджера
with open('example.txt', 'r') as file:
    content = file.read()
    print(content)  # выводим содержимое файла
# Файл будет закрыт автоматически после выхода из блока with

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

Чтение из файлов в Python

После того как файл открыт, можно читать его содержимое. В Python для чтения используются следующие методы:

• read() — читает весь файл целиком. Метод вернёт строку, содержащую всё содержимое файла. Это полезно, когда файл небольшой.
• readline() — читает одну строку за раз. Этот метод полезен, если файл очень большой и нужно читать его по частям.
• readlines() — читает весь файл построчно и возвращает список строк. Это удобно, если нужно работать с файлами, где строки имеют смысл, например, в CSV-файлах.

Пример чтения всего содержимого файла:

with open('example.txt', 'r') as file:
    content = file.read()  # читаем весь файл
    print(content)  # выводим содержимое файла

Чтение файла построчно с использованием цикла:

with open('example.txt', 'r') as file:
    for line in file:  # цикл по строкам
        print(line.strip())  # удаляем лишние символы новой строки

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

Запись в файлы в Python

Для записи данных в файл используется метод write(). Этот метод позволяет записывать строку или данные в файл. Если файл открыт в режиме 'w', его содержимое будет перезаписано, а если в режиме 'a', новые данные будут добавляться в конец файла.

# Запись в файл
with open('output.txt', 'w') as file:
    file.write("Hello, Python!n")
    file.write("This is a test file.")

Для записи бинарных данных файл должен быть открыт в бинарном режиме. Например, для записи изображения или другого бинарного файла:

# Запись в бинарный файл
with open('image.png', 'wb') as file:
    file.write(binary_data)  # записываем данные в файл

Метод write() не добавляет символ новой строки в конце данных, поэтому если вы хотите записать несколько строк, нужно явно добавить символы новой строки или использовать writelines() для записи списка строк.

Работа с позицией в файле: методы tell() и seek()

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

• tell() — возвращает текущую позицию указателя в файле. Это полезно, если вам нужно узнать, на каком месте в файле вы сейчас находитесь.
• seek() — позволяет перемещать указатель на определённую позицию в файле. Можно использовать абсолютные позиции или смещение от текущей позиции.

Пример использования tell() и seek():

with open('example.txt', 'r') as file:
    file.seek(10)  # перемещаем указатель на 10 байт
    print(file.tell())  # выводим текущую позицию указателя
    content = file.read(5)  # читаем 5 байт с текущей позиции
    print(content)

Метод seek() позволяет не только изменять позицию, но и перемещать указатель в начало файла, что удобно для работы с большими файлами, когда необходимо многократно обращаться к данным в разных частях.

Обработка ошибок при работе с файлами

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

try:
    with open('nonexistent_file.txt', 'r') as file:
        content = file.read()
except FileNotFoundError:
    print("Файл не найден!")
except IOError:
    print("Ошибка ввода-вывода!")

Использование блоков try/except позволяет избежать неожиданных сбоев программы и предоставляет возможность корректно обработать возникшие проблемы.

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

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

Для этого используйте методы readline() или readlines(), а также читайте файл по частям с помощью цикла:

with open('large_file.txt', 'r') as file:
    while chunk := file.read(1024):  # читаем файл блоками по 1024 байта
        process(chunk)  # обработка данных

Заключение

Работа с файлами в Python — это важный аспект программирования, который позволяет взаимодействовать с данными на диске. Важно правильно открывать, читать и записывать файлы, использовать методы для управления позицией указателя, а также обрабатывать возможные ошибки. Контекстный менеджер with позволяет удобно управлять открытием и закрытием файлов, что делает код более надёжным. Следуя этим рекомендациям, вы сможете эффективно работать с файлами в Python, обрабатывать большие данные и избегать ошибок при работе с файлами.

Часто задаваемые вопросы (FAQ)

Сообщение Работа с файлами в Python: Полный гид по чтению, записи и обработке файлов появились сначала на Системный блог.

Исключения в Python — это механизм сигнализации об ошибках во время выполнения. Правильная обработка исключений делает код надёжным и читаемым. Ниже — базовые конструкции try/except, связка else/finally, генерация ошибок raise, пользовательские исключения и практики.

Что такое исключения и почему они важны

Исключение — объект, который «выбрасывается» (raise) при ошибочной ситуации: деление на ноль, выход за пределы списка, сбой сети, неправильные данные. Если исключение не перехвачено, интерпретатор прерывает программу и печатает Traceback.

• Перехват исключений не скрывает ошибку, а делает поведение контролируемым.
• Обработка повышает устойчивость сервисов и CLI.
• Правильный перехват упрощает отладку.

Иерархия исключений в Python

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

# Фрагмент дерева (упрощённо)
BaseException
 ├─ SystemExit
 ├─ KeyboardInterrupt
 └─ Exception
    ├─ ArithmeticError
    │   ├─ ZeroDivisionError
    │   └─ OverflowError
    ├─ LookupError
    │   ├─ IndexError
    │   └─ KeyError
    ├─ FileNotFoundError
    ├─ ValueError
    ├─ TypeError
    ├─ OSError
    └─ RuntimeError

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

Базовая конструкция try/except

Используйте try/except, чтобы безопасно выполнить рискованный код:

def safe_div(x, y):
    try:
        return x / y
    except ZeroDivisionError as e:
        return float("inf")  # или логика по умолчанию

Можно перехватывать несколько типов исключений разными блоками except или одной «кортежной» записью.

def parse_int(value):
    try:
        return int(value)
    except (ValueError, TypeError) as e:
        return None

Используйте as e, чтобы получить объект исключения и записать сообщение в лог.

Расширения: else и finally

Блок else выполняется, если в try не произошло исключения. Блок finally выполняется всегда — несмотря ни на что.

def read_number(path):
    f = None
    try:
        f = open(path, "r", encoding="utf-8")
        data = f.read()
    except FileNotFoundError:
        return None
    else:
        return int(data.strip())
    finally:
        if f:
            f.close()

Чаще вместо ручного finally используйте with, который корректно освободит ресурсы.

Генерация исключений: raise

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

def sqrt_positive(x: float) -> float:
    if x < 0:
        raise ValueError('x must be non-negative')
    return x ** 0.5

Для сохранения исходного контекста используйте raise from, чтобы связать исключения цепочкой (exception chaining) и быстрее диагностировать первопричину.

def load_json(path):
    import json
    try:
        with open(path, encoding="utf-8") as f:
            return json.load(f)
    except OSError as e:
        raise RuntimeError('Unable to read file') from e

Повторный выброс (re-raise) — просто raise без аргументов внутри блока except. Он полезен, если вы что-то залогировали и хотите передать ошибку выше.

try:
    risky()
except Exception:
    log_exception()  # запись в журнал
    raise

Пользовательские исключения

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

class PaymentError(Exception):
    'Базовая ошибка платежей.'

class CardDeclinedError(PaymentError):
pass

def charge(amount, card):
if not card.valid:
raise CardDeclinedError('Card declined') 

Совет: храните пользовательские исключения в модуле exceptions.py и документируйте условия их возникновения.

Множественные except и порядок проверки

Python сопоставляет исключение с блоками except сверху вниз. Узкие типы пишите раньше широких.

try:
    ...
except ValueError:
    handle_value()
except Exception:
    handle_generic()

EAFP против LBYL

Идиома Python — EAFP (Easier to Ask Forgiveness than Permission): «проще просить прощения, чем разрешения». Альтернатива — LBYL (Look Before You Leap): предварительно проверять условия.

# EAFP
try:
    value = mapping[key]
except KeyError:
    value = default

# LBYL

if key in mapping:
value = mapping[key]
else:
value = default 

EAFP обычно короче и масштабируется лучше в конкурентных сценариях.

Практические паттерны обработки ошибок

• Валидация входных данных: выбрасывайте ValueError/TypeError для некорректного ввода.
• Работа с файлами: перехватывайте FileNotFoundError, PermissionError, используйте with.
• Сеть и API: ловите OSError, таймауты, ошибки библиотек; ретраи при нужде.
• Базы данных: разделяйте транзиентные и фатальные ошибки.

import json
from pathlib import Path

def load_settings(path: str) -> dict:
p = Path(path)
try:
text = p.read_text(encoding='utf-8')
return json.loads(text)
except FileNotFoundError:
return {'theme': 'light', 'autosave': False}
except json.JSONDecodeError as e:
raise ValueError(f'Invalid config format: {e}') 

Логирование исключений

Используйте модуль logging вместо принтов. Метод logging.exception автоматически добавляет стек-трейс.

import logging

log = logging.getLogger(**name**)

def process(item):
try:
step(item)
except Exception:
log.exception('Failed to process item: %r', item)
raise 

Короткий чек-лист лучших практик

• Ловите только те ошибки, с которыми реально можете что-то сделать.
• Сообщения делайте конкретными: указывайте проблемное значение, путь, ключ, лимит.
• Не используйте исключения как обычные if/else — это дорого и запутывает контроль потока.
• Для библиотек документируйте, какие типы ошибок кидаете и когда.
• В публичных API мапьте внутренние ошибки на доменные.

def fetch(user_id, repo):
    if not isinstance(user_id, int):
        raise TypeError('user_id must be int')
    try:
        return repo.get(user_id)
    except OSError as e:
        raise RuntimeError('storage error') from e

Анти-паттерны: чего избегать

• except Exception: без нужды — маскирует баги.
• голые except: перехватывают BaseException включая KeyboardInterrupt.
• молчаливый перехват: пустой обработчик без логирования.
• злоупотребление assert: утверждения могут быть отключены.
• неподходящие типы ошибок: ValueError для значения, TypeError для типа и т.п.

Исключения и контекстные менеджеры

Контекстные менеджеры инкапсулируют открытие/закрытие ресурсов и политику ошибок. Свой менеджер — через класс с __enter__/__exit__ или декоратор contextmanager.

from contextlib import contextmanager

@contextmanager
def opened(path, mode='r', encoding='utf-8'):
f = open(path, mode, encoding=encoding)
try:
yield f
finally:
f.close() 

Исключения в тестах

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

import pytest

def test_sqrt_positive_raises():
with pytest.raises(ValueError):
sqrt_positive(-1) 

Частые вопросы (FAQ)

Помните: «Ловите то, что готовы обработать». Остальное должно падать быстро и громко

Освоив try/except, else/finally и raise, вы пишете предсказуемый код. Перехватывайте конкретные типы, логируйте исключения, проектируйте свои классы там, где это повышает ясность, и придерживайтесь идиомы EAFP. Удачной разработки!

Сообщение Обработка исключений в Python появились сначала на Системный блог.

Функции — основной механизм структурирования программ в Python. Они позволяют сгруппировать логику под понятным именем, сократить дублирование, улучшить читаемость и изолировать поведение для тестирования. Ниже — полный разбор: синтаксис def и return, позиционные и именованные аргументы, значения по умолчанию, вариативные параметры *args/**kwargs, области видимости, замыкания, lambda, рекурсия, декораторы, типизация и практики качества. Всё сопровождается примерами и упражнениями.

Что такое функция

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

def normalize_name(raw: str) -> str:
    text = raw.strip()
    return text.capitalize()

print(normalize_name("  алиса  "))  # Алиса

Синтаксис: def, параметры и return

Определение начинается с def и имени в стиле snake_case; список параметров заключён в скобки; тело отделяется двоеточием и отступами. Оператор return завершает выполнение и передаёт значение. Если return не указан — возвращается None.

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

def greet(name: str) -> None:
print(f"Привет, {name}!")

print(add(2, 3))       # 5
print(greet("Алиса"))  # None

Вызов функций: позиционные и именованные аргументы

Аргументы можно передавать по позиции и по имени. Именованные аргументы повышают читаемость и снижают риск перепутать порядок.

def connect(host: str, port: int, use_ssl: bool) -> str:
    return f"{host}:{port} ssl={use_ssl}"

print(connect("example.com", 443, True))
print(connect(host="example.com", port=443, use_ssl=True))

Виды параметров в сигнатуре

Python поддерживает позиционные-только, позиционные/именованные, именованные-только параметры и вариативные. Разделители: символ / вводит позиционные-только, символ * — границу, после которой параметры принимаются только по имени.

def f(a, b, /, c, d, *, e, f_):
    # a, b — только позиционно; c, d — позиционно или по имени; e, f_ — только по имени
    return a + b + c + d

Значения по умолчанию, *args и **kwargs

Значения по умолчанию сокращают количество обязательных аргументов. *args собирает произвольное число позиционных параметров в кортеж, **kwargs — именованные в словарь.

def paginate(page: int = 1, per_page: int = 20) -> tuple[int, int]:
    start = (page - 1) * per_page
    return start, per_page

def summarize(*nums: float, **opts) -> str:
total = sum(nums)
prefix = opts.get("prefix", "sum")
return f"{prefix}={total}"

print(paginate())                       # (0, 20)
print(summarize(1, 2, 3, prefix="Σ"))   # Σ=6

def append_bad(item, bucket=[]):
    bucket.append(item)
    return bucket  # состояние «залипает» между вызовами

def append_ok(item, bucket=None):
if bucket is None:
bucket = []
bucket.append(item)
return bucket

Распаковка аргументов и управление вызовами

Последовательности можно распаковать как позиционные, словари — как именованные аргументы. Это удобно при передачах параметров «сквозь» функции.

def area(w: float, h: float) -> float:
    return w * h

args = (3, 4)
kwargs = {"w": 5, "h": 6}
print(area(*args))      # 12
print(area(**kwargs))   # 30

Область видимости: локальные, глобальные, nonlocal

Имена, созданные в функции, локальны. Чтение глобальных переменных допустимо; для записи используйте global. Во вложенных функциях можно менять переменные внешней функции через nonlocal. Сократите использование global/nonlocal — чаще лучше возвращать результат или инкапсулировать состояние в объект.

counter = 0

def tick():
global counter
counter += 1

def outer():
x = 0
def inner():
nonlocal x
x += 1
inner(); inner()
return x  # 2

Замыкания и функции высшего порядка

Функции — объекты первого класса: их можно передавать, возвращать и хранить в структурах данных. Замыкание захватывает из внешней области используемые переменные.

from typing import Callable

def make_counter() -> Callable[[], int]:
n = 0
def inc():
nonlocal n
n += 1
return n
return inc

c = make_counter()
print(c(), c(), c())  # 1 2 3

Анонимные функции (lambda)

lambda задаёт короткую безымянную функцию из одного выражения. Она удобна для ключей сортировки, простых преобразований и «инлайновых» колбэков. Если логика разрастается — переходите на def.

users = [{"name":"bob","age":30},{"name":"ann","age":20}]
print(sorted(users, key=lambda u: (u["age"], u["name"])))

Рекурсия и итерация

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

def fact(n: int) -> int:
    if n < 2:
        return 1
    return n * fact(n - 1)

def fact_iter(n: int) -> int:
res = 1
for k in range(2, n + 1):
res *= k
return res

Декораторы: расширяем поведение без правки исходника

Декоратор принимает функцию и возвращает новую, «обёрнутую», добавляя кросс-функциональные аспекты: логирование, кеширование, авторизацию, измерение времени.

import time
from functools import wraps

def timing(fn):
@wraps(fn)
def wrapper(*args, **kwargs):
t0 = time.perf_counter()
try:
return fn(*args, **kwargs)
finally:
dt = (time.perf_counter() - t0) * 1000
print(f"{fn.**name**} took {dt:.1f} ms")
return wrapper

@timing
def heavy():
sum(range(1_000_00))
heavy()

from functools import lru_cache

@lru_cache(maxsize=1024)
def fib(n: int) -> int:
if n < 2:
return n
return fib(n - 1) + fib(n - 2)

Типизация и документация

Аннотации типов помогают IDE и статическим анализаторам, а докстринги объясняют назначение и контракт функции. Придерживайтесь единого формата (Google/NumPy/reST), и описывайте параметры, возвращаемое значение и исключения.

def clamp(x: float, low: float, high: float) -> float:
    """Ограничивает x интервалом [low, high]."""
    return max(low, min(high, x))

Ошибки и исключения

Исключительные ситуации обрабатывайте через try/except, а не через громоздкие ветвления. Логи фиксируют контекст и ускоряют диагностику.

import logging
logging.basicConfig(level=logging.INFO)

def price_from_str(s: str) -> float:
try:
val = float(s)
if val < 0:
raise ValueError("negative")
logging.info("ok: %s", val)
return val
except ValueError as e:
logging.error("parse error: %s", e)
return 0.0

Практики качества

• SRP: одна функция — одна задача.
• Понятные имена: глаголы для действий (load_user), существительные для вычислений (distance).
• Минимизируйте скрытые побочные эффекты; явно возвращайте новые объекты.
• Гвард-клаусы: ранний выход упрощает чтение.
• Покрывайте ветвления тестами; добавляйте примеры в докстринг.

def can_access(user: dict | None) -> bool:
    if not user:
        return False
    if not user.get("active"):
        return False
    return user.get("role") == "admin"

Инструменты функционального стиля

Модуль functools предлагает полезные утилиты: partial для частичного применения, cmp_to_key для старых сравнителей, lru_cache для мемоизации.

from functools import partial

def power(base: int, exp: int) -> int:
return base ** exp

square = partial(power, exp=2)
print(square(7))  # 49

Мини-практикум: 6 задач для закрепления

1) Форматтер строк с *args и **kwargs

def fmt(*parts, **opts):
    sep = opts.get("sep", " ")
    end = opts.get("end", "!")
    return sep.join(map(str, parts)) + end

print(fmt("Hello", "Python", sep="-", end=" 🚀"))

2) Нормализатор коллекций

from typing import Iterable, Callable, Any

def normalize(items: Iterable[Any], *, unique=False, key: Callable | None = None):
xs = [key(x) if key else x for x in items]
return list(dict.fromkeys(xs)) if unique else xs

print(normalize([" A ","A","b"], unique=True, key=lambda s: s.strip().lower()))

3) Глубина вложенных структур

def deep_len(x) -> int:
    if isinstance(x, (list, tuple, set)):
        return sum(deep_len(i) for i in x)
    return 1

print(deep_len([1,(2,3),[4,[5,6]]]))  # 6

4) Декоратор повторных попыток

import random, time
from functools import wraps

def retry(times=3, delay=0.1):
def deco(fn):
@wraps(fn)
def wrap(*a, **kw):
for attempt in range(times):
try:
return fn(*a, **kw)
except Exception:
if attempt + 1 == times:
raise
time.sleep(delay)
return wrap
return deco

@retry(times=5, delay=0.05)
def flaky():
if random.random() < 0.7:
raise RuntimeError("fail")
return "ok"

print(flaky())

5) Композиция функций

from typing import Callable

def compose(f: Callable, g: Callable) -> Callable:
return lambda x: f(g(x))

strip_cap = compose(str.capitalize, str.strip)
print(strip_cap("   python  "))  # Python

6) Проверка контрактов

def require_positive(fn):
    def wrap(x: float):
        assert x >= 0, "x must be non-negative"
        return fn(x)
    return wrap

@require_positive
def sqrt_approx(x: float) -> float:
# примитивная аппроксимация Ньютона
g = x or 1.0
for _ in range(10):
g = 0.5 * (g + x / g)
return g

print(round(sqrt_approx(9), 3))

FAQ

Почему функция возвращает None?

В ветке отсутствует return или он вызывается без значения. Проверьте условия и убедитесь, что из каждой ветви возвращаете результат.

Когда использовать *args и **kwargs?

Когда количество параметров заранее неизвестно или требуется гибкость. Важные аргументы делайте явными, а «настройки» передавайте через **kwargs.

Чем lambda отличается от def?

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

Как документировать функции?

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

Зачем типовые аннотации?

Они не влияют на выполнение, но повышают качество рецензий, снижают число ошибок и улучшают подсказки IDE.

Рекурсия или цикл?

Рекурсия уместна на деревьях и разборе вложенных структур; для длинных последовательностей надёжнее цикл или явный стек.

Почему изменяемые дефолты — проблема?

Потому что объект создаётся один раз при определении функции и «копится» между вызовами. Используйте None и создавайте новый контейнер внутри.

Итоги

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

Сообщение Функции в Python: определение, вызов и приёмы для построения переиспользуемого кода появились сначала на Системный блог.

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

Ключевая идея

Список — упорядоченная и изменяемая последовательность. Это означает:

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

empty = []
mix = [1, "a", 3.14, True]
grid = [[1, 2], [3, 4]]        # вложенные списки

mix[0] = 42                    # изменение «на месте»

Важно: переменные хранят ссылку на объект. Присваивание создаёт вторую ссылку, а не копию.

a = [1, 2, 3]
b = a
b.append(99)
print(a)  # [1, 2, 3, 99]

Создание списков

• Литерал: []
• Конструктор: list(iterable)
• Преобразование из других коллекций: tuple, set, range
• Генератор списка (list comprehension)

L1 = [1, 2, 3]
L2 = list("abc")            # ['a', 'b', 'c']
L3 = list(range(5))         # [0, 1, 2, 3, 4]
tpl = (10, 20)
L4 = list(tpl)              # [10, 20]
squares = [x * x for x in range(6)]

bad = [[0] * 3] * 2
bad[0][0] = 9
print(bad)  # [[9, 0, 0], [9, 0, 0]]

good = [[0] * 3 for _ in range(2)]  # независимые строки

Индексация и срезы

Индексация с нуля. Отрицательные индексы отсчитываются с конца. Срезы создают новый список; присваивание срезу изменяет исходный.

L = ["a", "b", "c", "d", "e"]
L[0], L[-1]               # 'a', 'e'
L[1:4]                    # ['b', 'c', 'd']
L[::2]                    # ['a', 'c', 'e']
copy1 = L[:]              # поверхностная копия
L[1:3] = ["B", "C"]       # ['a', 'B', 'C', 'd', 'e']

Операции со списками

• len(L) — размер;
• in/not in — проверка наличия;
• + — конкатенация; * — повторение;
• лексикографическое сравнение по элементам.

nums = [1, 2, 3]
len(nums)              # 3
2 in nums              # True
nums + [4, 5]          # [1, 2, 3, 4, 5]
["a"] * 3              # ['a', 'a', 'a']

Методы списков: практичный справочник

Добавление

append(x) — один элемент в конец; extend(iterable) — добавить элементы итерируемого; insert(i, x) — вставка по индексу.

L = [1, 2]
L.append(3)                # [1, 2, 3]
L.extend([4, 5])           # [1, 2, 3, 4, 5]
L.insert(1, 100)           # [1, 100, 2, 3, 4, 5]

# типичная путаница:

L = [1, 2]; L.append([3, 4])  # [1, 2, [3, 4]] (один элемент-список)

Удаление и извлечение

remove(x) — удаляет первое вхождение; pop(i=-1) — возвращает и удаляет элемент по индексу; clear() — очищает список.

L = ["a", "b", "b", "c"]
L.remove("b")         # ["a", "b", "c"]
last = L.pop()        # "c", теперь ["a", "b"]
first = L.pop(0)      # "a", теперь ["b"]
L.clear()             # []

Поиск и подсчёт

index(x[, start[, end]]) — индекс первого вхождения; count(x) — количество элементов, равных x.

L = [10, 20, 10, 30]
L.index(10)        # 0
L.index(10, 1)     # 2
L.count(10)        # 2

Порядок элементов

sort(key=None, reverse=False) — сортирует «на месте»; reverse() — разворачивает список; функция sorted() возвращает новый список.

L = ["Bob", "alice", "Carol"]
L.sort()                 # ['Bob', 'Carol', 'alice'] (Unicode-порядок)
L.sort(key=str.lower)    # ['alice', 'Bob', 'Carol'] (без регистра)
L.reverse()              # ['Carol', 'Bob', 'alice']

nums = [3, 1, 2]
sorted(nums)             # [1, 2, 3]; исходник не меняется

Копирование

Поверхностная копия: L.copy() или L[:]. Для вложенных структур — copy.deepcopy.

import copy
L = [[1], [2]]
shallow = L.copy()
deep = copy.deepcopy(L)
L[0].append(99)
print(shallow)   # [[1, 99], [2]]
print(deep)      # [[1], [2]]

Итерация и распаковка

Для доступа к индексам используйте enumerate, для параллельного обхода нескольких коллекций — zip. Удобна «звёздная распаковка».

colors = ["red", "green", "blue"]
for i, c in enumerate(colors, start=1):
    print(i, c)

xs = [1, 2, 3]; ys = [4, 5, 6]
for x, y in zip(xs, ys):
print(x, y)

head, *middle, tail = [10, 20, 30, 40]
print(head, middle, tail)  # 10 [20, 30] 40

Генераторы списков

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

evens = [x for x in range(10) if x % 2 == 0]
pairs = [(x, y) for x in range(3) for y in range(2)]
labels = ["even" if x % 2 == 0 else "odd" for x in range(5)]

# эквивалент через цикл для сложных сценариев

res = []
for x in range(10):
if x % 2 == 0:
res.append(x)

Вложенные списки (таблицы/матрицы)

«Список списков» — удобная модель двумерных данных. Следите за независимостью строк и осторожно копируйте.

M = [[1, 2, 3], [4, 5, 6]]
M[1][2]  # 6

rows, cols = 2, 3
M = [[0] * cols for _ in range(rows)]

Стандартные функции, которые «любят» списки

• sum, min, max — агрегирование;
• any, all — логические проверки с коротким замыканием;
• sorted — сортировка без изменения исходника;
• map, filter — преобразование/фильтрация (часто читаемее через генераторы).

nums = [3, 5, 1, 4]
sum(nums), min(nums), max(nums)          # 13, 1, 5
any(n % 2 == 0 for n in nums)            # есть ли чётные
all(n > 0 for n in nums)                 # все ли положительные
data = [{"name": "bob", "age": 30}, {"name": "ann", "age": 20}]
sorted(data, key=lambda d: d["age"])

Производительность: что важно знать

• append — амортизированно O(1).
• Вставки/удаления в середине — O(n).
• Частые операции «в начале» удобнее переносить на collections.deque.
• Не конкатенируйте списки в цикле через +; собирайте элементы и применяйте extend один раз.

Полезные паттерны

• Стек: append / pop().
• Очередь: используйте collections.deque для popleft.
• Удаление по условию: создавайте новый список, а не меняйте текущий в процессе обхода.
• Сохранить порядок и удалить дубликаты — через «множество виденных».

seen, out = set(), []
for x in [1, 2, 2, 3, 1, 4]:
    if x not in seen:
        seen.add(x); out.append(x)
print(out)  # [1, 2, 3, 4]

Антипаттерны и частые ошибки

• Путаница append/extend.
• Ссылки вместо копий (нужны copy, срез или deepcopy для вложенных структур).
• [[0]*N]*M для матриц — общие ссылки на строки.
• Изменение списка во время итерации по нему.
• Сравнение значений через is вместо ==.

L = [1, 2, 3, 4, 5]
L = [x for x in L if x % 2 == 0]

Практикум

# 1) чётные квадраты
nums = [1, 2, 3, 4, 5, 6]
print([n * n for n in nums if n % 2 == 0])  # [4, 16, 36]

# 2) разворачивание вложенного списка

nested = [[1, 2], [3, 4, 5]]
flat = [x for sub in nested for x in sub]
print(flat)

# 3) частоты элементов

data = ["a", "b", "a", "c", "b", "a"]
freq = {}
for x in data:
freq[x] = freq.get(x, 0) + 1
print(freq)

# 4) сортировка по второму элементу кортежа (по убыванию)

items = [("a", 3), ("b", 1), ("c", 2)]
print(sorted(items, key=lambda t: t[1], reverse=True))

FAQ

Чем отличаются append и extend?

append(x) добавляет один объект как единую сущность; extend(iterable) добавляет элементы итерируемого по одному.

L = [1, 2]; L.append([3, 4])  # [1, 2, [3, 4]]
L = [1, 2]; L.extend([3, 4])  # [1, 2, 3, 4]

Когда использовать sort, а когда sorted?

list.sort() меняет список «на месте» и возвращает None; sorted(iterable) создаёт новый список, исходник сохраняется.

Почему умножение списка с вложенными данными даёт неожиданный результат?

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

Как копировать списки корректно?

Поверхностно: L.copy() или L[:]. Глубоко: copy.deepcopy для вложенных структур.

Как развернуть список?

reverse() меняет порядок «на месте», срез L[::-1] возвращает новую перевёрнутую копию.

Итоги

Списки — фундаментальный инструмент Python. Освойте создание и срезы, грамотно используйте методы добавления/удаления, помните о стабильной сортировке и различии поверхностных и глубоких копий. Учитывайте стоимость операций и выбирайте подходящую структуру данных под задачу. Регулярная практика быстро превращает эти приёмы в автоматизм.

Сообщение Списки в Python: что это такое и как с ними работать появились сначала на Системный блог.

Материал разбирает ветвление в Python для новичков и практиков: от базового if и пары «if–else» до каскада if–elif–else, вложенных условий, тернарного оператора, логических и сравнительных выражений, short-circuit-оценки, а также типичных паттернов и антипаттернов. Вы научитесь писать читаемые проверки, избегать лишней вложенности и выбирать подходящую форму условия под задачу. Поехали!

Зачем нужны условные операторы

Условные операторы позволяют программе принимать решения на основе булевых выражений: если условие истинно — выполняется один блок кода, иначе — другой. В Python почти любые объекты могут участвовать в проверках «на истинность»: пустые контейнеры и ноль трактуются как False, непустые и ненулевые — как True. Это добавляет гибкости: валидируете входные данные, выбираете алгоритм, пропускаете лишние шаги, обрабатываете особые случаи.

• Истинность/ложность (truthy/falsy). False, None, 0, пустые », [], {}, set() считаются ложными; остальное — истинным.
• Ветвление. Позволяет пройти разными путями исполнения.
• Читаемость. Аккуратные условия облегчают поддержку кода.

Базовый if: синтаксис, отступы и блоки

Python использует отступы в 4 пробела для выделения блоков. После двоеточия идёт блок, который выполняется при истинности условия.

# Простой if
temp = 21
if temp >= 20:
  print("Тепло, выходим без куртки")

В блоке можно выполнять несколько операторов. Держите единый стиль и не смешивайте табы с пробелами.

# Несколько выражений в блоке
balance = 500
cost = 200
if balance >= cost:
  balance -= cost
  print("Покупка оформлена, остаток:", balance)

Пара if–else: двоичный выбор

if–else покрывает два взаимоисключающих сценария. Если условие ложно — срабатывает ветка else.

age = 17
if age >= 18:
  msg = "совершеннолетний"
else:
  msg = "несовершеннолетний"
print(msg)

Совет: не пишите лишний else, если он не несёт пользы. Часто достаточно вернуть результат в ветке if и продолжить обычный ход функции.

Каскад if–elif–else: множественный выбор

Когда вариантов больше двух, используйте цепочку if–elif–else. Ветви проверяются сверху вниз до первого совпадения.

code = 404
if code == 200:
  text = "OK"
elif code == 301:
  text = "Moved Permanently"
elif code == 404:
  text = "Not Found"
else:
  text = "Other"
print(text)

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

# Таблица соответствий вместо «лестницы» elif
responses = {200: "OK", 301: "Moved Permanently", 404: "Not Found"}
text = responses.get(code, "Other")

Вложенные условия: когда можно и когда нельзя

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

# Умеренная вложенность
user = {"role": "admin", "active": True}
if user and user.get("active"):
  if user.get("role") == "admin":
    print("Админский доступ открыт")
  else:
    print("Обычный пользователь")

Как уменьшить вложенность:

• Guard-clauses. Сначала обрабатывайте «плохие» случаи и выходите из функции.
• Возврат из веток. return внутри условия делает код прямолинейнее.
• Словарь-свитч. Заменяет длинные цепочки elif.

# Guard-clauses вместо глубины
def can_access(user):
  if not user: return False
  if not user.get("active"): return False
  return user.get("role") == "admin"

Тернарный оператор: компактный if–else

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

# syntax: A if condition else B
age = 20
status = "OK" if age >= 18 else "FAIL"
print(status)

Не злоупотребляйте тернарным выражением: если логика разрастается, обычный if читается лучше.

Логические и сравнительные операторы в условиях

Условия часто комбинируют логику and, or, not и сравнения ==, !=, <, <=, >, >=. В Python есть «цепочки сравнений» и short-circuit-оценка.

• Цепочки сравнений. 0 <= x < 10 эквивалентно двум проверкам с and, но читается лучше.
• Short-circuit. В A and B вторая часть не вычисляется, если A ложна; в A or B — если A истинна.
• in / not in. Проверяет принадлежность элементу в коллекции.

x = 7
if 0 <= x < 10 and x != 5:
  print("x в допустимом диапазоне и не равен 5")

# short-circuit для безопасного доступа
user = None
if user and user.get("email"):
  print("Отправляем письмо")

Не путайте логические операторы с побитовыми: в Python побитовый — &, а логический — and.

Truthy/Falsy и проверка пустых значений

Часто удобнее проверять объект «как есть», без явного сравнения.

# Неудачно (шумно)
if len(items) > 0:
  ...
# Лучше (питоничнее)
if items:
  ...

Отличайте «нет значения» от «нулевого значения». Явно проверяйте None, если ноль и пустая строка допустимы.

# Отличайте None от нуля
count = 0
if count is None:
  print("значение ещё не вычислено")
elif count == 0:
  print("нулевое значение — это нормально")

Паттерны: диапазоны, словари-свитчи, ранний выход, валидация

Пара приёмов для ежедневных задач

Проверка диапазонов и принадлежности

score = 73
if 90 <= score <= 100:
  grade = "A"
elif 75 <= score < 90:
  grade = "B"
elif 60 <= score < 75:
  grade = "C"
else:
  grade = "D"

Словарь вместо каскада elif (таблица соответствий)

def op_add(a, b): return a + b
def op_sub(a, b): return a - b
def op_mul(a, b): return a * b
ops = {"+": op_add, "-": op_sub, "*": op_mul}
op = "*"
result = ops.get(op, lambda a, b: None)(3, 4)

Ранний выход (guard-clauses)

def normalize(email):
  if not email: return None
  email = email.strip()
  if "@" not in email: return None
  return email.lower()

Валидация входных данных

raw_age = "18"
age = int(raw_age) if raw_age.isdigit() else None
if age is None or not (0 <= age <= 120):
  print("Некорректный возраст")

Антипаттерны и типичные ошибки

• Лишняя вложенность. Выталкивайте ранние проверки наверх и используйте словари-свитчи.
• Сравнение с None через ==. Правильно: is / is not.
• Преждевременная оптимизация. Ясность важнее микровыгод.
• Перегруженные условия. Выносите подвыражения в именованные переменные или функции.
• Смешение табов/пробелов. Единый стиль отступов: 4 пробела.
• & вместо and. Побитовые операции не для логики ветвления.

# Вынос сложного условия в именованные предикаты
is_email = lambda s: s and "@" in s
is_corporate = lambda s: s.endswith("@example.com") if s else False
if is_email(email) and not is_corporate(email):
  print("только личные адреса")

Мини-практикум: 4 задания для закрепления

1) Категории по возрасту

age = int(input("Возраст: "))
if age < 0: print("ошибка")
elif age < 12: print("ребёнок")
elif age < 18: print("подросток")
elif age < 65: print("взрослый")
else: print("старше 65")

2) Проверка високосного года

year = int(input("Год: "))
if (year % 400 == 0) or (year % 4 == 0 and year % 100 != 0):
  print("високосный")
else:
  print("обычный")

3) Маршрутизация команды (словарь-свитч)

cmd = input("Команда: ")
def start(): print("стартуем")
def stop(): print("останавливаемся")
def help(): print("команды: start/stop/help")
router = {"start": start, "stop": stop, "help": help}
router.get(cmd, help)()

4) Валидация формы

email = input("Email: ").strip()
password = input("Пароль: ")
if not email or "@" not in email:
  print("некорректный email")
elif len(password) < 8:
  print("короткий пароль")
else:
  print("ок")

Расширения темы: match/case, исключения, логирование

Хотя match/case — сопоставление с образцом, его удобно использовать как альтернативу большому каскаду elif, когда проверяете конкретные значения и формы данных.

# match/case (Python 3.10+)
status = 404
match status:
  case 200: print("OK")
  case 301: print("Moved")
  case 404: print("Not Found")
  case _: print("Other")

Рядом с условными конструкциями идут исключения и логирование: ловите «исключительные» ситуации через try/except, а не через громоздкие if; фиксируйте решения логами, чтобы понимать, почему условие сработало.

import logging; logging.basicConfig(level=logging.INFO)
try:
  price = float(input("Цена: "))
  if price < 0: raise ValueError("отрицательная цена")
  logging.info("ok: %s", price)
except ValueError as e:
  logging.error("ошибка ввода: %s", e)

Чек-лист читаемых условий

• Пишите условия коротко и прямо; разбивайте сложные выражения.
• Используйте цепочки сравнений и in, где это уместно.
• Избегайте глубокой вложенности: применяйте guard-clauses и словари.
• Разгружайте условие именованными булевыми переменными/функциями.
• Проверяйте is None вместо == None.
• Для простых выборов — тернарный оператор, но без фанатизма

Полезные ссылки и итоги

• Документация Python: разделы про выражения и инструкции управления.
• PEP 8: рекомендации по стилю условий и отступов.
• Практика: песочницы и задачники для тренировки логики (Codewars, LeetCode, HackerRank).

Итог: условные операторы — фундамент ветвления программ. Освойте базовый if, двоичный выбор if–else, каскад if–elif–else, применяйте тернарный оператор для коротких присваиваний, держите условия простыми и читаемыми, избегайте глубокой вложенности и используйте «инструменты снижения сложности» — guard-clauses и словари-свитчи. Чем яснее проверки, тем надёжнее и предсказуемее поведение приложения

Сообщение Использование условных операторов (if, elif, else) в Python для управления потоком выполнения программы появились сначала на Системный блог.