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

Это статья для тех, кто только начинает изучать Python и хочет разобраться, как устроен язык. У Python короткий и понятный синтаксис: код на нём часто читается почти как обычный английский текст.

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

• Что такое команды Python и как они работают
• Базовые команды Python
• Переменные и основные типы данных
• Условные конструкции в Python
• Циклы в Python
• Функции в Python: синтаксис и параметры
• Встроенные функции Python и их использование
• Структуры данных и команды для работы с ними
• Что изучать дальше

Как устроены команды в Python

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

Обычно одна команда занимает одну строку. Например:

print("Привет!")

Если запустить этот код, на экране появится:

Привет!

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

В чём разница между командами, операторами и функциями

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

Возьмём для примера простую строчку кода:

print(x + 5)

Здесь сразу есть и команда, и оператор, и функция. Разберём, что есть что.

Команда (инструкция) — это вся строчка целиком. Это законченное действие, которое Python выполнит за один шаг: «Вывести на экран результат сложения x и 5».

Оператор — это знак или короткое ключевое слово внутри команды, которое выполняет одно конкретное действие с данными. В нашем примере оператор + складывает два числа.

Функция — это готовый кусок кода, который умеет что-то делать и которому можно дать имя. В нашем примере print — встроенная функция Python, которая выводит данные на экран. Чтобы её использовать, не нужно расписывать «возьми текст, открой консоль, отправь туда символы» — достаточно написать print(...) и передать в скобках то, что вы хотите вывести.

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

Как Python выполняет команды

Когда вы запускаете скрипт, за дело берётся интерпретатор. Он не выполняет ваш код буквально — сначала он переводит его в форму, понятную для машины, и только потом запускает. Этот процесс идёт в четыре шага:

• Токенизация. Интерпретатор разбивает код на маленькие смысловые куски: числа, имена переменных, операторы, ключевые слова. Это похоже на то, как человек, читая фразу, мысленно делит её на слова.
• Проверка синтаксиса. Python смотрит, всё ли записано по правилам языка: на месте ли двоеточия, закрыты ли скобки, верно ли расставлены отступы. Если нет — программа не запустится, и вы увидите ошибку SyntaxError.
• Компиляция в байт-код. Код переводится в промежуточный формат — байт-код, который ближе к языку машины, но ещё не сам машинный код. Это как черновик, по которому интерпретатору быстрее работать, чем по исходному тексту.
• Выполнение. Виртуальная машина Python читает байт-код и выполняет его, команду за командой.

Команды выполняются сверху вниз — в том порядке, в котором они записаны. Этот порядок можно изменить только тремя способами: условиями — if пропускает блок, если проверка не прошла; циклами — for и while повторяют один и тот же блок несколько раз; и функциями — вызов функции «перепрыгивает» в её тело, выполняет код там и возвращается обратно.

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

print(name)       # NameError: переменной name ещё не существует
name = "Анна"

Правильно — наоборот:

name = "Анна"
print(name)       # Анна

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

Базовые команды Python

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

Вывод данных — команда print()

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

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

Например, напишите код:

print("Привет, мир!")

При запуске в консоли появится сообщение:

Привет, мир!

В print() можно передавать почти любые данные, которые Python сможет превратить в текст:

print("Текст")           # Строки
print(42)                # Числа
print(3.14)              # Дробные числа
print(True)              # Логические значения
print(5 + 3 * 2)         # Результаты вычислений → 11

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

name = "Анна"
age = 25
print("Меня зовут", name, ", мне", age, "лет")
# Вывод: Меня зовут Анна , мне 25 лет

Чаще, впрочем, такие сообщения собирают через f-строки — это удобнее, чем перечислять значения через запятую. Перед кавычками ставится буква f, а переменные подставляются в фигурных скобках:

name = "Анна"
age = 25
print(f"Меня зовут {name}, и мне {age} лет.")
# Меня зовут Анна, и мне 25 лет.

F-строки позволяют расставлять знаки препинания и не следить за пробелами — это самый удобный способ собрать сообщение из текста и значений.

