Язык Python - мощный язык программирования, он прост в изучении, имеет элегантный синтаксис и динамическую типизацию. Его можно было бы использовать больше в объектно-ориентированном программировании, и он был создан Гвидо ван Россумом, где Тим Петерс создал Дзен Python, чтобы описать небольшие правила, чтобы знать, как Python работает и творит чудеса за кулисами.

Итак, первое, что вам нужно понять, это то, что все в Python является объектом, и это говорит о том, что каждая переменная содержит экземпляр объекта, это означает, что когда вы инициализируете объект, ему назначается уникальный идентификатор объекта, а его тип определяется во время выполнения и однажды установленный не может измениться, но эти объекты могут быть изменяемыми или неизменяемыми в зависимости от того, в каком состоянии они находятся.

Теперь давайте посмотрим, что представляют собой объекты встроенных типов и являются ли они изменяемыми или неизменяемыми. Эта таблица может быть полезна для понимания типов, а также для понимания того, являются ли они изменяемыми или неизменяемыми.

Но как мы узнаем, является ли наша переменная изменяемым или неизменяемым объектом? Ответ прост: вы должны разбираться в функциях id () и type ().

Функции id () и type ()

Функция id () возвращает идентификатор объекта как целое число, и это целое число обычно соответствует местоположению объекта в памяти.

Функция type () возвращает тип объекта.

Давайте посмотрим на пример, который может помочь прояснить и увидеть, как работает

Как вы видите в предыдущей части, мы использовали оператор is, он сравнивает идентичность двух объектов. Давайте посмотрим еще один пример с type ()

Теперь мы знаем, как сравнить две простые строковые переменные, чтобы найти типы и идентификаторы. Используя эти две функции, мы можем проверить, что разные типы объектов связаны с переменными и как объекты могут быть изменены. Если вы не знаете, является ли объект изменяемым или неизменным, лучший трюк - это его идентичность (функция id ()).

Изменяемые и неизменяемые объекты

Итак, как мы обсуждали ранее, изменяемый объект может изменять свое состояние или содержимое, а неизменяемые объекты - нет.

Изменяемые объекты:

список, словарь, набор, байтовый массив

Неизменяемые объекты:

int, float, сложный, строка, кортеж, замороженный набор [примечание: неизменяемая версия набора], байты

Практический пример для определения изменчивости типов объектов

x = 10
x = y

Мы создаем объект типа int. идентификаторы x и y указывают на один и тот же объект.

id(x) == id(y)
id(y) == id(10)

если мы сделаем простую операцию

x = x + 1

В настоящее время

id(x) != id(y)
id(x) != id(10)

Объект, в котором был помечен x, будет изменен. объект 10 никогда не изменялся. Неизменяемые объекты нельзя изменять после создания

В случае изменяемых объектов

m = list([1, 2, 3])
n = m

Мы создаем объект типа list. идентификаторы m и m, привязанные к одному объекту списка, который представляет собой набор из трех неизменяемых объектов типа int.

id(m) == id(n)

Теперь выталкивание элемента из объекта списка действительно меняет объект,

m.pop()

id объекта не будет изменен

id(m) == id(n)

m и n будут указывать на один и тот же объект списка после модификации. Теперь объект списка будет содержать [1, 2].

Итак, что мы видели так далеко из приведенных выше примеров?

  • Python по-разному обрабатывает изменяемые и неизменяемые объекты.
  • Доступ к неизменяемым объектам быстрее, чем к изменяемым объектам.
  • Изменяемые объекты отлично подходят, когда вам нужно изменить размер объекта, список примеров, dict и т. Д. Неизменяемые объекты используются, когда вам нужно гарантировать, что созданный вами объект всегда останется прежним.
  • Неизменяемые объекты принципиально дорого «изменять», потому что это требует создания копии. Изменение изменяемых объектов дешево.

Исключения в неизменности.

Как обсуждалось ранее, любимые кортежи контейнеров Python неизменяемы. Это означает, что значение tuple не может быть изменено после его создания. Но «значение» кортежа - это фактически последовательность имен с неизменяемыми привязками к объектам. Ключевым моментом является то, что нельзя изменить привязки, а не объекты, к которым они привязаны.

Рассмотрим кортеж t = (‘holberton’, [1, 2, 3])

Вышеупомянутый кортеж t содержит элементы разных типов данных, первый из которых является неизменяемой строкой, а второй - изменяемым списком. Сам кортеж не является изменяемым. т.е. у него нет методов для изменения его содержимого. Точно так же строка неизменна, потому что строки не имеют методов изменения. Но у объекта списка есть методы изменения, поэтому его можно изменить. Это тонкий, но тем не менее важный момент: «значение» неизменяемого объекта не может измениться, а составляющие объекты могут.

Как объекты передаются в функции

Для нас важно знать разницу между изменяемыми и неизменяемыми типами и то, как они обрабатываются при передаче в функции. Эффективность памяти сильно зависит от использования правильных объектов.

Например, если изменяемый объект вызывается по ссылке в функции, он может изменить саму исходную переменную. Следовательно, чтобы этого избежать, исходную переменную необходимо скопировать в другую переменную. Неизменяемые объекты можно вызывать по ссылке, потому что их значение в любом случае нельзя изменить.

def updateList(list1):
    list1 += [10]n = [5, 6]
print(id(n))                  # 140312184155336updateList(n)
print(n)                      # [5, 6, 10]
print(id(n))                  # 140312184155336

Как видно из приведенного выше примера, мы вызвали список с помощью вызова по ссылке, поэтому изменения вносятся в сам исходный список.

Давайте посмотрим на другой пример:

def updateNumber(n):
    print(id(n))
    n += 10b = 5
print(id(b))                   # 10055680
updateNumber(b)                # 10055680
print(b)                       # 5

В приведенном выше примере в функцию передается тот же объект, но значение переменных не меняется, даже если объект идентичен. Это называется пройти по значению. Так что же именно здесь происходит? Когда значение вызывается функцией, передается только значение переменной, а не сам объект. Таким образом, переменная, ссылающаяся на объект, не изменяется, но изменяется сам объект, но только в пределах области действия функции. Значит изменение не отражено.

NSMALLPOSINTS и NSMALLNEGINTS

Последнее, что нужно знать и понимать в Python - это два макроса, определенные для наиболее часто используемых целых чисел. Этот макрос на самом деле представляет собой массив из 262 целых чисел для максимально быстрого доступа, они выделяются сразу при инициализации ваших NSMALLPOSINTS и NSMALLNEGINTS, диапазон значений от -5 (включительно) до 257 (не включительно).