Consejos para reducir el tamaño de los objetos de Python

Todos conocemos un inconveniente muy común de Python en comparación con lenguajes de programación como C o C++. Es significativamente más lento y no es muy adecuado para realizar tareas de uso intensivo de memoria, ya que los objetos de Python consumen mucha memoria. Esto puede resultar en problemas de memoria cuando se trata de ciertas tareas. Cuando la RAM se sobrecarga con tareas durante la ejecución y los programas comienzan a congelarse o a comportarse de manera poco natural, lo llamamos un problema de memoria.

Veamos algunas formas en las que podemos usar esta memoria de manera efectiva y reducir el tamaño de los objetos.

Uso de diccionarios integrados:

Todos estamos muy familiarizados con el tipo de datos de diccionario en Python. Es una forma de almacenar datos en forma de claves y valores. Pero cuando se trata de administración de memoria, el diccionario no es el mejor. De hecho, es lo peor. Veamos esto con un ejemplo:

# importing the sys library
import sys 
  
Coordinates = {'x':3, 'y':0, 'z':1}
  
print(sys.getsizeof(Coordinates))

288

Vemos que una instancia del diccionario de tipos de datos ocupa 288 bytes. Por lo tanto, consumirá una gran cantidad de memoria cuando tengamos muchas instancias:

por lo tanto, concluimos que el diccionario no es adecuado cuando se trata de programas con uso eficiente de la memoria.

Usando tuplas:

Las tuplas son perfectas para almacenar valores de datos inmutables y también son bastante eficientes en comparación con el diccionario para reducir el uso de memoria:

import sys
  
Coordinates = (3, 0, 1)
  
print(sys.getsizeof(Coordinates))

72

Por simplicidad, asumimos que los índices 0, 1, 2 representan x, y, z respectivamente. Entonces, de 288 bytes, bajamos a 72 bytes simplemente usando tupla en lugar de diccionario. Todavía no es muy eficiente. Si tenemos una gran cantidad de instancias, aún necesitaríamos una gran cantidad de memoria:

Usando la clase:

Al organizar el código dentro de las clases, podemos reducir significativamente el consumo de memoria en comparación con el uso de diccionario y tupla.

import sys
  
class Point:
  
    # defining the coordinate variables
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z
  
Coordinates = Point(3, 0, 1)
print(sys.getsizeof(Coordinates))

56

Vemos que el mismo programa ahora requiere 56 bytes en lugar de los 72 bytes anteriores. Las variables x, y y z consumen 8 bytes cada una, mientras que los 32 bytes restantes son consumidos por los códigos internos de Python. Si tenemos un mayor número de instancias, tenemos la siguiente distribución:

Entonces concluimos que las clases tienen una ventaja sobre el diccionario y la tupla cuando se trata de ahorrar memoria.

Nota al margen: la especificación de la función sys.getsizeof(object[, default]) dice: «Solo se tiene en cuenta el consumo de memoria directamente atribuido al objeto, no el consumo de memoria de los objetos a los que se refiere».

Así que en tu ejemplo:

class Point:
  
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z
  
Coordinates = Point(3, 0, 1)

el uso efectivo de la memoria del objeto Coordenadas es:
sys.getsizeof(Coordinates) +
sys.getsizeof(Coordinates.x) +
sys.getsizeof(Coordinates.y) +
sys.getsizeof(Coordinates.z) =
= 56 + 28 + 24 + 28 =
= 136

Consulte https://docs.python.org/3/library/sys.html .

Usando la clase de registro:

Recordclasses una biblioteca de Python bastante nueva. Viene con el soporte para registrar tipos que no está integrado en Python. Dado que recordclass es un módulo de terceros con licencia del MIT, primero debemos instalarlo escribiendo esto en la terminal:

pip install recordclass

Usemos recordclass para ver si ayuda aún más a reducir el tamaño de la memoria.

# importing the installed library
import sys
from recordclass import recordclass 
  
Point = recordclass('Point', ('x', 'y', 'z'))
  
Coordinates = Point(3, 0, 1)
print(sys.getsizeof(Coordinates))

Producción:

48

Entonces, el uso de recordclass redujo aún más la memoria requerida de una instancia de 56 bytes a 48 bytes. Esta será la distribución si tenemos un gran número de instancias:

Usando objetos de datos:

En el ejemplo anterior, al usar recordclass, incluso los valores basura se recopilan, por lo que se desperdicia memoria innecesaria. Esto significa que todavía hay un alcance de optimización. Eso es exactamente donde se usan los objetos de datos. La funcionalidad del objeto de datos viene bajo el módulo recordclass con una especialidad que no contribuye a ningún valor basura.

import sys
from recordclass import make_dataclass
  
Position = make_dataclass('Position', ('x', 'y', 'z'))
Coordinates = Position(3, 0, 1)
  
print(sys.getsizeof(Coordinates))

Producción:

40

Finalmente, vemos una reducción de tamaño de 48 bytes por instancia a 40 bytes por instancia. Por lo tanto, vemos que los objetos de datos son la forma más eficiente de organizar nuestro código cuando se trata de la menor utilización de memoria.