Эта статья будет коротким чтением, мы сосредоточимся на том, как память управляется в Python для таких объектов, как список и кортеж И что может быть ключевым выводом.
Давайте начнем!
Список
Список Python, как мы все знаем, является изменчивым динамическим массивом, который ведет себя как связанный список. Давайте посмотрим на какой -то код для создания и обновления списка:
# ./list_1.py
l = [1,2,3] # A new list gets created
print('Initial List', l)
l.append(4) # Updating list using in-built append method
print('Append 4, List updated to', l)
l.pop() # Pop last item
print('Pop, List updated to', l)
l += [5, 6] # Updating list by adding a new list to given list
print('Add new list, List updated to', l)
Следующее будет выход:
Initial List [1, 2, 3] Append 4, List updated to [1, 2, 3, 4] Pop, List updated to [1, 2, 3] Add new list, List updated to [1, 2, 3, 5, 6] >>>
Теперь давайте посмотрим, что произойдет в памяти, когда мы запустим приведенный выше сценарий, здесь мы будем использовать Sys Чтобы помочь нам в просмотре информации, связанной с системой:
# ./list_2.py
import sys
l = [1,2,3] # A new list gets created
print('Initial List', l)
print('Initial List Address', id(l))
print('Initial List Memory', sys.getsizeof(l))
l.append(4) # Updating list using in-built append method
print('Append 4, List updated to', l)
print('Append 4, List Address', id(l))
print('Append 4, List Memory', sys.getsizeof(l))
l.pop() # Pop last item
print('Pop, List updated to', l)
print('Pop, List Address', id(l))
print('Pop, List Memory', sys.getsizeof(l))
l += [5, 6] # Updating list by adding a new list to given list
print('Add new list, List updated to', l)
print('Add new list, List Address', id(l))
print('Add new list, List Memory', sys.getsizeof(l))
Сначала посмотрим на вывод:
Initial List [1, 2, 3] Initial List Address 139688582615624 Initial List Memory 88 Append 4, List updated to [1, 2, 3, 4] Append 4, List Address 139688582615624 Append 4, List Memory 120 Pop, List updated to [1, 2, 3] Pop, List Address 139688582615624 Pop, List Memory 120 Add new list, List updated to [1, 2, 3, 5, 6] Add new list, List Address 139688582615624 Add new list, List Memory 120 >>>
Следующие моменты мы можем выяснить после просмотра вывода:
- Первоначально, когда список был создан, у него была память о
88байты, с 3 элементами. - Позже, после добавления элемента
4В список память изменяется на120Байты, что означает больше блоков памяти было связано с спискомl. - Даже после выхода последнего элемента память созданных блоков остается прежней и все еще прикрепленной к списку
l. И когда мы добавляем еще один список с еще 2 элементами в данное списокl, мы видим, что занятая память все же120байты. Следовательно, мы можем сделать вывод, что он ведет себя больше как динамический массив, который обновляет размер списка, чтобы содержать больше элементов одновременно, чтобы избежать повторяющихся обратных вызовов (для создания и прикрепления нового адреса памяти) при каждой вставке нового элемента. - Мы также замечаем, что адрес списка остается прежним, даже если мы делаем добавление, POP или добавляем в него новый список (если мы не назначаем его новой переменной). Это выступает за природу изменчивости списков Python (это означает более или менее, что на том же адресе мы можем обновить значения или расширить их дальше).
Теперь давайте посмотрим на кортежи.
Кортеж
Python Tuple, как мы все знаем, неизменны и не расширяются в памяти дальше после первоначального объявления. Теперь давайте посмотрим на тот же сценарий, но на кортежи:
# ./tuple_1.py
import sys
t = (1,2,3) # A new tuple gets created
print('Initial Tuple', t)
print('Initial Tuple Address', id(t))
print('Initial Tuple Memory', sys.getsizeof(t))
t += (5, 6,) # Updating tuple by adding a new tuple to given tuple
print('Add new tuple, Tuple updated to', t)
print('Add new tuple, Tuple Address', id(t))
print('Add new tuple, Tuple Memory', sys.getsizeof(t))
Выход:
Initial Tuple (1, 2, 3) Initial Tuple Address 140452527817280 Initial Tuple Memory 72 Add new tuple, Tuple updated to (1, 2, 3, 5, 6) Add new tuple, Tuple Address 140452528572728 Add new tuple, Tuple Memory 88 >>>
Следующие моменты мы заметили после просмотра вывода:
- Поскольку кортежи неизменны, после создания не могут быть обновлены, если только новый кортеж не будет добавлен к предыдущему, что привело к созданию нового кортежа.
- Как только кортеж будет создан, его выделенная память не будет изменена.
- Обновляя кортеж после добавления еще одного кортежа, обновляет адрес полученного кортежа, это выступало за свой свойство неизменности.
- Мы видим, что это выделяет
72байты для 3 значений и88Для 6 значений он не выделяет ненужное количество памяти, только то, что требуется, выделяется.
Давайте посмотрим на некоторые разные точки.
Разное
Что происходит, когда мы создаем пустой список и пустой кортеж?
# ./misc.py
import sys
t1 = ()
t2 = ()
l1 = []
l2 = []
print('List l1 address', id(l1))
print('List l2 address', id(l2))
print('List l1 memory', sys.getsizeof(l1))
print('List l2 memory', sys.getsizeof(l2))
print('List t1 address', id(t1))
print('List t2 address', id(t2))
print('List t1 memory', sys.getsizeof(t1))
print('List t2 memory', sys.getsizeof(t2))
Что мы получили?
List l1 address 139766851756616 List l2 address 139766851761800 List l1 memory 64 List l2 memory 64 List t1 address 139766871547976 List t2 address 139766871547976 List t1 memory 48 List t2 memory 48 >>>
Что мы нашли?
- Создание 2 пустых списков имеет одинаковый объем памяти, выделенного, тогда как адрес обоих списков отличается. Это имеет смысл, потому что адрес списка должен будет действовать как изменчивое и не может быть одинаковым в определенное время, что означает, что 2 разных списка будут разными, если они не одинаковы (не в значении, а с точки зрения ссылки).
- Создание 2 пустых кортежей имеет одинаковый объем памяти, и это будет указывать на один и тот же адрес. Это имеет смысл из -за его свойства неизменности. Рассмотрим целое число
1Значение в питоне, которая неизменна и всегда указывает на один и тот же адрес, если не будет изменено на какое -то другое целое число. Точно так же начальный пустой кортеж всегда будет указывать на один и тот же адрес, если не будет изменено на какой -либо другой кортеж.
Ну, это все от меня.
Мы исследовали довольно много моментов о том, как распределяется память и как ее можно управлять на Python.
Чтобы узнать больше об управлении памятью, я призываю вас изучить их код, доступный на Python’s Репо Анкет
Чувствуете, что трудно пройти исходный код Python? Не волнуйтесь, мы всегда можем использовать доступные Sys Методы модуля и другие функции, такие как id Развивать понимание того, что может произойти за кулисами.
Только начинаете путешествие с открытым исходным кодом? Не забудьте проверить Привет, открыть Источник
Хотите продемонстрировать свой Python Project или просто для изучения? Проверьте Потрясающие репо с питоном
Хотите сделать простую и потрясающую игру с нуля? Проверьте Понгпонг
Хочу
++Ваш профиль GitHub Readme? Проверьте Цитата – Ридме
До следующего раза!
Намасте 🙏
Оригинал: “https://dev.to/siddharth2016/python-list-vs-tuple-memory-management-4056”