okpython.net
Все для начинающих

Введение в типы данных 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 повсюду присутствуют объекты, которые представляют собой данные и наборы операций (методы) для обработки этих данных. Методы и данные, кстати, называют атрибутами объекта. Но как можно получить доступ к этим самым атрибутам? В Python все очень просто, и этот случай не исключение. Доступ к атрибутам любого объекта осуществляется через точку и имя атрибута (см. пример №7). А чтобы узнать, какие атрибуты имеет данный объект, можно воспользоваться очередной встроенной функцией dir(), которой в качестве аргумента следует передать требуемый объект. Результатом будет словарь со всеми атрибутами объекта.

Если необходимо узнать количество элементов какой-нибудь последовательности или коллекции, например, строки или словаря, проще всего воспользоваться встроенной функцией 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('', end='\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 мы заканчиваем, посвятив более подробному рассмотрению каждого из перечисленных типов весь остаток второй главы.


Помогите проекту, подпишитесь!

Подписка на учебные материалы сайта оформляется сроком на один год и стоит около 15 у.е. После подписки вам станут доступны следующие возможности.

  • Доступ ко всем ответам на вопросы и решениям задач.
  • Возможность загрузки учебных кодов и программ на свой компьютер.
  • Доступ ко всем тренажерам и видеоурокам (когда появятся).
  • Возможность внести свой скромный вклад в развитие проекта и мира во всем мире, а также выразить свою благодарить автору за его труд. Нам очень нужна ваша поддержка!

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.

Быстрый переход к другим страницам