У print() есть параметры, которые меняют, как именно функция выводит данные. Два часто используемых — sep и end.

sep задаёт разделитель между значениями. По умолчанию это пробел, но можно поставить что угодно — запятую, вертикальную черту, любой текст:

print("Python", "Java", "C++")              # Python Java C++
print("Python", "Java", "C++", sep=" | ")   # Python | Java | C++
print("2026", "05", "21", sep="-")          # 2026-05-21

end указывает, что добавить в конце вывода. По умолчанию это перенос строки \n — поэтому каждый следующий print() начинается с новой строки. Если задать end=" ", два вывода окажутся на одной строке:

print("Первая часть", end=" --- ")
print("Вторая часть")
# Первая часть --- Вторая часть

Читайте также:

Функция print() в Python: аргументы и применение

Ввод данных — команда input()

input() нужна, когда программа должна получить что-то от пользователя: имя, возраст, выбор из меню, поисковый запрос и так далее. Как только выполнение доходит до этой строки, программа останавливается и ждёт, пока пользователь введёт ответ и нажмёт Enter. После этого работа продолжается, а введённая строка попадает в переменную.

Например, можно спросить у пользователя имя:

name = input("Как вас зовут? ")
print("Привет,", name)

Текст в скобках — это подсказка, которая появится в консоли перед вводом. Она необязательна: можно написать просто input(), но тогда пользователь увидит пустой курсор и не поймёт, чего от него хотят.

Результат input() — всегда строка. Даже если пользователь введёт 25, Python будет работать с этим значением как с текстом. Чтобы совершать с этими данными какие-то действия как с числами, их понадобится преобразовать: например, через int() для целых чисел или float() для дробных.

a = int(input(" число: ")) # Преобразуем введённое число в числовой тип данных

Если пользователь ничего не ввёл и просто нажал Enter, получится пустая строка "". Это тоже значение: его можно проверить и попросить пользователя ввести данные ещё раз.

Определение типа данных — type()

У каждого значения в Python есть тип — Python запоминает, чем именно является то, что лежит в переменной: числом, текстом, списком или чем-то ещё. От типа зависит, какие действия с этим значением вообще возможны: числа можно складывать и умножать, строки — соединять и резать, списки — перебирать.

Основные типы данных, с которыми часто сталкиваются изучающие Python:

• int — целое число (5, −12, 1000);
• float — дробное число (3.14, −0.5, 2.0);
• str — строка, то есть текст в кавычках ("Анна", "42");
• bool — логическое значение, может быть только True или False;
• list — список, упорядоченный набор значений ([1, 2, 3]);
• dict — словарь, набор пар «ключ — значение» ({"name": "Анна"}).

Чтобы узнать, какого типа конкретное значение или переменная, используется функция type():

print(type(5))           # <class 'int'>
print(type(3.14))        # <class 'float'>
print(type("Анна"))      # <class 'str'>
print(type(True))        # <class 'bool'>
print(type([1, 2, 3]))   # <class 'list'>

Чаще всего к type() обращаются при отладке — когда программа выдаёт ошибку или ведёт себя не так, как задумано. Самая частая ситуация: значение выглядит как число, а на самом деле хранится как строка. Так бывает, например, после input() — оттуда всё приходит текстом, даже если пользователь ввёл цифры.

Допустим, вы написали программу, которая показывает возраст пользователя через пять лет. Запустим её и попробуем ввести значение:

age = input("Сколько вам лет? ")  # Пользователь ввёл 25
print("Через 5 лет вам будет", age + 5)

TypeError: can only concatenate str (not "int") to str

При запуске Python выдаст ошибку, которая явно указывает на то, что программа пытается склеить строку и число. Но если ошибка кажется непонятной, можно сначала проверить тип type():

print(type(age))   # <class 'str'>

Видим: в переменной не число, а строка. Теперь можем преобразовать введённый текст в числовой тип данных, чтобы программа работала как задумано:

age = int(input("Сколько вам лет? "))
print("Через 5 лет вам будет", age + 5)
# Через 5 лет вам будет 30. Код выполняется правильно.

