Типы данных:
True
и False
;С целочисленным типом и числами с плавающей точкой мы уже познакомились. Посмотрим, как определить тип переменной:
x = 2.34
type(x)
float
y = 2
type(y)
int
Чтобы создать переменную строкового типа, нужны кавычки, причём использовать можно как двойные, так и одинарные:
text = "hello"
text2 = 'hello'
type(text)
str
Иногда требуется преобразовать тип переменной, например, из числа с плавающей точкой сделать целое число. Зачем это бывает нужно? Для удобства и для более корректной выдачи результатов. Например, у нас есть база данных по респондентам, в которой указан их год рождения, и мы хотим добавить столбец с возрастом респондентов (числом полных лет). Из-за того, что кто-то ввел год в виде 1993.0, возраст при вычислениях тоже получится числом с плавающей точкой — 25.0. Так как мы знаем, что возраст всегда будет целым, чтобы дробная часть не смущала, можно привести все значения к целочисленному типу.
int(25.0)
25
Вообще функции для изменения типа переменных называются так же, как и сами типы или их сокращённые названия.
float(23)
23.0
str(2)
'2'
Однако, если преобразование невозможно, Python выдаст ошибку (а точнее, исключение ValueError
, про исключения поговорим позже):
float('23,56')
--------------------------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-8-b3dd92f20a26> in <module> ----> 1 float('23,56') ValueError: could not convert string to float: '23,56'
Так как запятая в Python не воспринимается как десятичный разделитель (в качестве разделителя используется точка), превратить строку '23,56' в число не получится, нужно будет сначала заменить запятую на точку. Как работать со строками, мы обсудим позже, но если интересно, можно сделать следующее: создать любую строковую переменную, а потом после её названия поставить точку и нажать Tab. Так же, как и в случае с модулем math
, выпадет список всех возможных методов, которые можно применять к строке.
У Python активно реализуется перегрузка операторов, которая выражается в том, что одни и те же операторы могут выполнять разные задачи в зависимости от типа данных, к которым они применяются. Если говорить совсем формально и залезать в терминологию объектно-ориентированного программирования, для Python характерен полиморфизм – разное поведение операций и методов на разных классах. О классах мы будем говорить позже, а пока посмотрим на примеры такого поведения.
one = "abc"
two = "def"
one + two
'abcdef'
По идее, при исполнении кода выше мы должны были получить ошибку, нельзя применять сложение не к числам. Но нет: операция сложения в Python на строках тоже имеет смысл – она обеспечивает конкатенацию (склеивание) строк. А можно ли умножать строку на число? Давайте проверим:
one * 2
'abcabc'
Как выяснилось, можно. Здесь операция умножения работает как в математике: умножить число на число – то же самое что сложить это число необходимое количество раз. А складывать строки (то есть склеивать) Python умеет. Но, конечно, аналогии не могут продолжаться бесконечно:
one ** 2
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-11-4337aa96fb97> in <module> ----> 1 one ** 2 TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'int'
Иногда возникает необходимость запросить какую-нибудь информацию у пользователя — попросить ввести её с клавиатуры. Это может быть нужно, например, когда мы пытаемся имитировать заполнение какой-нибудь формы (собрать информацию и обработать) или написать функцию, которая будет работать по-разному в зависимости от режима ("Если хотите выгрузить данные из файла, нажмите 1, если хотите вводить данные вручную, введите 2").
Запросить данные с клавиатуры можно с помощью функции input()
:
input()
smth
'smth'
Однако обычно нам нужно не просто вывести на экран то, что ввёл пользователь (он и сам это видит), но и сохранить введенную информацию. Сделаем это (и заодно перейдём к числам).
num = input("Введите какое-нибудь число: ")
Введите какое-нибудь число: 5
Теперь мы можем работать с переменной num
, в которую мы сохранили результат ввода с клавиатуры.
num
'5'
Введенное нами число 5 сохранилось. Однако, если посмотреть внимательнее, это не совсем число, это строка! Проверим:
type(num) # действительно
str
Функция input()
всегда возвращает обект типа string. Тут нам и пригодится преобразование типов переменных:
num = int(num)
num
5
И теперь всё сразу: правильно и компактно.
num = int(input("Введите какое-нибудь число: "))
num
Введите какое-нибудь число: 7
7
Раз мы не предлагаем пользователю ввести именно целое число, число может быть любым, даже дробным. Учтём это – будем конвертировать введенный текст в число с плавающей точкой.
num = float(input("Введите какое-нибудь число: "))
num
Введите какое-нибудь число: 6.5
6.5
С клавиатуры можно вводить сколько угодно объектов:
numbers = input("Введите числа через пробел: ")
Введите числа через пробел: 2 3
numbers
'2 3'
Только тогда для работы с отдельными элементами ввода потребуется разбить строку на части по какому-нибудь символу (в нашем случае – по пробелу). О разбиении текста на части поговорим позже, когда будем обсуждать работу со строками, а пока разберём вывод информации на экран.
Как мы уже знаем, для вывода чего-либо на экран в Python существует функция print()
:
print(5)
print('Hello!')
5 Hello!
Для того, чтобы вывести на экран сразу несколько объектов, нужно просто перечислить их через запятую в круглых скобках.
age = 23
print('Your age is ', age)
Your age is 23
По умолчанию в качестве разделителей (отделяющих объекты друг от друга) используются пробелы. Но при желании это можно поправить, добавив аргумент sep
(от separator – разделитель):
print(2, 3, sep='-')
2-3
print(2, 3, sep='------')
2------3
При работе с функцией print()
важно помнить, что эта функция используется исключительно для вывода текста на экран, она ничего не возвращает – не умеет сохранять то, что выводит на экран. Если попробуем сохранить результат её исполнения, получим пустой объект – объект особого типа None
:
s = print(2, 3, sep='-')
print(s)
2-3 None
А теперь посмотрим на то, как подставлять значения в уже имеющийся текстовый шаблон, то есть форматировать строки. Чтобы понять, о чём идет речь, можно представить, что у нас есть электронная анкета, которую заполняет пользователь, и мы должны написать программу, которая выводит на экран введенные данные, чтобы пользователь мог их проверить.
Пусть для начала пользователь вводит своё имя и возраст.
name = input("Введите Ваше имя: ")
age = int(input("Введите Ваш возраст: "))
Введите Ваше имя: Алла Введите Ваш возраст: 28
Теперь выведем на экран сообщение вида
Ваше имя: `имя`. Ваш возраст: `возраст`.
Но прежде, чем это сделать, поймем, какого типа будут значения, которые мы будем подставлять в шаблон. Имя – это строка (string), а возраст – это целое число (integer).
result = "Ваше имя: %s. Ваш возраст: %i." % (name, age)
print(result)
Ваше имя: Алла. Ваш возраст: 28.
Что за таинственные %s
и %i
? Все просто: оператор %
в строке указывает место, на которое будет подставляться значение, а буква сразу после процента – сокращённое название типа данных (s
– от string и i
– от integer). Осталось только сообщить Python, что именно нужно подставлять – после кавычек поставить %
и в скобках перечислить названия переменных, значения которых мы будем подставлять.
Конечно, результат можно выводить сразу, не сохраняя полученную строку в переменную.
print("Ваше имя: %s. Ваш возраст: %i." % (name, age))
Ваше имя: Алла. Ваш возраст: 28.
Примечание: не теряйте часть с переменными после самой строки, а также круглые скобки вокруг названий переменных, из которых мы подставляем значения, если их несколько.
Важно помнить, что если мы забудем указать какую-то из переменных, мы получим ошибку (точнее, исключение): Python не будет знать, откуда брать нужные значения.
print("Ваше имя: %s. Ваш возраст: %i." % (name))
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-27-2343aa81e176> in <module> ----> 1 print("Ваше имя: %s. Ваш возраст: %i." % (name)) TypeError: not enough arguments for format string
Кроме того, создавая такие текстовые шаблоны, нужно обращать внимание на типы переменных, значения которых мы подставляем.
print("Ваше имя: %s. Ваш возраст: %s." % (name, age)) # так сработает, int -> str
Ваше имя: Алла. Ваш возраст: 28.
print("Ваше имя: %i. Ваш возраст: %s." % (name, age)) # а так нет, str !-> int
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-29-4fb6c5ef466d> in <module> ----> 1 print("Ваше имя: %i. Ваш возраст: %s." % (name, age)) # а так нет, str !-> int TypeError: %i format: a number is required, not str
А что будет, если мы будем подставлять не целое число, а дробное, с плавающей точкой? Попробуем!
height = float(input("Введите Ваш рост (в метрах): "))
height
Введите Ваш рост (в метрах): 1.68
1.68
print("Ваш рост: %f м." % height) # f - от float
Ваш рост: 1.680000 м.
По умолчанию при подстановке значений типа float Python выводит число с шестью знаками после запятой. Но это можно исправить. Перед f
нужно поставить точку и указать число знаков после запятой, которое мы хотим:
print("Ваш рост: %.2f м." % height) # например, два
Ваш рост: 1.68 м.
print("Ваш рост: %.1f м. " % height) # или один
Ваш рост: 1.7 м.
В случае, если указанное число знаков после запятой меньше, чем есть на самом деле (как в ячейке выше), происходит обычное арифметическое округление.
Рассмотренный выше способ форматирования строк – не единственный. Он довольно стандартный, но при этом немного устаревший. В Python 3 есть другой способ – форматирование с помощью метода .format()
. Кроме того, в Python 3.6 и более поздних версиях появился ещё более продвинутый способ форматирования строк ‒ f-strings (formatted string literals). Этот способ позволяет не только подставлять в текстовый шаблон значения переменных, но и исполнять выражения с кодом внутри строки.
F-strings очень удобны и просты в использовании: вместо %
и сокращённого названия типа в фигурных скобках внутри текстового шаблона нужно указать название переменной, из которой должно подставляться значение, а перед всей строкой добавить f
, чтобы Python знал, что нам нужна именно f-string.
print(f"Ваше имя: {name}. Ваш возраст: {age}.")
Ваше имя: Алла. Ваш возраст: 28.
print(f"Ваш рост: {height}.") # нет лишних знаков
Ваш рост: 1.68.
print(f"Ваш рост: {round(height, 1)}.") # пример выражения
Ваш рост: 1.7.
print(f"Возраст в квадрате: {age ** 2}.") # пример выражения
Возраст в квадрате: 784.