Урок 1. Переменные, ввод-вывод и базовые типы данных в Python

Теория

1. Что такое программа. Язык Python

Программа — это последовательность инструкций, которые сообщают компьютеру, что нужно сделать. Инструкции могут быть следующими:

• считать данные с клавиатуры;
• выполнить вычисления (сложение, вычитание, умножение, деление);
• вывести информацию на экран;
• принять решение (условный оператор);
• повторить действие (цикл).

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

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

Примеры языков программирования: Python, C, C++, Java, C#, Ruby, PHP.

Почему Python?

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

Python используется в Google, NASA, Instagram и многих других крупных организациях.

Компилируемые и интерпретируемые языки

Python — интерпретируемый язык. Интерпретатор читает и выполняет код строка за строкой, что упрощает тестирование и отладку.

Как работает интерпретатор Python

[Ваш код (.py)] → [Интерпретатор] → [Байт-код] → [Виртуальная машина Python] → [Результат]

1. Вы пишете исходный код в файле .py.
2. Интерпретатор читает ваш код.
3. Он преобразует его в байт-код (промежуточное представление).
4. Виртуальная машина Python (PVM) выполняет байт-код.

Это делает Python платформо-независимым — один и тот же код работает в Windows, macOS и Linux.

2. Первые программы: print() и input()

Функция print()

Функция print() выводит данные на экран (в консоль).

print("Hello, World!")
print(42)
print(3.14159)

Вывод:

Hello, World!
42
3.14159

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

print("The answer is", 42)
print("Today", "is", "Monday")

Вывод:

The answer is 42
Today is Monday

Параметр sep

Параметр sep задаёт разделитель между аргументами (по умолчанию — пробел):

print("a", "b", "c", sep="*")
print("d", "e", "f", sep="**")

Вывод:

a*b*c
d**e**f

Параметр end

Параметр end задаёт то, что выводится в конце (по умолчанию — перевод строки \n):

print("Hello", end="")
print("World")

Вывод:

HelloWorld

print("apple", "banana", "cherry", sep=",")
# Вывод: apple,banana,cherry
 
print("One", "Two", "Three", sep=" - ", end="!\n")
# Вывод: One - Two - Three!

Функция input()

Функция input() считывает строку текста, введённую пользователем.

name = input("Enter your name: ")
print("Hello", name)

Пример работы:

Enter your name: Alice
Hello Alice

age = input("Enter your age: ")
print("In 10 years you will be", age + 10)  # ОШИБКА!

input() можно вызывать и без подсказки:

name = input()
print("Hello,", name)

Интерактивная программа

# Простая интерактивная программа
print("Welcome to my first program!")
name = input("What is your name? ")
print("Nice to meet you,", name)
print("Let's learn Python together!")

Пример работы:

Welcome to my first program!
What is your name? Alex
Nice to meet you, Alex
Let's learn Python together!

3. Переменные и оператор присваивания

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

Синтаксис присваивания:

имя_переменной = значение

name = "Alice"       # строка
age = 20             # целое число
pi = 3.14159         # вещественное число
is_student = True    # логическое значение

a = 23    # Правильно: присвоить 23 переменной a
23 = a    # Неправильно: нельзя присвоить значение литералу

Правила именования переменных

1. Имя должно начинаться с буквы или символа подчёркивания (_).
2. Может содержать буквы, цифры и символы подчёркивания.
3. Регистрозависимо (name ≠ Name ≠ NAME).
4. Нельзя использовать ключевые слова Python (if, for, while и т.д.).

Хорошие имена:

user_name = "Bob"
total_count = 42
_max_value = 100

Плохие имена:

2nd_place = "silver"   # нельзя начинать с цифры
user-name = "Bob"      # дефис не допускается
if = 5                 # if — ключевое слово

Принято использовать «змеиный стиль» (snake_case): составные имена записываются строчными буквами, слова разделяются подчёркиванием.