По мере того как вы будете писать более сложные программы, type() пригодится не только с input(), но и при работе с данными из файлов, API и баз данных для проверки типа данных.

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

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

Как создавать переменные в Python

Переменная — это именованное место в памяти, куда программа кладёт значение, чтобы потом к нему обращаться. В Python переменную создают через знак =: слева имя, справа значение.

name = "Анна"        # Строка
age = 25             # Целое число
height = 1.68        # Дробное число
is_student = True    # Логическое значение

Имя переменной должно подчиняться нескольким правилам:

• имя может содержать латинские буквы, цифры и нижние подчёркивания;
• имя не может начинаться с цифры;
• регистр букв имеет значение: myVar и myvar — разные переменные.
• нельзя использовать ключевые слова Python: if, for, while, def и так далее.

В Python принят стиль snake_case: строчные буквы, слова разделены подчёркиваниями — user_age, total_price, is_admin. Это часть PEP 8 — официального руководства по стилю кода Python, которому следуют все разработчики, чтобы их код было удобно читать друг другу.

Хорошее имя сразу сообщает, что лежит в переменной:

# Так непонятно:
x = 25
a = "Анна"
t = 1500

# Так понятно:
user_age = 25
user_name = "Анна"
total_price = 1500

Если вы вернётесь к коду через месяц, разница между этими двумя стилями окажется огромной. Имена x и t имеет смысл оставлять только для очень коротких циклов и временных значений.

​​Переменную нужно создать до использования. Если обратиться к имени, которое Python ещё не видел, программа остановится с ошибкой NameError. Та же ошибка возникнет при опечатке в имени:

user_name = "Анна"
print(user_nme)
# NameError: name 'user_nme' is not defined

Читайте также:

Переменные в Python: что это такое и какие они бывают

Основные типы данных: int, float, str, bool

Тип данных показывает, что именно хранится в переменной. Python по-разному работает с разными типами: числа он складывает как числа, строки — склеивает как текст, а значения True и False использует в проверках. На старте достаточно знать четыре базовых типа:

• int — целые числа: 0, 7, −15, 42. Подходят для количеств, возраста, номеров попыток.
• float — дробные числа: 3.14, −0.5, 199.90. Дробная часть отделяется точкой, а не запятой.
• str — строки, то есть текст в одинарных или двойных кавычках: "Привет", 'Москва'. Для Python 42 и "42" — разные значения: первое можно сложить с числом, второе — только с другой строкой.
• bool — логические значения, True или False. На них держится вся логика программы: условия, проверки, циклы. True и False чаще всего получаются как результат сравнения: age >= 18 вернёт True, если возраст подходит, и False, если нет.

Читайте также:

Типы данных в Python для начинающих: какие бывают и как с ними работать

Команды для преобразования типов данных

Иногда значение нужно перевести из одного типа в другой — например, превратить строку, полученную через input(), в число. Это называют преобразованием типов. Для каждого базового типа в Python есть своя функция: int(), float(), str(), bool().

Преобразование в целое число: int()

Функция int() превращает значение в целое число, если это возможно.

print(int(3.14))      # 3
print(int("42"))      # 42
print(int(True))      # 1

Если преобразовать дробное число через int(), Python отбросит дробную часть. Он не округлит число, а просто уберёт всё после точки. Например, при преобразовании 3,99 вы получите не 4, а 3.

Преобразование в дробное число: float()

Функция float() превращает значение в дробное число.

print(float(5))       # 5.0
print(float("3.14"))  # 3.14
print(float("10"))    # 10.0

Это полезно, когда пользователь вводит не целое число, а, например, вес, рост, цену или температуру.

Преобразование в строку: str()

Функция str() превращает значение в строку.

print(str(123))   # "123"
print(str(3.14))  # "3.14"
print(str(True))  # "True"

Чаще всего str() нужна, когда число требуется склеить с текстом. Без преобразования Python выдаст ошибку:

age = 25
print("Мне " + age + " лет")
# TypeError: can only concatenate str (not "int") to str

