У нас есть 23 ответов на вопрос Сколько места занимает Python? Скорее всего, этого будет достаточно, чтобы вы получили ответ на ваш вопрос.
Содержание
- Как узнать сколько памяти занимает программный код питон?
- Как питон использует память?
- Сколько весит строка Python?
- Сколько места занимает Python? Ответы пользователей
- Сколько места занимает Python? Видео-ответы
Отвечает Сахо Архипов
Пустая строка в Python в 64 битной среде, занимает 49 байт! Затем потребление памяти увеличивается за счет увеличения полезного размера значения. В 64-битном С размер пустого std::list() равен 16 байт и это в 4 раза меньше, чем в Python.Mar 18, 2021
Как узнать сколько памяти занимает программный код питон?
Функция deep_getsizeof() getsizeof() может только сказать вам, сколько памяти занимает примитивный объект, давайте посмотрим на более адекватное решение. Функция deep_getsizeof() рекурсивно выполняет детализацию и вычисляет фактическое использование памяти графом объектов Python.
СКОЛЬКО ВРЕМЕНИ НУЖНО, ЧТОБЫ ВЫУЧИТЬ PYTHON?
Как питон использует память?
При запуске Python-программы создается новый процесс, в рамках которого операционная система выделяет пул ресурсов, включая виртуальное адресное пространство. В эту память загружается интерпретатор Python вместе со всеми необходимыми ему для работы данными, включая код вашей программы.
Сколько весит строка Python?
Пустая строка в Python в 64 битной среде, занимает 49 байт! Затем потребление памяти увеличивается за счет увеличения полезного размера значения. В 64-битном С размер пустого std::list() равен 16 байт и это в 4 раза меньше, чем в Python. Например, пустой словарь в С занимает 48 байт.
Источник: querybase.ru
Вес Python: что входит в состав и как это влияет на производительность
Python – один из самых популярных языков программирования в мире. В этой статье мы рассмотрим, сколько весит Python, что входит в состав его дистрибутива и как это может влиять на производительность приложений, написанных на этом языке.
Что входит в состав дистрибутива Python?
- Интерпретатор Python;
- Стандартная библиотека;
- Дополнительные модули и пакеты.
Сколько весит Python?
Точный вес дистрибутива Python зависит от его версии и используемой операционной системы. В целом, размер установленного Python может составлять от 50 до 300 Мб. Для оценки веса конкретной версии Python рекомендуется обратиться к официальной документации или произвести установку на своем компьютере.
Как влияет вес Python на производительность?
Вес Python сам по себе не является прямым фактором, влияющим на производительность приложений. Однако стоит учитывать, что больший вес дистрибутива может замедлить процесс установки и занимать больше места на диске.
Важным фактором, влияющим на производительность приложений на Python, является выбор используемых библиотек и пакетов. Использование оптимизированных и эффективных решений может значительно повысить производительность вашего приложения, даже если дистрибутив Python имеет большой размер.
СКОЛЬКО ВЕСИТ ПИТОН?
Заключение
Итак, вес Python зависит от версии, используемой операционной системы и включенных компонентов. Хотя размер дистрибутива может влиять на занимаемое место на диске и время установки, производительность приложений напрямую от этого не зависит. Важно выбирать оптимальные библиотеки и пакеты для вашего проекта, чтобы обеспечить высокую производительность и эффективность работы.
Python продолжает развиваться и улучшаться с каждой новой версией, и разработчики стараются оптимизировать его для различных платформ и задач. Используя этот мощный и гибкий язык программирования, вы сможете создавать разнообразные приложения с высокой производительностью и удобством разработки.
Источник: www.articleshub.net
Использование памяти в Python
Меня часто донимали размышление о том, насколько эффективно Python использует память по сравнению с другими языками программирования. Например, сколько памяти нужно, чтобы работать с 1 миллионом целых чисел? А с тем же количеством строк произвольной длины?
Как оказалось, в Python есть возможность получить необходимую информацию прямо из интерактивной консоли, не обращаясь к исходному коду на C (хотя, для верности, мы туда все таки заглянем).
Удовлетворив любопытство, мы залезем внутрь типов данных и узнаем, на что именно расходуется память.
Все примеры были сделаны в CPython версии 2.7.4 на 32 битной машине. В конце приведена таблица для потребности в памяти на 64 битной машине.
Необходимые инструменты
sys.getsizeof и метод __sizeof__()
Первый инструмент, который нам потребуется находится в стандартной библиотеки sys. Цитируем официальную документацию:
sys.getsizeof(объект[, значение_по_умолчанию])
Возвращает размер объекта в байтах.
Если указано значение по умолчанию, то оно вернется, если объект не предоставляет способа получить размер. В противном случае возникнет исключение TypeError.
Getsizeof() вызывает метод объекта __sizeof__ и добавляет размер дополнительной информации, которая хранится для сборщика мусора, если он используется.
Алгоритм работы getsizeof(), переписанной на Python, мог бы выглядеть следующем образом:
Py_TPFLAGS_HAVE_GC = 1
Где PyGC_Head — элемент двойного связанного списка, который используется сборщиком мусора для обнаружения кольцевых ссылок. В исходном коде он представлен следующей структурой:
typedef union _gc_head < struct < union _gc_head *gc_next; union _gc_head *gc_sourcev; Py_ssize_t gc_refs; >gc; long double dummy; > PyGC_Head;
Размер PyGC_Head будет равен 12 байт на 32 битной и 24 байта на 64 битной машине.
Попробуем вызвать getsizeof() в консоли и посмотрим, что получится:
>>> import sys >>> GC_FLAG = 1 >> sys.getsizeof(1) 12 >>> (1).__sizeof__() 12 >>> bool(type(1).__flags__ >> sys.getsizeof(1.1) 16 >>> (1.1).__sizeof__() 16 >>> bool(type(1.1).__flags__ >> sys.getsizeof(») 21 >>> ».__sizeof__() 21 >>> bool(type(»).__flags__ >> sys.getsizeof(‘hello’) 26 >>> sys.getsizeof(tuple()) 24 >>> tuple().__sizeof__() 12 >>> bool(type(tuple()).__flags__ >> sys.getsizeof(tuple((1, 2, 3))) 36
За исключением магии с проверкой флагов, все очень просто.
Как видно из примера, int и float занимают 12 и 16 байт соответственно. Str занимает 21 байт и еще по одному байту на каждый символ содержимого. Пустой кортеж занимает 12 байт, и дополнительно 4 байта на каждый элемент. Для простых типов данных (которые не содержат ссылок на другие объекты, и соответственно, не отслеживаются сборщиком мусора), значение sys.getsizeof равно значению, возвращаемого методом __sizeof__().
id() и ctypes.string_at
Теперь выясним, на что именно расходуется память.
Для этого нужно нам нужны две вещи: во-первых, узнать, где именно хранится объект, а во-вторых, получить прямой доступ на чтение из памяти. Несмотря на то, что Python тщательно оберегает нас от прямого обращения к памяти, это сделать все таки возможно. При этом нужно быть осторожным, так как это может привести к ошибке сегментирования.
Встроенная функция id() возвращает адрес памяти, где храниться начала объекта (сам объект является C структурой)
>>> obj = 1 >>> id(obj) 158020320
Чтобы считать данные по адресу памяти нужно воспользоваться функцией string_at из модуля ctypes. Ее официальное описание не очень подробное:
ctypes.string_at(адрес[, длина])
Это функция возвращает строку, с началом в ячейки памяти «адрес». Если «длина» не указана, то считается что строка zero-terminated,
Теперь попробуем считать данные по адресу, который вернул нам id():
>>> import ctypes >>> obj = 1 >>> sys.getsizeof(obj) 12 >>> ctypes.string_at(id(obj), 12) ‘ux01x00x00 xf2x08x00x00x00x001x00x00x00’
Вид шестнадцатеричного кода не очень впечатляет, но мы близки к истине.
Модель Struct
Для того чтобы представить вывод в значения, удобные для восприятия, воспользуемся еще одним модулем. Здесь нам поможет функция unpack() из модуля struct.
struct
Этот модуль производит преобразование между значениями Python и структурами на C, представленными в виде строк.
struct.unpack(формат, строка)
Разбирает строку в соответствие с данным форматов. Всегда возвращает кортеж, даже если строка содержит только один элемент. Строка должна содержать в точности то количество информации, как описано форматом.
Форматы данных, которые нам потребуются.
| символ | Значение C | Значение Python | Длина на 32битной машине |
| c | char | Строка из одного символа | 1 |
| i | int | int | 4 |
| l | long | int | 4 |
| L | unsigned long | int | 4 |
| d | double | float | 8 |
Теперь собираем все вместе и посмотрим на внутреннее устройство некоторых типов данных.
Int
>>> obj = 1 >>> sys.getsizeof(obj), obj.__sizeof__() (12, 12) >>> struct.unpack(‘LLl’, ctypes.string_at(id(obj), 12)) (373, 136770080, 1)
О формате значений несложно догадаться.
Первое число (373) — количество указателей, на объект.
>>> obj2 = obj >>> struct.unpack(‘LLl’, ctypes.string_at(id(obj), 12)) (374, 136770080, 1)
Как видно, число увеличилось на единицу, после того как мы создали еще одну ссылку на объект.
Второе число (136770080) — указатель (id) на тип объекта:
>>> type(obj) >>> id(type(obj) ) 136770080
Третье число (1) — непосредственно содержимое объекта.
>>> obj = 1234567 >>> struct.unpack(‘LLl’, ctypes.string_at(id(obj), 12)) (1, 136770080, 1234567)
Наши догадки можно подтвердить, заглянув в исходный код CPython
typedef struct < PyObject_HEAD long ob_ival; >PyIntObject;
Здесь PyObject_HEAD — макрос, общий для всех встроенных объектов, а ob_ival — значение типа long. Макрос PyObject_HEAD добавляет счетчик количества указателей на объект и указатель на родительский тип объекта — как раз то, что мы и видели.
Float
Число с плавающей запятой очень похоже на int, но представлено в памяти C значением типа double.
typedef struct < PyObject_HEAD double ob_fval; >PyFloatObject;
В этом легко убедиться:
>>> obj = 1.1 >>> sys.getsizeof(obj), obj.__sizeof__() (16, 16) >>> struct.unpack(‘LLd’, ctypes.string_at(id(obj), 16) (1, 136763968, 1.1)
Строка (Str)
Строка представлена в виде массива символов, оканчивающимся нулевым байтом. Также в структуре строки отдельного сохраняется ее длина, хэш от ее содержания и флаг, определяющий, хранится ли она во внутреннем кэше interned.
typedef struct < PyObject_VAR_HEAD long ob_shash; # хэш от строки int ob_sstate; # находится ли в кэше? char ob_sval[1]; # содержимое строки + нулевой байт >PyStringObject;
Макрос PyObject_VAR_HEAD включает в себя PyObject_HEAD и добавляет значение long ob_ival, в котором хранится длина строки.
>>> obj = ‘hello world’ >>> sys.getsizeof(obj), obj.__sizeof__() (32, 32) >>> struct.unpack(‘LLLli’ + ‘c’ * (len(obj) + 1), ctypes.string_at(id(obj), 4*5 + len(obj) + 1)) (1, 136790112, 11, -1500746465, 0, ‘h’, ‘e’, ‘l’, ‘l’, ‘o’, ‘ ‘, ‘w’, ‘o’, ‘r’, ‘l’, ‘d’, ‘x00’)
Четвертое значение соответствует хэшу от строки, в чем нетрудно убедиться.
>>> hash(obj) -1500746465
Как видно, значение sstate равно 0, так что строка сейчас не кэшируется. Попробуем ее добавить в кэш:
>>> intern(obj) ‘hello world’ >>> struct.unpack(‘LLLli’ + ‘c’ * (len(obj) + 1), ctypes.string_at(id(obj), 4*5 + len(obj) + 1)) (2, 136790112, 11, -1500746465, 1, ‘h’, ‘e’, ‘l’, ‘l’, ‘o’, ‘ ‘, ‘w’, ‘o’, ‘r’, ‘l’, ‘d’, ‘x00’)
Кортеж (Tuple)
Кортеж представлен в виде массива из указателей. Так как его использование может приводить к возникновению кольцевых ссылок, он отслеживается сборщиком мусора, на что расходуется дополнительная память (об этом нам напоминает вызов sys.getsizeof())
Структура tuple похоже на строку, только в ней отсутствуют специальные поля, кроме длины.
typedef struct < PyObject_VAR_HEAD PyObject *ob_item[1]; >PyTupleObject;
>>> obj = (1,2,3) >>> sys.getsizeof(obj), obj.__sizeof__() (36, 24) >>> struct.unpack(‘LLL’+’L’*len(obj), ctypes.string_at(id(obj), 12+4*len(obj))) (1, 136532800, 3, 146763112, 146763100, 146763088) >>> for i in obj: print i, id(i) 1 146763112 2 146763100 3 146763088
Как видим из примера, последние три элементы кортежа являются указателями на его содержимое.
Остальные базовые типы данных (unicode, list, dict, set, frozenset) можно исследовать аналогичным образом.
Что в итоге?
| Тип | Имя в CPython | формат | Формат, для вложенных объектов | Длина на 32bit | Длина на 64bit | Память для GC* |
| Int | PyIntObject | LLl | 12 | 24 | ||
| float | PyFloatObject | LLd | 16 | 24 | ||
| str | PyStringObject | LLLli+c*(длина+1) | 21+длина | 37+длина | ||
| unicode | PyUnicodeObject | LLLLlL | L*(длина+1) | 28+4*длина | 52+4*длина | |
| tuple | PyTupleObject | LLL+L*длина | 12+4*длина | 24+8*длина | Есть | |
| list | PyListObject | L*5 | L*длину | 20+4*длина | 40+8*длина | Есть |
| Set/ frozenset |
PySetObject | L*7+(lL)*8+lL | LL* длина | ( (>5 элементов) 100+8*длина | ( (>5 элементов) 200+16*длина | Есть |
| dict | PyDictObject | L*7+(lLL)*8 | lLL*длина | ( (>5 элементов) 124+12*длина | ( (>5 элементов) 248+24*длина | Есть |
* Добавляет 12 байт на 32 битной машине и 32 байта на 64 битной машине