Синтаксис Python: шпаргалка с примерами

Синтаксис Python — это правила, по которым пишется код на этом языке: блоки выделяются отступами (в C, Java и JavaScript для этого служат фигурные скобки), переменные не объявляются заранее, а строка кода обычно заканчивается без точки с запятой. Если коротко, программа на Python выглядит так:

name = "мир"
if name:
    print(f"Привет, {name}!")  # → Привет, мир!

Эта шпаргалка собирает весь базовый синтаксис языка программирования Python на одной странице: каждая тема — коротко, с примером и ссылкой на подробную статью. Все примеры проверены на Python 3.12; вывод показан комментарием # →. Если Python ещё не установлен или вы не знаете, как запустить файл, начните с руководства как запустить Python-скрипт.

Отступы и блоки кода

В Python отступ — часть синтаксиса. Тело условия, цикла, функции или класса начинается после двоеточия : и сдвигается вправо. Стандарт — 4 пробела на уровень (рекомендация PEP 8).

for n in range(3):
    if n % 2 == 0:
        print(n, "чётное")
    else:
        print(n, "нечётное")
print("готово")  # вне цикла: без отступа

0 чётное
1 нечётное
2 чётное
готово

Если отступ сбит, программа не запустится:

def greet():
print("Привет")

IndentationError: expected an indented block after function definition on line 1

Не смешивайте табы и пробелы: настройте редактор так, чтобы клавиша Tab вставляла 4 пробела. Пустой блок, который пока нечем заполнить, обозначают словом pass.

Комментарии

Однострочный комментарий начинается с #. Специального синтаксиса для многострочных комментариев нет — пишут несколько строк с #. Строка в тройных кавычках сразу после def или class — это docstring, документация функции.

# Это комментарий
price = 100  # комментарий в конце строки


def area(r):
    """Возвращает площадь круга радиуса r."""
    return 3.14159 * r ** 2


print(area.__doc__)  # → Возвращает площадь круга радиуса r.

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

Переменная создаётся присваиванием, тип определяется значением и может меняться. Имена чувствительны к регистру (name и Name — разные переменные) и по соглашению пишутся в snake_case.

age = 30              # int — целое число
height = 1.75         # float — дробное
name = "Анна"         # str — строка
is_admin = False      # bool — True или False
nothing = None        # None — «нет значения»

print(type(age))      # → <class 'int'>
print(isinstance(height, float))  # → True

a, b = 1, 2           # множественное присваивание
a, b = b, a           # обмен значений без временной переменной
print(a, b)           # → 2 1

Преобразование типов — функциями int(), float(), str(), bool(), list():

print(int("42") + 1)    # → 43
print(str(3.5) + " кг")  # → 3.5 кг
print(bool(0), bool(""), bool([]), bool("0"))  # → False False False True

Последняя строка — правило истинности: ноль, пустая строка, пустые коллекции и None в условиях считаются ложью, всё остальное — истиной.

В Python 3.12–3.15 — 35 ключевых слов (if, for, def, class, return, import и другие): их нельзя использовать как имена переменных. Полный список выводит import keyword; print(keyword.kwlist). Отдельно существуют мягкие ключевые слова (keyword.softkwlist): match, case, _, type, а с Python 3.15 ещё lazy. Они работают как ключевые только в своей конструкции, в остальном коде это обычные имена.

Числа и арифметика