print("Мне " + str(age) + " лет")
# Мне 25 лет

Преобразование в логическое значение: bool()

bool() превращает значение в True или False. Правило простое: пустые значения — False, непустые — True.

print(bool(0))        # False
print(bool(42))       # True
print(bool(""))       # False — пустая строка
print(bool("Hello"))  # True
print(bool([]))       # False — пустой список

Это пригождается в проверках. Например, чтобы понять, ввёл ли пользователь хоть что-то, можно написать так:

answer = input("Введите имя: ")
if answer:
    print("Спасибо!")
else:
    print("Вы ничего не ввели.")

Обратите внимание: явный bool(answer) здесь не нужен — if сам приводит значение к булевому. Это идиоматичный способ записи в Python.

Важно! Строка "False" — это непустая строка. То есть bool("False") вернёт True, потому что Python смотрит не на содержимое, а на то, есть ли в строке хоть один символ. Это легко проверить:

print(bool("False"))  # True

Условные конструкции в Python

До сих пор наши программы выполнялись построчно — Python последовательно проходил все команды сверху вниз. Но в реальном коде часто нужно, чтобы программа выбирала, что делать дальше, в зависимости от ситуации: ввёл пользователь нужный пароль или нет, есть ли товар в наличии, исполнилось ли клиенту 18 лет. Для таких развилок в Python есть условные конструкции. Разберём основные из них.

Читайте также:

Условные операторы в Python: от простых «если» до вложенных конструкций

Команда if и базовый синтаксис

Команда if нужна, когда программа должна принять решение: выполнить часть кода или пропустить её. После if пишут условие — проверку, на которую Python отвечает True или False. Если результат True, Python выполняет блок кода ниже. Если результат False, этот блок пропускается.

Самая простая форма условия выглядит так:

age = 20

if age >= 18:
    print("Доступ разрешён")

Здесь важны три вещи: ключевое слово if, двоеточие в конце строки и отступ перед print().

Двоеточие говорит Python, что дальше начинается блок — одна или несколько строк, которые относятся к этому условию. Блок должен быть выполнен в том случае, если условие в if выполняется.

Отступ показывает, какие именно строки входят в блок. В Python нет фигурных скобок { }, как в JavaScript или C, — границы блока определяются именно отступом. По соглашению PEP 8 используют четыре пробела.

Если отступа не будет, Python остановит программу с ошибкой:

if age >= 18:
print("Доступ разрешён")
# IndentationError: expected an indented block

Конструкция if-else

Одиночная if либо выполняет блок, либо пропускает его. Часто нужно второе условие — чтобы программа выполняла разный код в зависимости от того, истинно условие или ложно.

Для этого к if добавляют else:

password = input("Введите пароль: ")
if password == "qwerty123":
    print("Вход выполнен")
else:
    print("Неверный пароль")

После else не пишут условие — этот блок выполняется во всех случаях, когда условие в if оказалось False.

В отличие от одиночной if, конструкция if-else гарантированно выполнит ровно одну из двух веток. Программа не может «проскочить мимо» обеих: либо первая, либо вторая.

Конструкция if-elif-else

Иногда двух веток мало — нужно перебрать несколько вариантов. Например, поставить оценку в зависимости от баллов: 90 и выше — «Отлично», от 75 — «Хорошо», от 60 — «Удовлетворительно», ниже — «Неудовлетворительно». Для таких случаев между if и else ставят elif.

elif — это сокращение от else if («иначе если»). Python проверяет условия сверху вниз и выполняет первый блок, где условие оказалось истинным. После этого остальные условия уже не проверяются, даже если они тоже подошли бы.

score = 85

if score >= 90:
    grade = "Отлично"
elif score >= 75:
    grade = "Хорошо"
elif score >= 60:
    grade = "Удовлетворительно"
else:
    grade = "Неудовлетворительно"

print(grade)

В этом примере score равен 85. Первое условие score >= 90 ложно — Python идёт дальше. Второе условие score >= 75 истинно — в grade попадает "Хорошо", и Python пропускает остальные elif и else. Блок else выполнится только тогда, когда не подошло ни одно условие выше.