long_long_name = "описательное имя переменной"
user_age = 25
total_price = 99.99

Оператор присваивания

Оператор = связывает имя переменной с объектом в памяти:

x = 500
y = 300
x = x - 200   # x теперь ссылается на новый объект (300)
pi = 3.14159
name = "Alice"
is_student = True

Моржовый оператор (Python 3.8+)

В Python 3.8 появился оператор присваивания-выражения, также известный как «моржовый оператор» (walrus operator), потому что := напоминает глаза и клыки моржа.

имя_переменной := выражение

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

x = (y := 10) * 2

В результате y ссылается на 10, x — на 100.

y := 10    # Синтаксическая ошибка
(y := 10)  # Правильно

4. Как данные хранятся в памяти

Прежде чем использовать любое значение, Python преобразует его в объект PyObject. В CPython (эталонной реализации Python) каждый объект — это структура PyObject.

Для простоты можно представлять PyObject как совокупность трёх значений:

1. type — тип данных (int, str и т.д.);
2. value — собственно значение;
3. refcount — количество ссылок на этот объект.

Когда Python выполняет:

print("Hello, world!")

Сначала создаётся объект типа str со значением "Hello, world!" и refcount = 0. Затем этот объект передаётся функции print().

Все операторы и функции Python работают именно с такими структурами PyObject.

Как выглядит присваивание в памяти

Проследим выполнение простой программы:

x = 500
y = 300
x = x - 200

Шаг 1: x = 500 — Python создаёт объект int со значением 500. Имя x привязывается к этому объекту.

Шаг 2: y = 300 — создаётся объект int со значением 300. Имя y привязывается к нему.

Шаг 3: x = x - 200:

• Python вычисляет правую часть: 500 - 200 = 300.
• Объект int со значением 300 уже существует (на него ссылается y).
• x привязывается к тому же объекту, что и y.
• refcount объекта 300 становится равным 2.
• refcount объекта 500 падает до 0.
• Объект 500 автоматически удаляется сборщиком мусора.

5. Типы данных и типизация

В Python есть несколько базовых типов данных:

Проверить тип значения можно функцией type():

print(type(42))      # <class 'int'>
print(type(3.14))    # <class 'float'>
print(type("Hi"))    # <class 'str'>
print(type(True))    # <class 'bool'>

Изменяемые и неизменяемые типы

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

Привычные типы (int, float, str) являются неизменяемыми. Это означает, что при попытке изменения значения создаётся новый объект, а старый остаётся неизменным.

Динамическая и строгая типизация

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

x = 5          # x — целое число
x = "hello"    # теперь x — строка
x = 3.14       # теперь x — вещественное число

При этом Python — строго типизированный язык: несовместимые операции вызывают ошибку:

s = '2134' + '123'       # OK: str + str = str
s = 1234 + 12            # OK: int + int = int
s = 1234.4321 + 12.21    # OK: float + float = float
s = 1234.4321 + 12       # OK: float + int = float
s = True + True          # OK: bool + bool = int (2)
s = '123' + 12           # ОШИБКА! str + int

Строки

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

message1 = 'Hello'
message2 = "World"
message3 = "She said 'Hello'"
message4 = 'She said "Hello"'

Многострочные строки используют тройные кавычки:

poem = """Roses are red,
Violets are blue,
Python is fun,
And so are you!"""

Основные операции со строками:

greeting = "Hello"
name = "Alice"
 
print(greeting + " " + name)   # Конкатенация: Hello Alice
print("Ha" * 3)                 # Повторение: HaHaHa
print(greeting[0])              # Индексация: H
print(len(greeting))            # Длина: 5

Логические значения

Логический тип bool принимает значения True или False:

is_sunny = True
is_raining = False
print(is_sunny == True)   # True

Логические значения часто являются результатом сравнений:

print(5 > 3)      # True
print(5 == 3)     # False
print(5 != 3)     # True

