loading...

26.04.2018

Уроки Python: Типы данных Python. Mutable и immutable типы данных.

В данной статье мы рассмотрим типы данных в языке Python — какие существуют типы, чем они отличаются и что такое изменяемые/неизменяемые типы данных (mutable и immutable), а так же что такое динамическая типизация.

Динамическая типизация

Начнём с последнего пункта — динамическая типизация.
Наверняка многие знают что в языках типа C++, Java используется статическая типизация.
Поэтому в этих языках, чтобы использовать переменную, нам требуется сначала объявить её с требуемым типом, например:

int a = 1;

Переменная a останется переменной типа int на протяжении выполнении всей программы и больше в переменную a нельзя записать значение другого типа (например, строку).
Расписывать плюсы и минусы каждого подхода я не буду в данной статье (т. к. это потянет на отдельную полноценную статью). В принципе вы можете легко найти их в интернете.

А вот в Python используется динамическая типизация. Что же такое динамическая типизация?
Википедия даёт такое определение динамической типизации:

Динами́ческая типиза́ция — приём, широко используемый в языках программирования и языках спецификации, при котором переменная связывается с типом в момент присваивания значения, а не в момент объявления переменной. Таким образом, в различных участках программы одна и та же переменная может принимать значения разных типов.

Собственно, это мы и наблюдаем в Python, когда пишем такой код:

a = 5
a = 'hello'

Здесь не будет никаких ошибок и код полностью корректен.
Вот несколько основ динамической типизации:

  • любой объект является ссылкой
  • типом объекта является то, на что он ссылается
  • тип объекта может меняться в процессе выполнения кода, если ссылка начинает ссылаться на другой объект (см. пример выше).

Но раз переменная может в любой момент поменять свой тип — как тогда узнать какой сейчас тип у данной переменной? Для этих целей в Python есть встроенная функция type():

a = 5
print(type(a))

a = 5.1
print(type(a))

a = 'hello'
print(type(a))

Листинг 1
Данный код выведет следующий результат:

<class 'int'>
<class 'float'>
<class 'str'>

Как видим — с помощью функции type() можно узнать текущий тип переменной.
И тут мы переходим ко второму вопросу — какие существуют встроенные типы данных Python?

Типы данных Python.

Вот список основных встроенных типов данных:

  • Boolean (bool) — тут всё просто: True (истина) или False (ложь);
  • Integer (int) — целые числа;
  • Float (float) — числа с плавающей точкой;
  • String (str) — строка;
  • Bytes (bytes) — последовательность байт (новый тип Python3);
  • List (list) — список;
  • Tuple (tuple) — кортеж;
  • Set (set) — множество;
  • Dictionary (dict) — словарь.

По правде типов данных в Python больше, но не будем на этом сейчас заострять внимание.
Чтобы проверить все эти типы можете выполнить такой код:

a = True
print(type(a))
 
a = 5
print(type(a))
 
a = 5.1
print(type(a))
 
a = 'hello'
print(type(a))
 
a = b'123'
print(type(a))
 
a = [1, 2, 3]
print(type(a))
 
a = (1, 2, 3)
print(type(a))
 
a = {1, 2, 3}
print(type(a))
 
a = {1: 'a', 2: 'b', 3: 'c'}
print(type(a))

Листинг 2
Он должен вывести:

<class 'bool'>
<class 'int'>
<class 'float'>
<class 'str'>
<class 'bytes'>
<class 'list'>
<class 'tuple'>
<class 'set'>
<class 'dict'>

В принципе, сложностей в работе с данными типами возникнуть не должно. Но я всё же считаю что каждый тип (особенно list, tuple, set, dict) заслуживают по отдельной статье, поэтому мы их рассмотрим более детально в следующих статьях этого цикла.

Mutable и immutable типы данных

В Python все типы данных делятся на 2 вида:

  • Изменяемые (mutable)
  • Неизменяемые (immutable)

Изменяемые:

  • Список (list)
  • Множество (set)
  • Словарь (dict)

Неизменяемые:

  • Строка (str)
  • Кортеж (tuple)
  • Числа (int, float)
  • Фиксированное множество (frozenset)
  • Байты (bytes)

Я думаю из названий «изменяемые» и «неизменяемые» уже становится понятно, чем отличаются эти 2 вида. Изменяемые типы данных — это те типы данных, которые вы можете изменить после создания данного объекта. Для того чтобы это проверить запустите следующий код:

a = [1, 2, 3]  # list
b = {5, 4, 3}  # set
c = {1: 'h', 2: 'e', 3: 'l', 4: 'l'}  # dict
 
print(a)
print(b)
print(c)
 
print('-' * 20)
 
a.append(4)
b.add(2)
c[5] = 'o'
 
print(a)
print(b)
print(c)

Листинг 3
Данный код выведет:

[1, 2, 3]
{3, 4, 5}
{1: 'h', 2: 'e', 3: 'l', 4: 'l'}
--------------------
[1, 2, 3, 4]
{2, 3, 4, 5}
{1: 'h', 2: 'e', 3: 'l', 4: 'l', 5: 'o'}

Как видим — мы без проблем смогли изменить данные.

Неизменяемые типы данных — это те типы данных, которые нельзя изменить в процессе работы программы. Давайте рассмотрим строки:

a = 'hello'
print(a)
 
a[5] = '!'
print(a)

Листинг 4
Данный код упадёт с ошибкой:

Traceback (most recent call last):
  File "immutable.py", line 4, in <module>
    a[5] = '!'
TypeError: 'str' object does not support item assignment

Как мы видим — строку нельзя изменять.
Но наверняка многие из вас скажут что они меняли строку! Это легко делается с помощью конкатенации:

a = 'hello'
print(a)
 
a = a + '!'
print(a)

Листинг 5
И вправду, такой код выведет:

hello
hello!

Но на самом деле Python здесь не изменил строку, он просто соединил 2 строки, создал новую строку, и присвоил её переменной a. Так что изменения строки здесь не было.

Изменяемость типа является важным свойством, так как от этого зависит — может ли данный тип использоваться как ключ в словаре (dict) или нет. Но это мы так же рассмотрим в следующих статьях, посвящённых типам данных Python.

На этом всё.

Как всегда жду ваших комментариев и замечаний — можете писать здесь или лично мне в социальных сетях. Все контакты указаны в нижней части сайта и на главной странице.

Posted in БлогTaggs:
Write a comment