Важный момент: порядок условий имеет значение. Если в примере с оценками первой проверкой поставить score >= 60, то 85 подойдёт под него — и Python выдаст «Удовлетворительно», даже не дойдя до score >= 75. Учитывайте это при написании кода.

Циклы в Python: автоматизация повторяющихся действий

Циклы избавляют от необходимости писать одну и ту же команду много раз — например, вместо того чтобы копировать строку с print() десять раз подряд, можно записать её один раз и попросить Python повторить десять раз. Это удобно везде, где действие нужно сделать многократно: вывести каждый элемент списка, посчитать сумму чисел, попросить пользователя ввести корректные данные. В Python два вида циклов — for и while. Разберём каждый из них.

Читайте также:

Циклы в Python: как работают и какие бывают

Цикл for

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

fruits = ["яблоко", "банан", "апельсин"]
for fruit in fruits:
    print(fruit)

# яблоко
# банан
# апельсин

Здесь fruits — список с фруктами, а fruit — переменная, которая на каждом шаге принимает очередное значение из списка. После последнего элемента fruits цикл заканчивается, и Python продолжает выполнение со следующей строки.

То же самое работает и со строкой — тогда Python будет по очереди брать не слова, а отдельные символы:

word = "Python"
for letter in word:
    print(letter)
# P
# y
# t
# h
# o
# n

Если нужно просто повторить действие фиксированное число раз — без готового списка, — используют range(). Это встроенная функция, которая создаёт диапазон чисел: range(5) — числа от 0 до 4, range(1, 11) — от 1 до 10. Цикл for i in range(5): повторит свой блок ровно пять раз, а переменная i пройдёт значения 0, 1, 2, 3, 4 — это удобно, когда нужно знать номер шага.

Читайте также:

Как работает функция range() в Python: от базовых циклов до списковых выражений

Цикл while

Цикл while используют, когда заранее неизвестно, сколько раз действие нужно повторить. Цикл работает, пока условие остаётся истинным. Посмотрим на примере:

count = 1
while count <= 5:
    print(count)
    count += 1
# 1
# 2
# 3
# 4
# 5

Python сначала проверяет count <= 5. Если результат True, выполняется блок с отступом: выводится значение count и увеличивается на 1. Затем условие проверяется снова — и так до тех пор, пока count не станет равным 6. Запись count += 1 — это сокращение от count = count + 1, такой синтаксис используют для удобства.

Строка count += 1 критически важна. Без неё count навсегда осталась бы равна 1, условие всегда бы выполнялось, и программа зависла бы, бесконечно выводя единицу.

Функции в Python: синтаксис и параметры

Функции — это именованные блоки кода, которые выполняют конкретную задачу. Они избавляют разработчиков от необходимости писать один и тот же код в нескольких местах программы: вы описываете действие один раз, а дальше вызываете его по имени. Со встроенными функциями вы уже работали — print(), len(), type() — но можно создавать и свои, для решения конкретных задач.

Общий синтаксис

В Python функцию объявляют через ключевое слово def:

def say_hello():
    print("Привет, мир!")

Разберём, что здесь происходит:

• def — ключевое слово, которое начинает объявление функции.
• say_hello — имя функции. По нему мы потом будем её вызывать. Имена функций пишут в snake_case, как и переменные.
• () — скобки для параметров, то есть тех данных, которые функция принимает на входе. Здесь параметров нет, но скобки всё равно обязательны.
• : и отступ — обозначают тело функции, по тому же правилу, что и блок внутри if или цикла.

Важно: при выполнении строки def say_hello(): Python только запоминает функцию — ничего внутри неё пока не выполняется. Чтобы код запустился, функцию нужно вызвать — написать её имя со скобками:

say_hello() # Привет, мир!

Одну и ту же функцию можно вызывать сколько угодно раз:

say_hello()
say_hello()
say_hello()

# Привет, мир!
# Привет, мир!
# Привет, мир!

Читайте также:

Функции в Python: исчерпывающий гайд

