Python: atributo orientado a objetos, método de clase, método estático, diferencia de método de instancia y uso detallado

I. Introducción

• En la programación orientada a objetos de Python, los atributos de clase y los atributos de instancia son dos conceptos diferentes y tienen diferentes alcances y usos.
• Hay tres métodos en la programación orientada a objetos en Python: métodos de instancia, métodos de clase y métodos estáticos. Las diferencias entre ellos se reflejan principalmente en la forma en que se pasan y llaman los parámetros.

2. Orientado a objetos: atributos de clase y atributos de instancia

1. Diferencia

En Python, la diferencia entre los atributos de clase y los atributos de instancia son sus diferentes alcances.

• Un atributo de clase es un atributo que pertenece a un objeto de clase. Su valor es el mismo para todas las instancias de la clase. Se puede acceder a los atributos de clase a través del nombre de la clase o el nombre de la instancia .
• Los atributos de instancia son atributos que pertenecen a objetos de instancia y cada instancia puede tener su propio valor de atributo. Solo se puede acceder a las propiedades de la instancia a través del nombre de la instancia .

2. Código de muestra

class MyClass:
    class_attr = "I am a class attribute"

    def __init__(self, ins_attr):
        self.ins_attr = ins_attr


if __name__ == '__main__':
    obj1 = MyClass("I am an instance attribute of obj1")
    obj2 = MyClass("I am an instance attribute of obj2")

    print(obj1.class_attr)  # 输出 "I am a class attribute"
    print(obj2.class_attr)  # 输出 "I am a class attribute"

    print(obj1.ins_attr)  # 输出 "I am an instance attribute of obj1"
    print(obj2.ins_attr)  # 输出 "I am an instance attribute of obj2"

    obj1.class_attr = "I am a new update class attribute of obj1"
    print(obj1.class_attr)  # 输出 "I am a new update class attribute of obj1"
    print(obj2.class_attr)  # 输出 "I am a class attribute"

    MyClass.class_attr = "I am a new MyClass attribute"
    print(obj1.class_attr)  # 输出 "I am a new update class attribute of obj1"
    print(obj2.class_attr)  # 输出 "I am a new MyClass attribute"
    print(MyClass.class_attr)  # 输出 "I am a new MyClass attribute"

En el código anterior, definimos una clase MyClass, que tiene un atributo de clase class_attr y un nombre de atributo de instancia. Después de crear una instancia de obj1 y obj2, accedemos a sus atributos de instancia y atributos de clase respectivamente, luego modificamos el valor del atributo de clase y accedemos a los valores de atributo de clase de las dos instancias respectivamente, y finalmente imprimimos el valor del atributo de cada instancia. .

Los resultados de ejecución son los siguientes.

Como se puede ver en los resultados de ejecución anteriores,

• Cuando 实例对象modificamos según el uso 类属性, los atributos de clase del objeto de instancia cambiarán, pero solo se afectarán a sí mismos (el objeto de instancia modificado) y no afectarán los valores de los atributos de otras instancias.
• Cuando 类lo modificamos directamente 类属性, los atributos de clase cambiarán y tendrán efecto en otros objetos de instancia. Los resultados de acceso de otros objetos de instancia se convertirán en los resultados de los atributos de clase modificados de la clase, mientras que los atributos de clase modificados del objeto de instancia no lo serán . afectado Afectado , el valor de su atributo de clase es su valor modificado (objeto de instancia).

3. Resumen

• Los atributos de clase son variables globales de una clase. Todos los objetos de instancia comparten un valor al que se puede acceder a través del nombre de la clase o del objeto de instancia. Además, cabe señalar que diferentes métodos de modificación pueden afectar el resultado final de los atributos de clase.
• Los atributos de instancia son atributos privados de los objetos de instancia, y cada objeto de instancia tiene su propio valor, al que solo se puede acceder a través del objeto de instancia.

En el desarrollo real, es necesario elegir el uso de atributos de clase y atributos de instancia de acuerdo con la situación real.

2. Atributos de clase, métodos de decoración de métodos y uso de uso común

1. @propiedad

Convierte un método en un atributo, al que se puede acceder como un atributo.

class MyClass:
    def __init__(self, value):
        self._x = value
    
    @property
    def x(self):
        return self._x
    
c = MyClass(5)
print(c.x)  # 输出5

2. @métododeclase

Declare un método como método de clase y llámelo con el nombre de la clase.

class MyClass:
    x = 0
    
    @classmethod
    def classmethod(cls):
        cls.x += 1
        return cls.x
    
print(MyClass.classmethod())  # 输出1
print(MyClass.classmethod())  # 输出2

3. @métodoestático

Se puede declarar un método como método estático sin crear una instancia de un objeto.

class MyClass:
    @staticmethod
    def staticmethod():
        return "This is a static method."
    
print(MyClass.staticmethod())  # 输出"This is a static method."

4. @get.setter

El método utilizado para establecer el valor de la propiedad debe definirse en el método @property.

class MyClass:
    def __init__(self, value):
        self._x = value
    
    @property
    def x(self):
        return self._x
    
    @x.setter
    def x(self, value):
        self._x = value * 2
    
c = MyClass(5)
print(c.x)  # 输出5
c.x = 10
print(c.x)  # 输出20

5. @get.deleter

El método utilizado para eliminar atributos debe definirse debajo del método @property.

class MyClass:
    def __init__(self, value):
        self._x = value
    
    @property
    def x(self):
        return self._x
    
    @x.deleter
    def x(self):
        del self._x
    
c = MyClass(5)
print(c.x)  # 输出5
del c.x
# print(c.x)  # AttributeError: 'MyClass' object has no attribute '_x'

6. @cached_property

