Введение в типы данных Python
- Как данные представлены в Python?
- Базовые типы данных в Python
- Динамическая типизация в Python
- О приведении типов в Python
- Получение помощи по объектам в Python
- Краткие итоги параграфа
- Вопросы и задания для самоконтроля
Как данные представлены в Python?
Когда мы имеем дело со значениями в программе, например, присваивая их для хранения переменной или передавая в качестве аргументов функции, нам приходится манипулировать различными типами этих значений (типами данных) такими, например, как числа или строки. В Python, как и в других языках программирования, имеется как встроенный комплект стандартных типов данных, так и возможность определять собственные пользовательские типы данных. При этом следует помнить про одну важную особенность – все данные в Python представлены в виде объектов, которые представляют собой выделенные области памяти со значениями данного типа и определенными для этих значений наборами операций (см. пример №1).
pythonCodes
# Импортируем модуль.
import sys
# Интерпретатор автоматически выделит под значения в памяти
# место, определит тип значений и набор операций для их
# обработки, т.е. создаст в памяти два объекта.
str_1 = 'Большой '
str_2 = 'дом.'
# Выведем на экран типы этих значений. Для этого используем
# общедоступную встроенную функцию type(obj)
print('Тип объекта str_1: ', type(str_1))
print('Тип объекта str_2: ', type(str_2), end='\n\n')
# Выведем объемы занимаемой значениями памяти. Метод getsizeof(obj)
# модуля sys стандартной библиотеки возвращает размер объекта в байтах.
print('Объем str_1: ', sys.getsizeof(str_1), 'байт')
print('Объем str_2: ', sys.getsizeof(str_2), 'байт', end='\n\n')
# Объединим эти строки в одну и выведем на экран.
print(str_1 + str_2, end='\n\n')
# Узнаем, что еще можно делать, например, с первым объектом.
print(dir(str_1))Тип значения в переменной str_1: <class 'str'>
Тип значения в переменной str_2: <class 'str'>
Объем памяти, занимаемый str_1: 90 байт
Объем памяти, занимаемый str_2: 82 байт
Большой дом.
['__add__', '__class__', '__contains__', '__delattr__', '__dir__',
'__doc__', '__eq__', '__format__', '__ge__', '__getattribute__',
'__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__',
'__init_subclass__', '__iter__', '__le__', '__len__', '__lt__',
'__mod__', '__mul__', '__ne__', '__new__', '__reduce__',
'__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__',
'__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold',
'center', 'count', 'encode', 'endswith', 'expandtabs', 'find',
'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii',
'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric',
'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust',
'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind',
'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split',
'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate',
'upper', 'zfill']
Пример №1. Определение типа и размера данных.
Как видим, Python предоставляет нам довольно обширный стандартный набор операций над строковыми объектами (надеюсь вы не забыли про кнопку «Результат»). Тоже самое касается и других встроенных типов. Если же программисту вдруг станет тесно, он всегда может разработать собственный тип данных и определить для него необходимый набор операций.
Базовые типы данных Python
Давайте с целью первичного ознакомления перечислим некоторые основные типы данных встроенные в Python.
- Числа – это целые (-8, 0, 47), вещественные (-0.54 или -.54, 0.0, 2.475) и комплексные числа (-3+5j, 77+2j). Все они относятся к неизменяемым типам данных.
- Строки – это текст произвольной длины, взятый в одинарные, двойные или тройные кавычки. Например, '25 яблок', "Ok, Python!", '''Строка в тройных кавычках так''', """или так.""". Строки также являются неизменяемым типом данных, хотя получить доступ к символу строки можно по его индексу.
- Списки – это упорядоченные неименованные изменяемые коллекции значений (объектов), например, ['A', 'B', 'C'] или [2, [True, False], "house"]. Литерал списка задается квадратными скобками, внутри которых через запятую перечисляются значения любых типов данных включая и сами списки. Доступ к значениям списка осуществляется по индексам (об этом чуть позже).
- Кортежи – это упорядоченные неименованные неизменяемые коллекции значений (объектов), например, ('A', 'B', 'C') или (2, "house", True). Литерал кортежа задается круглыми скобками, внутри которых через запятую перечисляются значения неизменяемых типов данных. Доступ к значениям осуществляется по индексам. Но, т.к. кортежи являются неизменяемыми последовательностями, то добавлять или удалять элементы из них нельзя.
- Словари – это именованные изменяемые неупорядоченные коллекции значений (объектов), например, {'Name': 'Sveta', 'Age': 25}. Литерал словаря задается фигурными скобками, внутри которых через запятую перечисляются пары ключ: значение. В качестве ключей в принципе можно использовать любые неизменяемые уникальные значения, например, числа или строки, а в качестве значений вообще любые типы объектов, включая другие словари. Доступ к значениям в словаре осуществляется по ключам.
- Множества – это неименованные и неупорядоченные изменяемые коллекции уникальных и неизменяемых значений (объектов), например, {'Name', False, 25}. Литерал множества задается фигурными скобками, внутри которых через запятую перечисляются значения неизменяемых типов данных. Сами множества являются изменяемыми коллекциями значений, но вот значения в коллекции должны относиться к неизменяемым типам вроде чисел и строк.
- Логические значения – этот тип данных содержит всего две булевых константы: True и False.
- NoneType – специальное значение None, которое означает отсутствие значения.
Чтобы узнать тип объекта, используемого в программе, можно воспользоваться встроенной функцией type(obj), которой в качестве аргумента нужно передать интересующий нас объект (см. пример №2). Функция является встроенной в интерпретатор Питона, поэтому ее не нужно импортировать и она общедоступна для использования из любой точки программы. Посмотреть весь список встроенных функций можно в справочнике стандартной библиотеки в разделе Built-in Functions.
pythonCodes
# Не забываем про кнопку Результат!
# Именованный аргумент end задает концовку вывода.
# Здесь мы задали двойной перевод строки end='\n\n'.
print('--- Числа ---', end='\n\n')
# Выводим тип целого числа.
print('5: ', type(5))
# Выводим тип числа с плавающей точкой.
print('7.033: ', type(7.033))
# Выводим тип комплексного числа.
print('-0.2+3j: ', type(-0.2+3j), end='\n\n')
print('--- Строки ---', end='\n\n')
# Строка в одинарных кавычках.
print('\'Строка\': ', type('Строка'))
# Строка в двойных кавычках.
print('"Строка": ', type("Строка"))
# Строка в тройных кавычках.
print('"""Строка""": ', type("""Строка"""), end='\n\n')
print('--- Списки ---', end='\n\n')
# Проверим, является ли этот литерал списком.
print('["one", [1,2], 0]: ', type(["one", [1,2], 0]))
# Так можно задавать пустой список.
print('[]: ', type([]), end='\n\n')
print('--- Кортежи ---', end='\n\n')
# Проверим, является ли этот литерал кортежем.
print('("one", (1,2), 0): ', type(("one", (1,2), 0)))
# Так можно задавать пустой кортеж.
print('(): ', type(()), end='\n\n')
print('--- Словари ---', end='\n\n')
# Проверим, является ли этот литерал словарем.
dict = {'Name': 'Sveta', 'Age': 25}
print("{'Name': 'Sveta', 'Age': 25}: ", type(dict))
# Так можно задавать пустой словарь.
print('{}: ', type({}), end='\n\n')
print('--- Множества ---', end='\n\n')
# Проверим, является ли этот литерал множеством.
print("{'Sveta', 25}: ", type({'Sveta', 25}))
# Так можно задавать пустое множество (литерала нет).
print('set(): ', type(set()), end='\n\n')
print('--- Булевы значения ---', end='\n\n')
# Проверим, являются ли эти литералы булевыми значениями.
print('True: ', type(True))
print('False: ', type(False), end='\n\n')
print('--- Значение None ---', end='\n\n')
# Проверим, является ли этот литерал NoneType.
print('None: ', type(None), end='\n\n')--- Числа ---
5: <class 'int'>
7.033: <class 'float'>
-0.2+3j: <class 'complex'>
--- Строки ---
'Строка': <class 'str'>
"Строка": <class 'str'>
"""Строка""": <class 'str'>
--- Списки ---
["one", [1,2], 0]: <class 'list'>
[]: <class 'list'>
--- Кортежи ---
("one", (1,2), 0): <class 'tuple'>
(): <class 'tuple'>
--- Словари ---
{'Name': 'Sveta', 'Age': 25}: <class 'dict'>
{}: <class 'dict'>
--- Множества ---
{'Sveta', 25}: <class 'set'>
set(): <class 'set'>
--- Булевы значения ---
True: <class 'bool'>
False: <class 'bool'>
--- Значение None ---
None: <class 'NoneType'>
Пример №2. Литералы встроенных типов данных в исходном коде.
Хотелось бы добавить, что встроенные типы данных можно классифицировать по нескольким признакам: изменяемые (списки, словари, множества) и неизменяемые (числа, строки, кортежи, логические значения, значение None), а также упорядоченные (строки, списки, кортежи) и неупорядоченные (словари и множества). Эта классификация очень важна для понимания возможностей типов и области их применения. Однако здесь мы в подробности углубляться не будем, оставив более детальное рассмотрение перечисленных типов данных до последующих параграфов нашего учебника.
Динамическая типизация в Python
Как упоминалось ранее, Python относится к языкам программирования с динамической типизацией данных. Давайте рассмотрим это понятие подробнее.
Динамическая типизация – это прием, при котором переменная связывается с типом в момент присваивания значения, а не в момент объявления переменной.
Это значит, что в Python программисту не нужно объявлять тип переменной в исходном коде. Интерпретатор делает это автоматически во время присвоения переменной нового значения. При этом он самостоятельно контролирует объем памяти, распределяемый под вновь создаваемый объект (см. пример №3).
Объем памяти, занимаемой любым объектом, можно узнать при помощи метода sys.getsizeof(obj) модуля sys стандартной библиотеки, который возвращает размер объекта в байтах. В качестве аргумента методу необходимо передать интересующий нас объект.
Проверить объект на принадлежность к типу можно при помощи встроенной функции isinstance(obj, type), которой в качестве аргументов нужно передать проверяемый объект, а также имя типа. Если имя типа объекта совпадает с типом объекта, то функция вернет True, иначе – False.
pythonCodes
# Импортируем модуль sys стандартной библиотеки.
import sys
# Присвоим переменной целое число.
d = 33
# Проверим тип переменной.
print('Тип переменной d: ', type(d))
# Узнаем ее размер в байтах.
print('Размер d в байтах: ', sys.getsizeof(d), end='\n\n')
# Теперь присвоим той же переменной словарь.
d = {1: 'red', 2: 'green'}
# Тип по-прежнему int?
print("Тип d все еще int?: ", isinstance(d, int))
# А какой тогда?
print("Новый тип переменной d: ", type(d))
# А размер изменился?
print('Новый размер d в байтах: ', sys.getsizeof(d))Тип переменной d: <class 'int'>
Размер d в байтах: 28
Тип d все еще int?: False
Новый тип d: <class 'dict'>
Новый размер переменной d в байтах: 232
Пример №3. Динамическая типизация в действии.
Как видим, интерпретатор все сделал за нас. Однако при этом не стоит забывать, что мы сами должны следить за тем, чтобы в выражениях использовались значения допустимых типов (см. пример №4). Например, если в текущем фрагменте кода мы делим переменные, следует самим следить за тем, чтобы в обоих на момент выполнения операции хранились числа, иначе может возникнуть ошибка.
pythonCodes
# Присвоим переменной число с плавающей точкой.
d = 33.47
# Присвоим переменной строку.
s = '33.47'
# Попробуем сложить
res = d + s
# и затем вывести результат на экран.
print(res)
# Получили вполне ожидаемую ошибку.unsupported operand type(s) for +: 'float' and 'str'
Пример №4. Неправильное использование значений различных типов.
Хорошо, а где интерпретатор хранит тип значения? Все очень просто. Как мы уже говорили, в Python все состоит из объектов. Переменные как таковые типа не имеют. Когда в коде программы мы присваиваем переменной значение, интерпретатор создает для значения объект, в котором хранятся как тип значения, так и набор допустимых для данного типа операций. Самой же переменной присваивается только ссылка на этот объект. Таким образом в Python переменные не хранят сами значения, а только ссылаются на объекты присваиваемых им значений. Когда же мы присваиваем переменной другое значение, ей присваивается новая ссылка, указывающая на объект нового значения. А прежний объект, если он больше не используется в программе, просто удаляется, т.е. задействуется механизм автоматической сборки мусора.
О приведении типов в Python
Довольно часто в программе требуется преобразовать значение одного типа данных в другой. Например, когда пользователь вводит данные для вычислений в строковом виде, перед вычислениями возникает необходимость преобразования строки в число (см. пример №5). Если этого не сделать, то мы получим либо ошибку (как в предыдущем примере), либо совсем неожиданный результат.
Для передачи в программу данных, вводимых пользователем с клавиатуры, используется встроенная функция input(), которая останавливает текущий поток программы до тех пор, пока пользователь не введет все данные и не нажмет Enter. При этом функции можно передавать в качестве аргумента строку с сообщением, которое будет выведено пользователю на экран. Таким сообщением обычно бывает подсказка о типе вводимых данных или призыв к какому-то действию.
pythonCodes
# Просим ввести 1-е число с плавающей точкой.
d = input('Введите 1-е вещественное число: ')
# Просим ввести 2-е число с плавающей точкой.
s = input('Введите 2-е вещественное число: ')
# Я ввел 2.44 и 3.27 (см. Результат).
# Преобразуем строки в вещественые числа.
d = float(d)
s = float(s)
# А вот теперь сложим
res = d + s
# и выведем результат на экран.
print('d + s =', res)
Введите 1-е вещественное число: 2.44
Введите 2-е вещественное число: 3.27
d + s = 5.71
Пример №5. Приведение типов в Python (часть 1).
В примере выше для преобразования строки в число мы использовали встроенную функцию float(). Кроме того, для преобразования различных типов данных между собой всегда доступны и другие встроенные функции (конструкторы типов): bool(), int(), complex(), str(), tuple(), list(), dict() или set() (см. пример №6). О каждой из них мы поговорим подробнее, когда будем рассматривать вопрос приведения типов в конце этой главы.
pythonCodes
# Преобразуем строку в список.
li = list('abc')
# Посмотрим, что получилось.
print('Строка -> список: ', li, end='\n\n')
# Вещественное число преобразуем в целое.
int_num = int(11.24)
print('float -> int: ', int_num)
# Строковое представление числа в число.
float_num = float("11.24")
print('"11.24" -> float: ', float_num, end='\n\n')
# Преобразуем что-то в логический тип.
bool_1 = bool(1)
print('1 -> bool: ', bool_1)
bool_2 = bool(0)
print('0 -> bool: ', bool_2)
# Строку с буквами в bool.
bool_3 = bool('яблоко')
print('str -> bool: ', bool_3)
# Пустой объект в bool ('', [], {} и т.д.).
bool_4 = bool([])
print('[] -> bool: ', bool_4, end='\n\n')
# А вот здесь получим ошибки преобразования.
# Число не является итерируемым объектом.
li_1 = list(5)
# Буквы не получится преобразовать, нужно число.
int_num = int('яблоко')
Строка -> список: ['a', 'b', 'c']
float -> int: 11
"11.24" -> float: 11.24
1 -> bool: True
0 -> bool: False
str -> bool: True
[] -> bool: False
'int' object is not iterable
Пример №6. Приведение типов в Python (часть 2).
Как можно было убедиться на примере, во избежание ошибок в процессе преобразования типов нужно следить за возможностью такого преобразования. В общем случае, например, один тип числа легко преобразуется в другие числа, итерируемые объекты – в другие итерируемые объекты, а в логический тип можно преобразовать вообще все что угодно.
Получение помощи по объектам Python
Ранее мы уже отмечали, что в языке Python повсюду присутствуют объекты, которые представляют собой данные и наборы операций (методы) для обработки этих данных. Методы и данные, кстати, называют атрибутами объекта. Доступ к атрибутам любого объекта осуществляется через точку и имя атрибута. А чтобы узнать, какие атрибуты имеет данный объект, можно воспользоваться очередной встроенной функцией dir(), которой в качестве аргумента следует передать требуемый объект. Результатом будет словарь со всеми атрибутами объекта (см. пример №7).
Если необходимо узнать количество элементов какой-нибудь последовательности или коллекции, например, строки или словаря, проще всего воспользоваться встроенной функцией len(), которой нужно передать требуемый объект в качестве аргумента.
pythonCodes
# Давайте создадим строковый объект.
str_1 = 'Конь в пальто!'
# Выведем все атрибуты на экран и поэкспериментируем с ними.
print(dir(str_1), end='\n\n')
# Поищем подстроку па (выведет нам 7, т.е. индекс первого
# вхождения подстроки в строке начиная с нуля).
print(str_1.find('па'))
# Переведем все символы строки в верхний регистр.
print(str_1.upper(), end='\n\n')
# Узнаем возможности типа int, используя его имя.
# Ведь даже сами типы – это тоже объекты!
d = dir(int)
# А сколько вообще атрибутов у целочисленного типа?
print('Количество атрибутов типа int:', len(d), end='\n\n')
# Выведем их все на экран (см. Результат).
print(d)
['__add__', '__class__', '__contains__', '__delattr__', '__dir__',
'__doc__', '__eq__', '__format__', '__ge__', '__getattribute__',
'__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__',
'__init_subclass__', '__iter__', '__le__', '__len__', '__lt__',
'__mod__', '__mul__', '__ne__', '__new__', '__reduce__',
'__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__',
'__sizeof__', '__str__', '__subclasshook__', 'capitalize',
'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs',
'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha',
'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower',
'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join',
'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace',
'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip',
'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title',
'translate', 'upper', 'zfill']
7
КОНЬ В ПАЛЬТО!
Количество атрибутов типа int: 71
['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__',
'__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__',
'__float__', '__floor__', '__floordiv__', '__format__', '__ge__',
'__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__',
'__init__', '__init_subclass__', '__int__', '__invert__', '__le__',
'__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__',
'__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__',
'__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__',
'__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__',
'__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__',
'__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__',
'__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__',
'as_integer_ratio', 'bit_length', 'conjugate', 'denominator',
'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']Пример №7. Получение атрибутов объектов.
Таким образом, если в процессе создания программы мы забудем, например, какие методы имеются в Python для обработки строк, всегда можно воспользоваться функцией dir(). Это касается объектов не только встроенных типов данных, но и созданных пользователем.
Но и это еще не все! Интерпретатор Python реально поставляется под ключ. Поэтому в комплекте имеется собственный встроенный справочник, что очень даже удобно (см. пример №8). Ведь типов данных довольно много и для каждого из них имеются не только общие, но и свои индивидуальные методы обработки этих данных. Так что, если информации предоставляемой функцией dir() становится недостаточно и хочется получить более подробную справку, следует обращаться за помощью к встроенной функции help(), передав ей в качестве аргумента интересующий нас объект.
Обратите внимание, что запись в коде, например, my_func означает имя функции и сам объект функции. А выражение my_func() означает вызов этой функции. Так вот, когда в качестве аргумента нужно передать объект функции, следует передавать только ее имя и не использовать скобки.
pythonCodes
# Давайте создадим строковый объект.
str_1 = 'Конь одел кеды!'
# А теперь получим подробную справку по методу find.
help(str_1.find)
# Просто отделим блоки информации.
print('\n\n')
# А давайте запросим подробную справку по всему типу.
help(str)
Help on built-in function find:
find(...) method of builtins.str instance
S.find(sub[, start[, end]]) -> int
Return the lowest index in S where substring sub is found,
such that sub is contained within S[start:end]. Optional
arguments start and end are interpreted as in slice notation.
Return -1 on failure.
Help on class str in module builtins:
class str(object)
| str(object='') -> str
| str(bytes_or_buffer[, encoding[, errors]]) -> str
|
| Create a new string object from the given object. If encoding or
| errors is specified, then the object must expose a data buffer
| that will be decoded using the given encoding and error handler.
| Otherwise, returns the result of object.__str__() (if defined)
| or repr(object).
| encoding defaults to sys.getdefaultencoding().
| errors defaults to 'strict'.
|
| Methods defined here:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return key in self.
|
| __eq__(self, value, /)
| Return self==value.
-- Далее --Пример №8. Получение справки по объектам.
Опять же, поскольку в Python все является объектами, даже сами типы и модули, то передав функции help() имя импортируемого из стандартной библиотеки модуля, можно получить подробную справку и по нему.
Следует иметь в виду, что на экран информация выводится частями. Поэтому желательно максимально уточнять запрос (как в примере выше), чтобы не приходилось многократно нажимать Enter для вывода очередного блока информации.
Краткие итоги параграфа
- Все данные в Python представлены в виде объектов, которые представляют собой выделенные области памяти со значениями данного типа и определенными для этих значений наборами операций.
- К базовым типам данных Пайтона относятся числа (int, float, complex), строки (str), списки (list), кортежи (tuple), словари (dict), множества (set), булевы значения (bool) и специальное значение None (NoneType).
- Python относится к языкам программирования с динамической типизацией данных, поэтому программисту не нужно объявлять тип переменной в исходном коде. Интерпретатор делает это автоматически во время присвоения переменной нового значения. При этом он самостоятельно контролирует объем памяти, распределяемый под вновь создаваемый объект.
- Переменные в Python хранят не само значение, а ссылки на объект этого значения.
- Для преобразования одного встроенного типа данных в другой можно пользоваться соответствующими функциями (конструкторами типов): bool(), int(), float(), complex(), str(), tuple(), list(), dict() или set(). Однако нужно быть внимательным и во избежание ошибок проверять возможность такого преобразования.
- Для получения списка атрибутов объекта предназначена встроенная функция dir(), которой в качестве аргумента должен передаваться требуемый объект. Результатом будет словарь со всеми атрибутами объекта.
- Для получения более подробной справки по объектам следует использовать встроенную функцию help(), которой в качестве аргумента также нужно передавать требуемый объект.
На этом краткое описание типов данных Python мы заканчиваем, посвятив более подробному рассмотрению каждого из перечисленных типов весь остаток второй главы.
Вопросы и задания для самоконтроля
1. Определите устно типы следующих значений: '123', [1,2,3], {1,2,3}, 123, {1: 1, 2: 2, 3: 3}, (1,2,3). Показать решение.
Ответ. '123' – строка (т.е. тип str), [1,2,3] – список (т.е. тип list), {1,2,3} – множество (т.е. тип set), 123 – целое число (т.е. тип int), {1: 1, 2: 2, 3: 3} – словарь (т.е. тип dict), (1,2,3) – кортеж (т.е. тип tuple).
2. Выполните предыдущее задание, организовав вывод типов на экран при помощи скрипта. Показать решение.
pythonCodes
# Присвоим значения переменным.
v_1 = '123'
v_2 = [1,2,3]
v_3 = {1,2,3}
v_4 = 123
v_5 = {1: 1, 2: 2, 3: 3}
v_6 = (1,2,3)
# Для определения типа значений используем функцию type(obj).
print("Тип ", v_1, ": ", type(v_1), sep='')
print("Тип ", v_2, ": ", type(v_2), sep='')
print("Тип ", v_3, ": ", type(v_3), sep='')
print("Тип ", v_4, ": ", type(v_4), sep='')
print("Тип ", v_5, ": ", type(v_5), sep='')
print("Тип ", v_6, ": ", type(v_6), sep='') Тип 123: <class 'str'>
Тип [1, 2, 3]: <class 'list'>
Тип {1, 2, 3}: <class 'set'>
Тип 123: <class 'int'>
Тип {1: 1, 2: 2, 3: 3}: <class 'dict'>
Тип (1, 2, 3): <class 'tuple'>
3. Переменной li присвоили список [1, 2, 3]. В ходе выполения программы в список были добавлены еще два значения и он принял вид [1, 2, 3, 4, 5]. На сколько изменился объем памяти, занимаемый переменной? Показать решение.
pythonCodes
# Импортируем модуль sys стандартной библиотеки.
import sys
# Узнаем исходный размер, занимаемый переменной.
li = [1, 2, 3]
vol_1 = sys.getsizeof(li)
# Узнаем конечный размер, занимаемый переменной.
li = [1, 2, 3, 4, 5]
vol_2 = sys.getsizeof(li)
# Вычисляем изменение объема.
v = vol_2 - vol_1
# Выводим результат на экран.
print('Объем изменился на ', v, ' байт.', sep='')Объем изменился на 16 байт.
4. Что такое динамическая типизация? Показать решение.
Ответ. Динамическая типизация – это прием, при котором переменная связывается с типом в момент присваивания значения, а не в момент объявления переменной.
5. Напишите код программы, которая будет запрашивать у пользователя два целых числа, а затем выводить на экран их произведение. Показать решение.
pythonCodes
# Просим ввести 1-е целое число.
d = input('Введите 1-е целое число: ')
# Просим ввести 2-е целое число.
s = input('Введите 2-е целое число: ')
# Преобразуем строки в целые числа.
d = int(d)
s = int(s)
# Перемножим их.
res = d*s
# И выведем результат на экран.
print('Произведение чисел равно ', res)6. У какого типа больше атрибутов: tuple или list? Сперва попытайтесь догадаться устно, а затем вычислите программно и выведите их атрибуты на экран. Показать решение.
Ответ. Поскольку кортежи относятся к неизменяемым последовательностям, то скорее всего у них будет меньше методов для обработки своих данных, чем у списков. Ведь списки могут изменяться, а значит для них должны быть доступны дополнительные методы, например, для удаления или добавления новых элементов. Это конечно все несколько субъективно, но тем не менее давайте проверим.
pythonCodes
# Получаем словарь атрибутов типа tuple.
t = dir(tuple)
# Выводим их количество на экран.
print('Количество атрибутов типа tuple:', len(t), end='\n\n')
# Выведем все атрибуты на экран.
print(t, end='\n\n')
# Получаем словарь атрибутов типа list.
li = dir(list)
# Выводим их количество на экран.
print('Количество атрибутов типа list:', len(li), end='\n\n')
# Выведем все атрибуты на экран.
print(li)Количество атрибутов типа tuple: 33 ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index'] Количество атрибутов типа list: 46 ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
7. Получите описание функции len, использовав встроенную справку. Показать решение.
pythonCodes
# Используем функцию help().
help(len)
Help on built-in function len in module builtins:
len(obj, /)
Return the number of items in a container.
8. Какая из рассмотренных нами функций len(), type(), print(), isinstance(), dir(), help() или input() содержится в модуле sys? Как мы можем получить доступ к ней? Показать решение.
Ответ. Все перечисленные функции являются встроенными и не требуют импорта модуля стандартной библиотеки sys. Но с одной такой функцией мы уже познакомились – это функция getsizeof(). Чтобы ее использовать, сперва нужно импортировать указанный модуль при помощи инструкции import sys.
Быстрый переход к другим страницам
- Синтаксис Python
- Введение в типы данных Python
- Числа в Python
- К содержанию учебника