Параметры функции

Функция из прошлого раздела умела говорить только одно — «Привет, мир!». На практике гораздо чаще нужны функции, которые работают с разными данными: поздороваться с любым именем, посчитать площадь любого прямоугольника, повторить любую фразу. Для этого функциям передают параметры — переменные, значения которых задаются при вызове.

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

greet("Анна")     # Привет, Анна!
greet("Максим")   # Привет, Максим!

Здесь name — параметр функции, переменная, которая получит значение при каждом вызове. А "Анна" и "Максим" — аргументы: конкретные значения, которые передаются функции в момент вызова. Различие чисто терминологическое, но именно так эти понятия используют в документации и обсуждениях: параметр — это имя в объявлении функции, аргумент — фактическое значение при вызове.

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

def rectangle_area(width, height):
    print(f"Площадь прямоугольника: {width * height}")

rectangle_area(5, 3)
# Площадь прямоугольника: 15

Порядок важен: width получает первое значение (5), height — второе (3). Если функция принимает разнородные данные (например, имя и возраст), перепутанный порядок может привести к нелепому результату.

Чтобы не зависеть от порядка перечисления, аргументы можно передавать по имени: rectangle_area(height=3, width=5) — тогда Python поймёт, что куда, независимо от позиции.

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

def repeat_phrase(phrase, times=3):
    for i in range(times):
        print(phrase)

repeat_phrase("Python")
# Python
# Python
# Python

repeat_phrase("Python", 5)
# Python (выведется пять раз)

В первом вызове аргумент для times не передан, и параметр принимает значение по умолчанию — 3. Во втором — переданная 5 перекрывает значение по умолчанию. Одно правило: параметры со значениями по умолчанию ставят в конце списка параметров — после обычных. Иначе Python выдаст SyntaxError.

return: возвращаемые значения

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

Напишем простую функцию:

def add(a, b):
    return a + b

result = add(5, 3)
print(result)   # 8

print(add(2, 3) * 4) # 20 — результат сразу используется в выражении

Здесь результат функции add используется в двух print().

Если в функции нет return, она всё равно возвращает специальное значение None. Оно означает «ничего» или «нет значения»:

def just_print(x):
    print(x)

value = just_print(42)   # Выведет 42
print(value)             # None

Напишем функцию посложнее, которая сможет посчитать количество гласных букв в строке:

def count_vowels(text):
    vowels = "aeiouаеёиоуыэюяAEIOUАЕЁИОУЫЭЮЯ" # Явно указываем гласные буквы
    count = 0
    for char in text:
        if char in vowels:
            count += 1
    return count

print(count_vowels("Привет, мир!"))   # 3
print(count_vowels("Hello world"))    # 3

Всё сработало. Подсчёт прошёл удачно.

Встроенные функции Python и их применение

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

range(): создание последовательности чисел

range() создаёт последовательность чисел. Чаще всего её используют вместе с циклом for, когда нужно повторить действие несколько раз.

Например, если написать range(5), Python даст числа от 0 до 4:

for i in range(5):
    print(i)

#0
#1
#2
#3
#4

Числа начинаются с 0, а верхняя граница диапазона не включается.

У range() есть три основных варианта записи:

range(stop)
range(start, stop)
range(start, stop, step)

Рассмотрим параметры функции:

• start — число, с которого начинается последовательность (по умолчанию 0);
• stop — число, до которого считать (не включая его);
• step — шаг между элементами (по умолчанию 1).

Несколько примеров для закрепления:

print(list(range(3)))        # [0, 1, 2]
print(list(range(3, 6)))     # [3, 4, 5]
print(list(range(1, 10, 3))) # [1, 4, 8]

Можно указать отрицательный шаг, чтобы идти в обратную сторону:

for i in range(5, 0, -1):
    print(i, end=" ") # Выведем числа в одну строку 

Результат:

#5 4 3 2 1

Читайте также:

Как работает функция range() в Python: от базовых циклов до списковых выражений

round(): округление чисел

