Как и в любом другом языке программирования, в Python есть переменные. Присвоить переменной значение можно так:
In [1]:
a = 5
b = "Hello, LKSH"
c = 5.0
print(a)
print(b)
print(c)
Вы могли заметить, что мы нигде не объявили тип переменных a, b и c. В Python этого делать не надо. Язык сам выберет тип по значению, которое вы положили в переменную. Для переменной a это тип int (целое число). Для b — str (строка). Для c — float (вещественное число).
В ближайшем будущем вы скорее всего познакомитесь с такими типами:
| Тип | Python | Аналог в C++ | Аналог в Pascal |
|---|---|---|---|
| Целое число | int |
int |
Integer |
| Вещественное число | float |
double |
Double |
| Строка | str |
std::string |
String |
| Логический | bool |
bool |
Boolean |
| Массив | list |
std::vector<> |
Array |
| Множество | set |
std::set<> |
нет |
| Словарь | dict |
std::map<> |
нет |
Тип переменной можно узнать с помощью функции type:
In [2]:
a = 5.0
s = "LKSH students are awesome =^_^="
print(type(a))
print(type(b))
В Python можно присвоит значения сразу нескольким переменным:
In [3]:
a, b = 3, 5
print(a)
print(b)
При этом Python сначала вычисляет все значения справа, а потом уже присваивает вычисленные значения переменным слева:
In [4]:
a = 3
b = 5
a, b = b, a + b
print(a)
print(b)
Это позволяет, например, поменять значения двух переменных в одну строку:
In [5]:
a = "apple"
b = "banana"
a, b = b, a
print(a)
print(b)
Как вы уже видели, для вывода на экран в Python есть функция print. Ей можно передавать несколько значений через запятую — они будут выведены в одной строке через пробел:
In [6]:
a = 2
b = 3
print(a, "+", b, "=", a + b)
Для ввода с клавиатуры есть функция input. Она считывает одну строку целиком:
In [7]:
a = input()
b = input()
print(a + b)
Ага, что-то пошло не так! Мы получили 23 вместо 5. Так произошло, потому что input() возращает строку (str), а не число (int). Чтобы это исправить нам надо явно преобразовать результат функции input() к типу int.
In [8]:
a = int(input())
b = int(input())
print(a + b)
Так-то лучше :)
Частая ошибка — забыть внутренние скобки после функции input. Давайте посмотрим, что в этом случае произойдёт:
In [9]:
a = int(input)
b = int(input)
print(a + b)
Эту ошибку можно перевести с английского так:
ОшибкаТипа: аргумент функции int() должен быть строкой, последовательностью байтов или числом, а не функциейТеперь вы знаете что делать, если получите такую ошибку ;)
Давайте научимся складывать, умножать, вычитать и производить другие операции с целыми (тип int) или вещественными (тип float) числами. Стоит понимать, что целое число и вещественное число — это совсем разные вещи для компьютера.
Список основных бинарных (требующих 2 переменных) арифметических действий, которые вам понадобятся:
| Действие | Обозначение в Python | Аналог в C++ | Аналог в Pascal | Приоритет |
|---|---|---|---|---|
| Сложение | a + b |
a + b |
a + b |
3 |
| Вычитание | a - b |
a - b |
a - b |
3 |
| Умножение | a * b |
a * b |
a * b |
2 |
| Вещественное деление | a / b |
a / b |
a / b |
2 |
| Целочисленное деление (с округлением вниз) | a // b |
a / b |
a div b |
2 |
| Остаток от деления | a % b |
a % b |
a mod b |
2 |
| Возведение в степень | a ** b |
pow(a, b) |
power(a, b) |
1 |
Сложение, вычитание и умножение работают точно также, как и в других языках:
In [10]:
print(11 + 7, 11 - 7, 11 * 7, (2 + 9) * (12 - 5))
Вещественное деление всегда даёт вещественное число (float) в результате, независимо от аргументов (если делитель не 0):
In [11]:
print(12 / 8, 12 / 4, 12 / -7)
Результат целочисленного деления — это результат вещественного деления, округлённый до ближайшего меньшего целого:
In [12]:
print(12 // 8, 12 // 4, 12 // -7)
Остаток от деления — это то что осталось от числа после целочисленного деления.
Если c = a // b, то a можно представить в виде a = c * b + r. В этом случае r — это остаток от деления.
Пример: a = 20, b = 8, c = a // b = 2. Тогда a = c * b + r превратится в 20 = 2 * 8 + 4. Остаток от деления — 4.
In [13]:
print(12 % 8, 12 % 4, 12 % -7)
Возведение a в степень b — это перемножение a на само себя b раз. В математике обозначается как $a^b$.
In [14]:
print(5 ** 2, 2 ** 4, 13 ** 0)
Возведение в степень работает для вещественных a и отрицательных b. Число в отрицательной степени — это единица делённое на то же число в положительной степени: $a^{-b} = \frac{1}{a^b}$
In [15]:
print(2.5 ** 2, 2 ** -3)
Давайте посмотрим что получится, если возвести в большую степень целое число:
In [16]:
print(5 ** 100)
В отличии от C++ или Pascal, Python правильно считает результат, даже если в результате получается очень большое число.
А что если возвести вещественное число в большую степень?
In [17]:
print(5.0 ** 100)
Запись вида <число>e<степень> — это другой способ записать $\text{<число>} \cdot 10^\text{<степень>}$. То есть:
а это то же самое, что и 7888609052210118000000000000000000000000000000000000000000000000000000.
Этот результат не настолько точен, как предыдущий. Так происходит потому, что для хранения каждого вещественного числа Python использует фиксированное количество памяти, а значит может хранить число только с ограниченной точностью.
Возведение в степень также работает и для вещественной степени. Например $\sqrt{a} = a^\frac{1}{2} = a^{0.5}$
In [18]:
print(2 ** 0.5, 9 ** 0.5)
В школе вам, наверное, рассказывали, что квадратный корень нельзя извлекать из отрицательных чисел. С++ и Pascal при попытке сделать это выдадут ошибку. Давайте посмотрим, что сделает Python:
In [19]:
print((-4) ** 0.5)
В общем, это не совсем правда. Извлекать квадратный корень из отрицательных чисел, всё-таки, можно, но в результате получится не вещественное, а так называемое комплексное число. Если вы получили страшную такую штуку в своей программе, скорее всего ваш код взял корень из отрицательного числа, а значит вам надо искать в нём ошибку. В ближайшее время вам нет необходимости что-то знать про комплексные числа.
Естественно, как и во многих других языках программирования, вы можете составлять большие выражения из переменных, чисел, арифметических операций и скобок. Например:
In [20]:
a = 4
b = 11
c = (a ** 2 + b * 3) / (9 - b % (a + 1))
print(c)
В примере выше переменной c присвоено значение выражения
При отсутствии скобок арфиметические операции в выражении вычисляются в порядке приоритета (см. таблицу выше). Сначала выполняются операции с приоритетом 1, потом с приоритетом 2 и т.д. При одинаковом приоритете вычисление происходит слева направо. Вы можете использовать скобки, чтобы менять порядок вычисления.
In [21]:
print(2 * 2 + 2)
print(2 * (2 + 2))
Если у вас есть значение одного типа, то вы можете преобразовать его к другому типу, вызвав функцию с таким же именем:
In [22]:
a = "-15"
print(a, int(a), float(a))
Больше примеров:
In [23]:
# a_int, b_float, c_str - это просто имена переменных.
# Они так названы, чтобы было проще разобраться, где какое значение лежит.
a_int = 3
b_float = 5.0
c_str = "10"
print(a_int, b_float, c_str)
# При попытке сложить без преобразования мы получили бы ошибку, потому что Python
# не умеет складывать числа со строками.
print("a_int + int(c_str) =", a_int + int(c_str))
print("str(a_int) + str(b_float) =", str(a_int) + str(b_float))
print("float(c_str) =", float(c_str))