Los atributos de la caché solo se calculan una vez y los accesos posteriores devuelven directamente el valor almacenado en la caché.

from cached_property import cached_property

class MyClass:
    @cached_property
    def x(self):
        print("Calculating x.")
        return 5
    
c = MyClass()
print(c.x)  # 输出Calculating x. 5
print(c.x)  # 输出5

7.@lazy_attribute

Se calcula la primera vez que se accede a la propiedad, después de lo cual se devuelve el valor almacenado en caché.

from lazy_object_proxy import Proxy

class MyClass:
    def __init__(self):
        self._my_property = Proxy(self.calculate_my_property)

    def calculate_my_property(self):
        print("Calculating my_property!")
        return 100

    @property
    def my_property(self):
        return self._my_property

my_class = MyClass()
print(my_class.my_property) # Output: Calculating my_property! 100
print(my_class.my_property) # Output: 100

2. Orientado a objetos: método de clase, método estático, método de instancia

1. Las principales diferencias entre los tres:

1. Método de clase:

Utilice @classmethodun decorador para la decoración. El primer parámetro predeterminado es cls, que representa la clase misma. Los métodos de clase pueden ser llamados por clases y objetos de instancia de la clase. No se puede acceder a las propiedades de instancia y a los métodos de instancia en los métodos de clase, porque no depende de ningún objeto de instancia, sino de la clase misma, que generalmente se usa para crear objetos de clase u operar en propiedades de clase.

2. Métodos de instancia:

Los métodos de instancia no tienen decoradores especiales y el primer parámetro predeterminado es self, que representa la instancia misma. Un método de instancia solo puede ser llamado por un objeto de instancia porque depende del objeto de instancia. Los métodos de instancia pueden acceder a las propiedades y otros métodos de instancia del objeto de instancia.

3. Método estático:

Utilice @staticmethodun decorador para la decoración, no es necesario que represente su propio objeto selfni clsparámetros. El método estático es un conjunto de herramientas de una clase. No tiene nada que ver con la clase y los objetos de instancia. Generalmente se usa para funciones de herramientas u operaciones de inicialización de la clase.

2. Introduzca también la diferencia entre métodos de clase y métodos de instancia:

• Los métodos de clase están @classmethoddecorados con decoradores, mientras que los métodos de instancia no.
• El primer parámetro de un método de clase es el objeto de clase ( cls), mientras que el primer parámetro de un método de instancia es el objeto de instancia ( self).
• Los métodos de clase se pueden llamar directamente a través del nombre de la clase, mientras que los métodos de instancia deben llamarse a través del objeto de instancia.
• Los métodos de clase son los mismos para todas las instancias, mientras que los métodos de instancia pueden ser diferentes para cada instancia.
• Los métodos de clase se usan generalmente para crear, modificar y consultar atributos de clase y el estado de la clase, mientras que los métodos de instancia generalmente se usan para operar los atributos y el estado de la instancia.
• Los métodos de clase pueden acceder a los atributos de clase, pero no a los atributos de instancia. Los métodos de instancia pueden acceder a atributos de instancia y atributos de clase.

Al utilizar métodos de clase y métodos de instancia, debe elegir qué método utilizar de acuerdo con las necesidades comerciales específicas.

3. Descripción y explicación del código de muestra.

1. Métodos de instancia:

En Python, todas las funciones de una clase son métodos de instancia de forma predeterminada. Un método de instancia es un selfmétodo que toma como primer parámetro. Se puede llamar creando una instancia de un objeto. Puede acceder a los datos de la instancia y también puede modificar la instancia. .datos, uno de los métodos más utilizados.

class MyClass:
    def my_instance_method(self, arg1, arg2):
        # 实例方法的代码
        pass

instance = MyClass()
instance.my_instance_method(arg1, arg2)

2. Métodos de clase:

Un método de clase es un método que toma cls como primer parámetro. Se puede llamar a través del nombre de la clase o del objeto@classmethod , y también puede modificar variables de clase. Sin embargo, no puede acceder a variables de instancia. Los métodos de clase se definen mediante decoradores.

Código de muestra

class MyClass:
    class_var = 0

    @classmethod
    def my_class_method(cls, arg1, arg2):
        # 类方法的代码
        cls.class_var += 1
        pass

MyClass.my_class_method(arg1, arg2)

3. Método estático:

Estos métodos también son métodos de miembros de clase, pero no requieren acceso al contexto de clase o instancia. Los métodos estáticos se pueden llamar como funciones normales, sin parámetros predeterminados.
Los métodos estáticos no necesitan pasar ningún parámetro. No tienen nada que ver con clases e instancias. Se pueden llamar usando nombres de clases o nombres de objetos. Por lo tanto, los métodos estáticos no pueden acceder a variables de instancia o variables de clase. Los métodos estáticos se definen usando decoradores @staticmethod.

class MyClass:
    @staticmethod
    def my_static_method(arg1, arg2):
        # 静态方法的代码
        pass

MyClass.my_static_method(arg1, arg2)

3. Resumen:

• El método de instancia es el tipo de método más utilizado y solo puede ser llamado por una instancia. El primer parámetro es self;
• Tanto los métodos de clase como los métodos estáticos son métodos de miembros de clase y se pueden llamar a través de la clase o instancia;
• El primer parámetro del método de clase es cls, que indica el objeto de clase actual;
• Los métodos estáticos no tienen parámetros predeterminados y no se les pasa el contexto de la clase.

Lo anterior es una explicación detallada de las diferencias y el uso de atributos orientados a objetos, métodos de clase, métodos estáticos y métodos de instancia en Python. Espero que le resulte útil. No dude en brindarme su ayuda. ¡Gracias!