Функция round() округляет число. Её используют, когда дробный результат вычислений нужно сократить до удобного для отображения вида: округлить цену до копеек, процент — до десятых, координату — до пятого знака.

Например, округлим число:

print(round(3.14159))

Если передать только одно число, Python округлит его до ближайшего целого. Здесь это число 3.

Можно указать, сколько знаков оставить после точки:

print(round(3.14159, 2))   # 3.14
print(round(3.14159, 4))   # 3.1416

Важный нюанс, который может привести к ошибкам: в Python используется так называемое банковское округление — половина округляется к ближайшему чётному числу, а не всегда вверх, как учили в школе. Поэтому round(0.5) даёт 0, round(1.5) — 2, round(2.5) — снова 2, а не 3. Это не баг, а официальный стандарт IEEE 754: при массовых вычислениях такое округление меньше искажает средние значения. Если нужно обычное «школьное» округление, импортируйте библиотеку math и используйте math.ceil() для округления вверх или math.floor() для округления вниз.

Читайте также:

Округление в Python: выбираем лучший способ

sum(): сложение чисел

Функция sum() складывает все числа в последовательности: списке, кортеже или диапазоне range(). Это базовый инструмент для подсчёта итогов: сумма покупок в чеке, общее число просмотров за неделю, баллы по дисциплинам.

Напишем код:

numbers = [10, 20, 30, 40]

print(sum(numbers))

Python берёт все числа из списка numbers, складывает их и выводит результат:

100

У sum() есть второй аргумент — начальное значение, с которого начинается сложение. Например, можно прибавить «бонус» к сумме покупок:

prices = [100, 200, 300] print(sum(prices, 50)) 
# 650 — к сумме 600 прибавилось начальное 50

min() и max(): минимальное и максимальное значение

min() находит самое маленькое значение, а max() — самое большое. Проверим на практике:

numbers = [5, 2, 8, 1, 9]

print(min(numbers))
print(max(numbers))

Результат:

1
9

Эти функции можно использовать не только со списком, но и с несколькими отдельными значениями:

print(min(10, 20, 5))
print(max(10, 20, 5))

Результат:

5
20

min() и max() удобно использовать, когда нужно быстро найти самый маленький или самый большой результат: например, минимальную цену, максимальный балл или самый короткий список.

Структуры данных в Python и команды для работы с ними

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

Можно было бы завести отдельную переменную для каждого значения:

fruit_1 = "яблоко"
fruit_2 = "банан"
fruit_3 = "апельсин"

Но с такими переменными неудобно работать: их нельзя перебрать в цикле, передать как единый набор в функцию или отсортировать одной командой. И если завтра добавится четвертый фрукт, придётся не просто создать новую переменную, а ещё и поправить весь код, который её использует. Поэтому в Python есть структуры данных — типы, которые позволяют хранить и обрабатывать группу значений как единое целое. В этом разделе разберём четыре основных: списки (list), кортежи (tuple), словари (dict) и множества (set).

Список list

Список используют, когда нужно хранить набор элементов в определённом порядке. Например, создадим список для фруктов:

fruits = ["яблоко", "банан", "апельсин"]

У элементов списка есть номера — индексы. Нумерация начинается с 0. К каждому элементу можно обращаться по индексу:

print(fruits[0])  # яблоко
print(fruits[1])  # банан

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

fruits = ["яблоко", "банан", "апельсин"]

fruits.append("груша")        # Добавили в конец
fruits.remove("банан")        # Удалили по значению
fruits[1] = "киви"            # Заменили по индексу

print(fruits)
# ['яблоко', 'киви', 'груша']

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

Читайте также:

Списки в Python: что это такое и как с ними работать

Словарь dict

Если списки хранят элементы по позиции (fruits[0], fruits[1]), то словари хранят их по имени — по так называемому ключу. Это удобно, когда у каждого значения есть свой смысл. Например, информацию о пользователе можно записать так:

user = {
    "name": "Анна",
    "age": 25,
    "city": "Москва"
}

Здесь "name", "age" и "city" — ключи. По ключу можно получить значение или, наоборот, добавить новое поле и изменить существующее:

print(user["name"])              # Анна
print(user["city"])              # Москва

user["email"] = "anna@mail.ru"   # Добавили новое поле
user["age"] = 26                 # Изменили существующее
print(user)
# {'name': 'Анна', 'age': 26, 'city': 'Москва', 'email': 'anna@mail.ru'}

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

Читайте также:

Словари в Python: что нужно знать и как пользоваться

Кортеж tuple

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

point = (10, 20)
rgb = (255, 0, 128)

point[0] = 15

# TypeError: 'tuple' object does not support item assignment

Всё остальное работает так же, как со списками: к элементам обращаются по индексу, кортеж можно перебирать в цикле и считать его длину через len(). А ещё кортеж можно удобно «распаковать» — присвоить элементы сразу нескольким переменным одной командой:

point = (10, 20)
x, y = point        # x = 10, y = 20
print(x, y)         # 10 20

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

Читайте также:

Что такое кортежи в Python и как их использовать

Множество set

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

tags = {"python", "html", "python", "css"} print(tags) 

# {'python', 'html', 'css'} — повтор "python" исчез

У множества есть две важные особенности:

• элементы не повторяются — повторное добавление просто игнорируется;
• порядок элементов не сохраняется: при выводе Python может показать их в любой последовательности, и обращаться к ним по индексу, как к списку, нельзя.

Базовые команды — добавить элемент через .add(), удалить через .discard() и проверить наличие через in:

tags.add("javascript")     # Добавили новый элемент
tags.add("python")         # Игнорируется, "python" уже есть
tags.discard("html")       # Удалили

print("css" in tags)       # True
print("php" in tags)       # False

Множества чаще всего используют для двух задач — убрать дубликаты из списка и быстро проверить, входит ли значение в коллекцию:

numbers = [1, 2, 2, 3, 3, 3]
unique_numbers = set(numbers)
print(unique_numbers)      # {1, 2, 3}

Читайте также:

Множества в Python: вводный гайд для начинающих

Что изучать дальше

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

Изучите темы, которые остались за рамками этой статьи

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

• с работой с файлами — как читать и записывать данные на диск;
• с обработкой ошибок через try/except — как сделать так, чтобы программа не падала на неожиданном вводе;
• с классами и объектами — это основа объектно-ориентированного программирования, на котором написано большинство реальных проектов.

Хорошие точки входа — официальная документация Python и The Python Tutorial от самих создателей языка.

Сделайте первые практические проекты

Ничто не закрепляет знания быстрее, чем рабочий проект, который не стыдно показать. У нас в Skillbox Media есть пошаговые гайды по типовым задачам для новичков — попробуйте сделать хотя бы один:

• Калькулятор на Python — простое приложение с интерфейсом, на котором удобно разобраться с базовой логикой.
• Игра «Змейка» на Pygame — классика для тех, кто хочет потрогать графику и создать простую игру. .
• Эхо-бот для Telegram на Aiogram — рабочий бот, которым можно пользоваться сразу после написания.
• Парсер сообщений из Telegram — задачка из реальной разработки, заодно знакомство с библиотеками и API.

Каждый из этих проектов укладывается в один-два вечера и позволит закрепить теорию.

Выберите направление и углубитесь в библиотеки

Python — универсальный язык, но в каждой сфере используют свой набор инструментов. Выберите одно направление и сделайте на нём небольшой проект:

• Веб-разработка — фреймворк Django для полноценных сайтов, Flask для лёгких приложений, FastAPI для современных API.
• Анализ данных — Pandas для работы с табличными данными и NumPy для вычислений с матрицами.
• Машинное обучение — Scikit-learn для классических алгоритмов, PyTorch и TensorFlow для нейросетей.

Если хочется учиться по структурированной программе, а не собирать материал по кусочкам, у Skillbox естькурс «Профессия Python-разработчик + ИИ» — обучение с наставниками, реальными проектами и портфолио к выпуску. Подойдёт и тем, кто только начинает, и тем, кто уже освоил базу и хочет двигаться к серьёзным задачам.