print(True + True)   # 2

6. Преобразование типов

Python предоставляет встроенные функции для преобразования между типами:

print(bool(0))        # False
print(bool(42))       # True
print(bool(""))       # False
print(bool("hello"))  # True
 
print(float(42))      # 42.0
print(float("3.14"))  # 3.14
print(float(True))    # 1.0
 
print(int(3.99))      # 3 (отбрасывает дробную часть, не округляет)
print(int("42"))      # 42
print(int("0x1A", 16))  # 26 (указано основание)
 
print(str(42))        # "42"
print(str(3.14))      # "3.14"
print(str(True))      # "True"

Исправление ошибки типов

Вернёмся к ошибке из предыдущего раздела и исправим её:

# НЕПРАВИЛЬНО:
# s = '123' + 12  # TypeError
 
# ИСПРАВЛЕНИЕ 1: преобразовать целое число в строку
s = '123' + str(12)   # '12312' (конкатенация строк)
 
# ИСПРАВЛЕНИЕ 2: преобразовать строку в целое число
s = int('123') + 12   # 135 (сложение целых чисел)

Преобразование строки в целое число с указанием основания

По умолчанию int() интерпретирует строку как десятичное число (основание 10):

print(int('10232'))   # 10232

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

int(s, b)  # s — строковое представление числа в системе счисления b

Цифры после 9 — это буквы английского алфавита a–z в любом регистре. Поддерживаются основания от 2 до 36.

x = int('1A20', 13)   # 1A20 в системе с основанием 13 = 3913 в десятичной

Проверка:

1 × 13³ + 10 × 13² + 2 × 13¹ + 0 × 13⁰
= 2197 + 1690 + 26 + 0
= 3913

Преобразование целого числа в другие системы счисления

Способ 1: f-строки (Python 3.6+)

x = 223
print(f'{x:b}')   # '11011111' (двоичная)
print(f'{x:o}')   # '337' (восьмеричная)
print(f'{x:x}')   # 'df' (шестнадцатеричная, нижний регистр)
print(f'{x:X}')   # 'DF' (шестнадцатеричная, верхний регистр)

Способ 2: встроенные функции

x = 223
print(bin(x))   # '0b11011111'
print(oct(x))   # '0o337'
print(hex(x))   # '0xdf'

Ключевые моменты:

• Результат всегда является строкой.
• Встроенные функции добавляют префикс: 0b (двоичная), 0o (восьмеричная), 0x (шестнадцатеричная).
• f-строки не включают префикс.

var = 1443
print(f'{var:x}')   # '5a3'
print(hex(var))     # '0x5a3'

Преобразование пользовательского ввода

age_str = input("Enter your age: ")   # "20" (строка)
age = int(age_str)                     # 20 (целое число)
print("Next year you'll be", age + 1)  # Работает!

Частые ошибки:

# int("3.14")  # ОШИБКА: нельзя преобразовать строку с десятичной точкой в int
# int("abc")   # ОШИБКА: нельзя преобразовать нечисловую строку
# int("42.0")  # ОШИБКА: нельзя напрямую преобразовать строку с плавающей точкой в int

Безопасное преобразование:

# Преобразовать строку с плавающей точкой в int через float
value = int(float("3.14"))   # 3

7. Арифметические операции

Базовые арифметические операции

