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

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