print(7 + 2, 7 - 2, 7 * 2)  # → 9 5 14
print(7 / 2)    # → 3.5   деление всегда даёт float
print(7 // 2)   # → 3     целочисленное деление
print(7 % 2)    # → 1     остаток
print(2 ** 10)  # → 1024  степень
print(-7 // 2)  # → -4    округление вниз, а не к нулю
print(abs(-5), max(3, 8), min(3, 8))  # → 5 8 3
print(1_000_000 + 1)  # → 1000001

Две особенности, о которых спрашивают чаще всего:

print(0.1 + 0.2)   # → 0.30000000000000004
print(round(2.5), round(3.5))  # → 2 4

Дробные числа хранятся в двоичном виде, поэтому возможны крошечные погрешности; для денег используют модуль decimal. А round() округляет «половинки» к ближайшему чётному числу (банковское округление).

Сокращённые операторы: x += 1, x -= 1, x *= 2. Операторов ++ и -- в Python нет. Все операторы языка, включая побитовые, моржовый := и таблицу приоритета, собраны в статье «Операторы в Python».

Строки и f-строки

Строки записываются в одинарных или двойных кавычках, многострочные — в тройных. Строка неизменяема: методы возвращают новую строку.

s = "Python"
print(len(s))         # → 6
print(s[0], s[-1])    # → P n
print(s[0:3])         # → Pyt
print(s.upper(), s.lower())  # → PYTHON python
print("  текст  ".strip())   # → текст
print("a-b-c".replace("-", "+"))  # → a+b+c
print(s.startswith("Py"), "th" in s)  # → True True
print("ab" * 3)       # → ababab

f-строки (с Python 3.6) подставляют значения выражений в фигурных скобках прямо в текст:

name, total = "Анна", 1234567.891
print(f"Клиент: {name}")         # → Клиент: Анна
print(f"Сумма: {total:,.2f}")    # → Сумма: 1,234,567.89
print(f"Доля: {0.256:.1%}")      # → Доля: 25.6%
print(f"{2 + 3 = }")             # → 2 + 3 = 5

После двоеточия внутри скобок идёт формат: .2f — два знака после запятой, , — разделитель тысяч, % — проценты. Знак = (Python 3.8+) выводит и само выражение — удобно для отладки.

Две операции со строками встречаются постоянно: разбить строку на части методом split() и собрать список обратно в строку методом join().

words = "мама мыла раму".split()
print(words)            # → ['мама', 'мыла', 'раму']
print("-".join(words))  # → мама-мыла-раму

Коллекции: списки, кортежи, словари, множества

Тип	Литерал	Изменяемый	Упорядочен	Пример применения
list	[1, 2, 3]	да	да	последовательность элементов
tuple	(1, 2, 3)	нет	да	фиксированная запись, ключ словаря
dict	{"a": 1}	да	порядок вставки	данные «ключ — значение»
set	{1, 2, 3}	да	нет	уникальные элементы

Список (list)

nums = [3, 1, 2]
nums.append(4)
nums.sort()
print(nums, len(nums), nums[-1])  # → [1, 2, 3, 4] 4 4
print(nums[1:3])  # → [2, 3]

Индексы, срезы, методы, сортировку и копирование подробно разбирает статья о списках в Python. Чем append() отличается от insert() и extend(), показано в статье «Как добавить элемент в список».

Элементом списка может быть другой список — так в Python хранят таблицы и матрицы:

grid = [[0] * 3 for _ in range(2)]  # 2 строки по 3 столбца
grid[0][1] = 5
print(grid)  # → [[0, 5, 0], [0, 0, 0]]

Ввод, обход, транспонирование и копирование таких структур — в статье о двумерных списках в Python.

Кортеж (tuple)

point = (10, 20)
x, y = point          # распаковка
print(x + y)          # → 30
single = (5,)         # кортеж из одного элемента — с запятой
print(type(single).__name__)  # → tuple

Кортеж нельзя изменить после создания. Функции часто возвращают несколько значений именно кортежем.

Словарь (dict)

user = {"name": "Анна", "age": 30}
user["city"] = "Казань"
print(user["name"])
print(user.get("email", "—"))  # нет ключа — значение по умолчанию
for key, value in user.items():
    print(key, value)

Анна
—
name Анна
age 30
city Казань

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

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

a = {1, 2, 3, 3}
b = {3, 4}
print(a)          # → {1, 2, 3}
print(a | b)      # → {1, 2, 3, 4}  объединение
print(a & b)      # → {3}           пересечение
print(a - b)      # → {1, 2}        разность
print(len(set([1, 1, 2])))  # → 2   убрать дубликаты

Пустое множество создаётся только как set(): запись {} — это пустой словарь.

Условия: if, elif, else

temp = 18
if temp > 25:
    print("жарко")
elif temp > 15:
    print("тепло")
else:
    print("холодно")
# → тепло

Операторы сравнения: ==, !=, <, >, <=, >=. Логические: and, or, not. Сравнения можно объединять в цепочку, а короткий выбор записать в одну строку:

x = 7
print(0 < x < 10)                        # → True
print("чёт" if x % 2 == 0 else "нечёт")  # → нечёт
print(x > 5 and x != 8, not x)           # → True False

== сравнивает значения, is проверяет, что слева и справа один и тот же объект. Для обычных сравнений нужен ==, а is используют с None: if value is None.

С Python 3.10 есть сопоставление с образцом match/case — удобная замена длинной цепочке elif:

command = "stop"
match command:
    case "start":
        print("Запуск")
    case "stop" | "exit":
        print("Остановка")  # → Остановка
    case _:
        print("Неизвестная команда")

Циклы: for и while

for перебирает элементы любой коллекции, range() генерирует последовательность чисел:

for i in range(1, 4):     # 1, 2, 3 — правая граница не входит
    print(i, end=" ")
print()
for i in range(10, 0, -3):  # с шагом
    print(i, end=" ")
print()

1 2 3
10 7 4 1

while выполняется, пока условие истинно. break прерывает цикл, continue переходит к следующей итерации:

n = 0
while True:
    n += 1
    if n % 2 == 0:
        continue
    if n > 5:
        break
    print(n, end=" ")
print()

1 3 5

Номер элемента в цикле даёт enumerate(), а параллельный обход двух списков — zip():

names = ["Анна", "Иван"]
scores = [95, 88]
for i, name in enumerate(names, start=1):
    print(i, name)
for name, score in zip(names, scores):
    print(f"{name}: {score}")

1 Анна
2 Иван
Анна: 95
Иван: 88

Функции

Функция объявляется словом def, результат возвращается через return. Без return функция возвращает None.

def greet(name, greeting="Привет"):
    """Параметр greeting необязательный — у него есть значение по умолчанию."""
    return f"{greeting}, {name}!"


print(greet("Анна"))                      # → Привет, Анна!
print(greet("Иван", greeting="Здравствуй"))  # → Здравствуй, Иван!


def min_max(numbers):
    return min(numbers), max(numbers)     # вернётся кортеж


low, high = min_max([4, 9, 1])
print(low, high)  # → 1 9

Произвольное число аргументов принимают *args (кортеж позиционных) и **kwargs (словарь именованных). Аннотации типов не обязательны и не проверяются при запуске, но помогают редактору и читателю:

def total(*args: float, **kwargs: str) -> float:
    print(kwargs)
    return sum(args)


print(total(1, 2, 3.5, unit="кг"))

{'unit': 'кг'}
6.5

Как аннотировать коллекции, необязательные значения и свои типы и проверять код в mypy — в статье «Аннотации типов и typing в Python».

Важно: не используйте изменяемые значения по умолчанию вроде def f(items=[]): список создаётся один раз и копит данные между вызовами. Пишите items=None и создавайте список внутри функции.

Асинхронные функции: async и await

Функция, объявленная через async def, возвращает корутину. Внутри неё await ждёт результат другой асинхронной операции, не блокируя остальные задачи, а запускает всё asyncio.run():

import asyncio


async def double(n):
    await asyncio.sleep(0.1)  # пауза, во время которой могут работать другие задачи
    return n * 2


print(asyncio.run(double(21)))  # → 42

Когда asyncio действительно ускоряет программу и как запускать задачи параллельно, разобрано в статье «async и await в Python».

lambda-функции

lambda — короткая безымянная функция из одного выражения. Чаще всего её передают как аргумент key в sorted(), min(), max() или в map():

square = lambda x: x ** 2
print(square(5))  # → 25

people = [("Анна", 31), ("Иван", 19), ("Олег", 25)]
print(sorted(people, key=lambda p: p[1]))  # → [('Иван', 19), ('Олег', 25), ('Анна', 31)]
print(list(map(lambda x: x * 10, [1, 2, 3])))  # → [10, 20, 30]

Если функция сложнее одного выражения или используется много раз, объявите её через def — так её проще читать и отлаживать.

Генераторы списков, словарей и множеств

Comprehension — компактный способ построить коллекцию из другой коллекции, с фильтром или без:

nums = [1, 2, 3, 4, 5]
print([n * n for n in nums])            # → [1, 4, 9, 16, 25]
print([n for n in nums if n % 2])       # → [1, 3, 5]
print({n: n * n for n in nums[:3]})     # → {1: 1, 2: 4, 3: 9}
print({n % 3 for n in nums})            # → {0, 1, 2}
print(sum(n * n for n in nums))         # → 55

Последняя строка — генераторное выражение: в отличие от генератора списка, оно не строит список в памяти и отдаёт элементы по одному. Его можно передавать прямо в sum(), max(), any(), "".join(). Так же лениво работают функции с yield — подробнее в статье «Генераторы и yield в Python».

Исключения: try, except, finally

Ошибки во время выполнения — это исключения. Их перехватывают конструкцией try/except:

def safe_div(a, b):
    try:
        result = a / b
    except ZeroDivisionError:
        print("Делить на ноль нельзя")
        return None
    else:
        return result          # выполняется, если ошибки не было
    finally:
        print("проверка завершена")  # выполняется всегда


print(safe_div(10, 2))
print(safe_div(1, 0))

проверка завершена
5.0
Делить на ноль нельзя
проверка завершена
None

Своё исключение выбрасывают через raise: raise ValueError("возраст не может быть отрицательным"). Перехватывайте конкретные типы ошибок, а не голый except:. Подробно — в статье о try/except в Python, а как читать сообщение об ошибке — в разборе traceback.

Классы и объекты

Класс описывает данные и поведение объектов. Метод __init__ вызывается при создании объекта, self — ссылка на сам объект.

class Dog:
    species = "собака"           # атрибут класса — общий для всех

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

    def bark(self):
        return f"{self.name}: Гав!"

    def __str__(self):
        return f"{self.name}, {self.age} г."


class Puppy(Dog):                # наследование
    def bark(self):
        return f"{self.name}: Тяв!"


rex = Dog("Рекс", 3)
print(rex.bark())   # → Рекс: Гав!
print(rex)          # → Рекс, 3 г.
print(Puppy("Бим", 1).bark())  # → Бим: Тяв!

Для классов, которые в основном хранят данные, есть декоратор @dataclass: он сам создаёт __init__, __repr__ и сравнение.

from dataclasses import dataclass


@dataclass
class Point:
    x: int
    y: int = 0


print(Point(3))                 # → Point(x=3, y=0)
print(Point(1, 2) == Point(1, 2))  # → True

Модули и import

Модуль — это файл .py. Встроенные модули стандартной библиотеки и установленные пакеты подключаются через import:

import math
from datetime import date
from collections import Counter as Cnt

print(math.sqrt(16))           # → 4.0
print(date(2026, 1, 1).year)   # → 2026
print(Cnt("abca")["a"])        # → 2

• import math — импорт модуля, обращение через math.sqrt;
• from datetime import date — импорт конкретного имени;
• as — псевдоним, например import numpy as np.

Сторонние пакеты сначала ставят через pip install. Если при импорте появляется ModuleNotFoundError, пакет не установлен в текущее окружение — разбор причин в статье про ModuleNotFoundError.

Чтобы код в файле выполнялся только при прямом запуске, а не при импорте, используют проверку:

def main():
    print("Запущено как скрипт")


if __name__ == "__main__":
    main()  # → Запущено как скрипт

Ввод и вывод

print() выводит значения, input() читает строку с клавиатуры. input() всегда возвращает строку, поэтому числа нужно преобразовать:

name = input()        # ввод: Анна
age = int(input())    # ввод: 30
print("Имя:", name, "возраст:", age)    # → Имя: Анна возраст: 30
print(name, age, sep=" | ")             # → Анна | 30
print("без перевода строки", end="")
print("!")                              # → без перевода строки!

В input() можно передать подсказку: input("Ваше имя: "). Несколько чисел в одной строке читают так: a, b = map(int, input().split()).

Работа с файлами — через open() в блоке with, который сам закроет файл. Указывайте кодировку явно, иначе на Windows кириллица может прочитаться неверно:

with open("notes.txt", "w", encoding="utf-8") as f:
    f.write("первая строка\n")
    f.write("вторая строка\n")

with open("notes.txt", encoding="utf-8") as f:
    for line in f:
        print(line.strip())

первая строка
вторая строка

Режимы: "r" — чтение (по умолчанию), "w" — запись с очисткой файла, "a" — дописывание в конец.

Основные команды Python для начинающих

«Командами» в Python обычно называют встроенные функции и инструкции языка. Вот те, что нужны с первого дня:

Функция / инструкция	Что делает
print(x)	вывести значение
input()	прочитать строку с клавиатуры
len(x)	длина строки или коллекции
type(x), isinstance(x, T)	узнать или проверить тип
int(), float(), str()	преобразовать тип
range(start, stop, step)	последовательность чисел для цикла
sum(), min(), max()	сумма, минимум, максимум
sorted(x)	отсортированная копия
enumerate(x), zip(a, b)	номер элемента; параллельный обход
round(x, n), abs(x)	округление, модуль числа
open(path)	открыть файл
help(x), dir(x)	справка и список атрибутов объекта
import, def, class	подключить модуль, объявить функцию и класс
if, for, while, try	условие, циклы, обработка ошибок

help() и dir() удобно вызывать в интерактивной консоли: запустите python (на Windows также py, на macOS и Linux — python3) и наберите, например, help(str.split). Полная справка по языку — на docs.python.org, где есть и перевод на русский; что в нём переведено и как читать документацию офлайн — в статье «Документация Python на русском».

Частые ошибки новичков

• IndentationError — сбиты отступы или смешаны табы с пробелами.
• SyntaxError — забыто двоеточие после if/for/def, не закрыта скобка или кавычка.
• = вместо == в условии: if x = 5 — синтаксическая ошибка; сравнение пишется ==.
• TypeError: can only concatenate str (not "int") to str — сложение строки с числом; используйте f-строку или str().
• NameError: name 'x' is not defined — опечатка в имени или переменная используется до присваивания.
• Число из input() — без int() вы получите строку: "2" + "3" даст "23".
• Изменяемый аргумент по умолчанию и копирование списка присваиванием — две классические ловушки ссылок.

Частые вопросы

Что означает SyntaxError: invalid syntax?

Python не смог разобрать строку и остановился до запуска программы. Обычные причины: забытое двоеточие, незакрытая скобка или кавычка, код в стиле Python 2. Ищите ошибку в указанной строке и в строке над ней. Начиная с Python 3.10 сообщения точнее и часто подсказывают, чего не хватает:

    if x > 5
            ^
SyntaxError: expected ':'

Нужна ли точка с запятой в конце строки?

Нет, инструкция заканчивается переводом строки. Точкой с запятой можно разделить несколько инструкций в одной строке (a = 1; b = 2), но PEP 8 так писать не рекомендует: одна инструкция — одна строка.

Как перенести длинную строку кода?

Внутри круглых, квадратных и фигурных скобок строку можно переносить свободно. Соседние строковые литералы склеиваются автоматически. Обратный слеш \ в конце строки тоже переносит код, но PEP 8 советует предпочитать скобки.

total = (1 + 2 + 3
         + 4 + 5)
message = ("Первая часть строки, "
           "вторая часть строки")
print(total)    # → 15
print(message)  # → Первая часть строки, вторая часть строки

Как проверить синтаксис файла, не запуская его?

Скомпилируйте файл в байт-код: python -m py_compile script.py (на Windows можно py -m py_compile script.py, на macOS и Linux — python3 -m py_compile script.py). Если ошибок нет, команда ничего не выводит; при ошибке покажет SyntaxError с номером строки. Редакторы вроде VS Code с расширением Python подсвечивают такие ошибки сразу.

Чем синтаксис Python 3 отличается от Python 2?

Код из старых учебников часто написан для Python 2 и в Python 3 не запускается. Главные отличия: print — функция и требует скобок (print("hi")), / всегда возвращает дробное число, input() возвращает строку, а строки по умолчанию в Unicode. Python 2 не поддерживается с 2020 года, учите только Python 3.

Итог

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