a = 10
b = 3
print(a + b)    # 13
print(a - b)    # 7
print(a * b)    # 30
print(a / b)    # 3.3333333333333335
print(a // b)   # 3
print(a % b)    # 1
print(a ** b)   # 1000

Приоритет операций

Python следует стандартному математическому приоритету:

1. Скобки ()
2. Возведение в степень **
3. Умножение, деление, целочисленное деление, остаток: *, /, //, %
4. Сложение, вычитание: +, -

print(2 + 3 * 4)     # 14 (сначала 3*4, затем +2)
print((2 + 3) * 4)   # 20 (сначала скобки)
print(2 ** 3 ** 2)   # 512 (2^(3^2) = 2^9, правоассоциативность)

Целочисленное деление и остаток

Эти два оператора особенно полезны при работе с цифрами:

• // — целочисленное деление, отбрасывает остаток;
• % — возвращает остаток.

print(17 // 5)   # 3
print(17 % 5)    # 2
print(17 / 5)    # 3.4

print(-12 // 7)   # -2
print(-12 % 7)    # 2
print(13 // -6)   # -3
print(13 % -6)    # -5

Сокращённая запись

Для изменения значения переменной относительно текущего можно использовать сокращённые операторы:

a = 10
a += 2   # a = 12
a *= 3   # a = 36
a /= 2   # a = 18.0
print(a)

8. Работа с цифрами числа

Если мы работаем в 10-й системе счисления, любое число можно разобрать на цифры, используя степени 10 и операции // и %.

Стандартный вид числа:

123 = 1 × 100 + 2 × 10 + 3

Таким образом, можно получить отдельные цифры числа:

• для получения сотен из трёхзначного числа нужно вычислить частное от деления на 100;
• для получения десятков — вычислить остаток от деления на 100, а затем частное от деления на 10;
• для получения единиц — взять остаток от деления на 10.

begin
  var a := abs(readinteger); // модуль числа
  println(a div 100 + (a div 10) mod 10 + a mod 10);
end.

На Python это будет выглядеть так:

n = abs(int(input("Введите трёхзначное число: ")))
s = n // 100 + (n // 10) % 10 + n % 10
print("Сумма цифр:", s)

n = 754
last = n % 10            # 4
middle = (n // 10) % 10  # 5
first = n // 100         # 7
print(first, middle, last)  # 7 5 4

Общая формула для k-й цифры (справа, нумерация с 0):

digit = (n // 10**k) % 10

9. Множественное присваивание

Python синтаксически поддерживает возможность задавать значения нескольких переменных с помощью одного оператора присваивания.

a, b = value1, value2

a, b = 1000, 450 + 550

После этой строки a ссылается на 1000, b — на 1000 (так как 450 + 550 = 1000).

Существует также альтернативный способ присвоить один и тот же объект нескольким переменным:

a = b = 1000

В этом случае создаётся один объект со значением 1000, и его адрес записывается в обе переменные.

Практическое применение: обмен значениями

Множественное присваивание делает обмен значениями переменных тривиальным в Python:

a = 5
b = 10
a, b = b, a   # Обмен!
print(a)      # 10
print(b)      # 5

10. PEP 8 и комментарии

Что такое PEP?

PEP (Python Enhancement Proposal) — документы, описывающие новые возможности или руководства по стилю для Python.

PEP 8 — официальное руководство по стилю кода на Python.

Ключевые рекомендации PEP 8

1. Отступы: используйте 4 пробела для отступа (не табуляцию).

# Правильно
if x > 0:
    print("Positive")
 
# Неправильно (неверный отступ)
if x > 0:
print("Positive")

2. Длина строки: максимум 79 символов.

3. Именование:

• Переменные и функции: lower_case_with_underscores (snake_case).
• Классы: CamelCase.

# Правильно
user_name = "Alice"
def calculate_average():
    pass
 
# Неправильно
userName = "Alice"          # не snake_case
def CalculateAverage():     # не snake_case для функций
    pass

4. Пробелы после запятых:

# Правильно
print("PEP8", "Rocks!")
 
# Неправильно
print("PEP8","Rocks!")
print("PEP8" , "Rocks!")

5. Без пробелов перед скобками в вызовах функций:

# Правильно
print("Hello")
 
# Неправильно
print ("Hello")

6. Без пробелов вокруг = для именованных аргументов:

# Правильно
print("Hello", end="!")
 
# Неправильно
print("Hello", end = "!")

Комментарии

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

Однострочные комментарии:

# Это комментарий
print("Hello")  # Это встроенный комментарий

Многострочные комментарии (docstrings):

"""
Это многострочный комментарий.
Он может занимать несколько строк.
Полезен для объяснения сложного кода.
"""
print("Hello")

Когда использовать комментарии:

• Объясняйте почему код что-то делает, а не что он делает.
• Документируйте сложную логику.
• Оставляйте заметки для себя или других разработчиков.

# Вычисляем площадь круга
# Формула: area = π * r²
radius = float(input("Введите радиус: "))
pi = 3.14159
area = pi * radius ** 2
print("Площадь:", area)

Лабораторные работы

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

print("Hello, World!")

Hello, World!

name = input("Введите ваше имя: ")
print("Привет,", name + "! Добро пожаловать в Python!")

Введите ваше имя: Алиса
Привет, Алиса! Добро пожаловать в Python!

num1 = int(input("Введите первое число: "))
num2 = int(input("Введите второе число: "))
sum_result = num1 + num2
print("Сумма:", sum_result)

Введите первое число: 5
Введите второе число: 7
Сумма: 12

num1 = input("Первое число: ")   # "5"
num2 = input("Второе число: ")   # "7"
print(num1 + num2)                # "57", а не 12!

a = float(input("Введите первое число: "))
b = float(input("Введите второе число: "))
print(a, "+", b, "=", a + b)
print(a, "-", b, "=", a - b)
print(a, "*", b, "=", a * b)
print(a, "/", b, "=", a / b)

Введите первое число: 10
Введите второе число: 3
10.0 + 3.0 = 13.0
10.0 - 3.0 = 7.0
10.0 * 3.0 = 30.0
10.0 / 3.0 = 3.3333333333333335

n = int(input("Введите трёхзначное число: "))
 
# Извлекаем цифры
last = n % 10
middle = (n // 10) % 10
first = n // 100
 
print("Цифры в обратном порядке:", last, middle, first)

Введите трёхзначное число: 754
Цифры в обратном порядке: 4 5 7

Формула: F = C × 9 / 5 + 32

celsius = float(input("Введите температуру в Цельсиях: "))
fahrenheit = celsius * 9 / 5 + 32
print(f"{celsius:.2f}°C = {fahrenheit:.2f}°F")

Введите температуру в Цельсиях: 25
25.00°C = 77.00°F

a = 5
b = 10
print("До обмена: a =", a, ", b =", b)
 
# Обмен с использованием временной переменной
temp = a
a = b
b = temp
 
print("После обмена: a =", a, ", b =", b)

До обмена: a = 5 , b = 10
После обмена: a = 10 , b = 5

a = 5
b = 10
print("До обмена: a =", a, ", b =", b)
 
# Элегантный обмен в Python
a, b = b, a
 
print("После обмена: a =", a, ", b =", b)

Самостоятельные задания

Решите следующие задачи самостоятельно. Для проверки используйте примеры вывода.

Пример вывода:

Введите год рождения: 2000
Вам 26 лет.

Подсказка: используйте int() для преобразования ввода.

Формула: Площадь = π × r²

Используйте π = 3.14159.

Пример вывода:

Введите радиус: 5
Площадь круга: 78.53975

Пример вывода:

Введите трёхзначное число: 423
Сумма цифр: 9
Произведение цифр: 24

Подсказка: используйте % и // для извлечения цифр.

Пример вывода:

Введите количество секунд: 125
125 секунд = 2 минуты и 5 секунд

Подсказка: используйте // для минут и % для оставшихся секунд.

Пример вывода:

Введите четырёхзначное число: 1234
Число в обратном порядке: 4321

Подсказка: извлеките каждую цифру с помощью % и //.

Пример вывода:

Введите первое число: 5
Введите второе число: 10
До обмена: a = 5, b = 10
После обмена: a = 10, b = 5

Подсказка: используйте арифметические операции + и -.

Словарь Python-объектов

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