Resumen del uso de la función mágica en python

1,__init__

        La función mágica __init__ es un método especial en Python que se usa para inicializar las propiedades de un objeto. El método __init__ se llama automáticamente cuando se crea un nuevo objeto.

El formato de definición del método __init__ es el siguiente:

def __init__(self, 参数1, 参数2, ...):
    # 初始化代码

        El primer parámetro del método __init__ suele ser self, que representa el propio objeto que se va a inicializar. Los siguientes argumentos son los valores utilizados para inicializar las propiedades del objeto.

Estos son algunos usos comunes del método __init__:

1.1 Inicializar las propiedades del objeto

def __init__(self, name, age):
    self.name = name
    self.age = age

        En este ejemplo, el método __init__ acepta dos parámetros, nombre y edad, y los asigna a las propiedades de nombre y edad del objeto, respectivamente.

1.2 Realizar otras operaciones de inicialización

        El método __init__ se puede usar no solo para inicializar las propiedades de un objeto, sino también para realizar otras operaciones de inicialización que deben realizarse cuando se crea el objeto. Por ejemplo, puede abrir archivos, establecer conexiones a bases de datos, etc. en el método __init__.

def __init__(self):
    self.file = open('data.txt', 'r')
    self.db = connect('localhost', 'user', 'password', 'database')

        En este ejemplo, el método __init__ abre un archivo y establece una conexión con la base de datos cuando se crea el objeto.

1.3 Heredar el método __init__ de la clase padre

        Si una clase hereda otras clases, su método __init__ puede llamar al método __init__ de la clase principal para inicializar las propiedades de la clase principal.

class Child(Parent):
    def __init__(self, name, age, school):
        super().__init__(name, age)
        self.school = school

        En este ejemplo, la clase secundaria hereda la clase principal y llama al método __init__ de la clase principal en su método __init__ para inicializar las propiedades de la clase principal. Luego, define adicionalmente un atributo de la escuela.

Código de muestra:

class Parent(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def user_info(self):
        print("name:", self.name, ", age:", self.age)


class Child(Parent):
    def __init__(self, school):
        self.school = school

    def student_info(self):
        print("school:", self.school)


class Child2(Parent):
    def __init__(self, name, age, school):
        super().__init__(name, age)
        self.school = school

    def student_info(self):
        print("school:", self.school)


if __name__ == '__main__':
    parent = Parent("dgw", 26)
    parent.user_info()

    child = Child("清华大学")
    child.student_info()
    # child.user_info()  这行直接使用报错，AttributeError: 'Child' object has no attribute 'name'

    child2 = Child2("dgw", 26, "清华大学")
    child2.student_info()
    child2.user_info()

resultado de la operación:

        En resumen, el método __init__ es un método especial en Python que se usa para inicializar las propiedades de un objeto y realizar otras operaciones de inicialización. Al definir el método __init__, puede realizar el trabajo de inicialización necesario al crear un objeto.

2、__str__

        La función mágica __str__ es un método especial en Python que devuelve una representación de cadena de un objeto. Cuando se imprime un objeto utilizando las funciones integradas str() o print(), se llama automáticamente al método __str__ del objeto.

El formato de definición del método __str__ es el siguiente:

def __str__(self):
    # 返回对象的字符串表示形式

El método __str__ debe devolver una cadena que represente una representación de cadena legible por humanos del objeto.

Los siguientes son algunos usos comunes del método __str__:

2.1 Devolver el valor del atributo del objeto

def __str__(self):
    return f"Name: {self.name}, Age: {self.age}"

En este ejemplo, el método __str__ devuelve una cadena que contiene los valores de las propiedades name y age del objeto.

Ejemplo de código 1:

class Parent(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def user_info(self):
        print("name:", self.name, ", age:", self.age)

    def __str__(self):
        return f"Name: {self.name}, Age: {self.age}"


if __name__ == '__main__':
    parent = Parent("dgw", 26)
    parent.user_info()
    print(parent)
    print(parent.__str__)
    print(parent.__str__())

resultado de la operación:

Ejemplo de código 2:

class Parent(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return f"Name: {self.name}, Age: {self.age}"


class Parent2(object):
    """未使用__str__方法"""
    def __init__(self, name, age):
        self.name = name
        self.age = age


if __name__ == '__main__':
    parent = Parent("dgw", 26)
    print(parent)
    print(parent.__str__)
    print(parent.__str__())
    parent2 = Parent2("dgw", 26)
    print(parent2)
    print(parent2.__str__)
    print(parent2.__str__())

resultado de la operación:

2.2 Devolver la información de descripción del objeto

El método __str__ puede devolver la información descriptiva del objeto, como el tipo y la dirección del objeto.

def __str__(self):
    return f"Object of {type(self).__name__} at {hex(id(self))}"

En este ejemplo, el método __str__ devuelve una cadena que describe el tipo y la dirección del objeto.

Código de muestra:

class Parent(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def user_info(self):
        print("name:", self.name, ", age:", self.age)

    def __str__(self):
        return f"Object of {type(self).__name__} at {hex(id(self))}"


if __name__ == '__main__':
    parent = Parent("dgw", 26)
    parent.user_info()
    print(parent)
    print(parent.__str__)
    print(parent.__str__())

resultado de la operación:

2.3 Representación de cadenas de objetos personalizados

El método __str__ puede personalizar la representación de cadena del objeto según sea necesario.

def __str__(self):
    if self.gender == 'M':
        return f"Mr. {self.name}"
    elif self.gender == 'F':
        return f"Ms. {self.name}"
    else:
        return f"{self.name}"

En este ejemplo, el método __str__ devuelve una representación de cadena diferente según la propiedad de género del objeto.

En resumen, el método __str__ es un método especial en Python que devuelve una representación de cadena de un objeto. Al definir un método __str__, puede personalizar la representación de cadena de un objeto para que sea más legible y expresivo.

3、__repr__

        La función mágica __repr__ es un método especial en Python que devuelve la representación de cadena "oficial" de un objeto. Cuando se imprime un objeto utilizando la función integrada repr() o el intérprete interactivo, se llama automáticamente al método __repr__ del objeto.

El formato de definición del método __repr__ es el siguiente:

def __repr__(self):
    # 返回对象的官方字符串表示形式

        El método __repr__ debe devolver una cadena que represente la representación de cadena oficial del objeto. Normalmente debería ser una cadena a partir de la cual la función eval() pueda recrear el objeto.

Estos son algunos usos comunes del método __repr__:

3.1 Devolver el valor del atributo del objeto

def __repr__(self):
    return f"Person(name='{self.name}', age={self.age})"

        En este ejemplo, el método __repr__ devuelve una cadena que contiene el nombre del objeto y los valores del atributo de edad, que pueden ser recreados por la función eval().

3.2 Devolver la información de descripción del objeto

El método __repr__ puede devolver la información descriptiva del objeto, como el tipo y la dirección del objeto.

def __repr__(self):
    return f"<{type(self).__name__} at {hex(id(self))}>"

En este ejemplo, el método __repr__ devuelve una cadena que describe el tipo y la dirección del objeto.

3.3 Representación de cadenas de objetos personalizados

El método __repr__ puede personalizar la representación de cadena del objeto según sea necesario.

def __repr__(self):
    return f"Point({self.x}, {self.y})"

En este ejemplo, el método __repr__ devuelve una representación de cadena personalizada que representa las coordenadas de un objeto de punto.

En resumen, el método __repr__ es un método especial en Python que devuelve la representación de cadena "oficial" de un objeto. La representación de cadena oficial de un objeto se puede personalizar para que sea más legible y expresiva definiendo un método __repr__. Esta representación de cadena por lo general debe ser una cadena a partir de la cual la función eval() puede recrear el objeto.

Consulte la publicación del blog para obtener más información: Explicación detallada de la función repr() en el blog de python_python repr_IT-CSDN Blog

4,__len__

        La función mágica __len__ es un método especial en Python que devuelve la longitud de un objeto. Cuando se usa la función integrada len() para operar en un objeto, se llama automáticamente al método __len__ del objeto.

El formato de definición del método __len__ es el siguiente:

def __len__(self):
    # 返回对象的长度

El método __len__ debe devolver un número entero que represente la longitud del objeto.

El método __len__ generalmente se usa en clases de contenedores personalizados, como listas, cadenas, diccionarios, etc. Estos son algunos usos comunes del método __len__:

4.1 Devolver la longitud de una lista o cadena

def __len__(self):
    return len(self.data)

En este ejemplo, el método __len__ devuelve la longitud del atributo de datos del objeto, que devuelve la longitud de la lista o cadena.

Código de muestra:

class Parent(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __len__(self):
        return len(self.name)


if __name__ == '__main__':
    parent = Parent("dgw", 26)
    print(len(parent))

resultado de la operación:

4.2 Devolver el número de claves en el diccionario

def __len__(self):
    return len(self.keys())

En este ejemplo, el método __len__ devuelve la cantidad de claves en el diccionario, que devuelve la cantidad de elementos en el diccionario.

4.3 Devolver el número de elementos en un contenedor personalizado

def __len__(self):
    count = 0
    for item in self:
        count += 1
    return count

En este ejemplo, el método __len__ itera sobre el objeto contenedor personalizado y cuenta el número de elementos, luego devuelve el número.

En resumen, el método __len__ es un método especial en Python que devuelve la longitud de un objeto. Al definir el método __len__, puede personalizar el método de cálculo de longitud de la clase de contenedor. De esta forma, al usar la función integrada len() para operar en un contenedor personalizado, se llamará automáticamente al método __len__ para obtener la longitud del contenedor.

5,__getitem__

        La función mágica __getitem__ es un método especial en Python para el acceso indexado a objetos. Cuando se usa el operador de índice [] para operar en un objeto, se llama automáticamente al método __getitem__ del objeto.

El formato de definición del método __getitem__ es el siguiente:

def __getitem__(self, index):
    # 返回指定索引的元素

El método __getitem__ debe aceptar un índice de parámetro, indicando el índice del elemento a obtener, y devolver el elemento correspondiente.

El método __getitem__ generalmente se usa en clases de contenedores personalizados, como listas, cadenas, diccionarios, etc. Estos son algunos usos comunes del método __getitem__:

5.1 Obtener elementos en una lista o cadena

def __getitem__(self, index):
    return self.data[index]

En este ejemplo, el método __getitem__ devuelve el elemento en el índice especificado en el atributo de datos del objeto, es decir, devuelve el elemento en el índice correspondiente de la lista o cadena.

Código de muestra:

class Test(object):
    def __init__(self, data):
        self.data = data

    def __getitem__(self, item):
        try:
            return self.data[item]
        except IndexError as e:
            print(e)


class Test2(object):
    def __init__(self, data):
        self.data = data

    def getitem(self, item):
        try:
            return self.data[item]
        except IndexError as e:
            print(e)


if __name__ == '__main__':
    test = Test([1, 2, 3, 4, 5, 6])
    ret = test[3]
    print(ret)
    ret = test[7]
    print(ret)
    print("*" * 100)
    test2 = Test2([1, 2, 3, 4, 5, 6])
    # ret2 = test2[3]  # 报错:TypeError: 'Test2' object is not subscriptable
    # print(ret2)

resultado de la operación:

5.2 Obtener el valor en el diccionario

def __getitem__(self, key):
    return self.data[key]

En este ejemplo, el método __getitem__ devuelve el valor de la clave especificada en el diccionario, es decir, devuelve el valor de la clave correspondiente en el diccionario.

5.3 Obtener los elementos en el contenedor personalizado

def __getitem__(self, index):
    for i, item in enumerate(self):
        if i == index:
            return item
    raise IndexError("Index out of range")

        En este ejemplo, el método __getitem__ atraviesa el objeto contenedor personalizado, encuentra el elemento correspondiente según el valor del índice y lo devuelve. Si el índice está fuera de los límites, se lanza una excepción IndexError.

        En resumen, el método __getitem__ es un método especial en Python que implementa el acceso indexado a los objetos. Al definir el método __getitem__, puede personalizar el método de acceso al índice de la clase contenedora. De esta forma, al usar el operador de índice [] para operar en un contenedor personalizado, se llamará automáticamente al método __getitem__ para obtener el elemento en el índice especificado.

6, __ conjunto de elementos__

        La función mágica __setitem__ es un método especial en Python para la asignación de índices de objetos. Cuando se utiliza el operador de índice [] para asignar un objeto, se llama automáticamente al método __setitem__ del objeto.

El formato de definición del método __setitem__ es el siguiente:

def __setitem__(self, index, value):
    # 对指定索引进行赋值操作

El método __setitem__ debe aceptar dos parámetros, index indica el índice del elemento que se va a asignar y value indica el valor que se va a asignar al índice.

El método __setitem__ generalmente se usa para personalizar clases de contenedores, como listas, cadenas, diccionarios, etc. Estos son algunos usos comunes del método __setitem__:

6.1 Modificar elementos en una lista o cadena

def __setitem__(self, index, value):
    self.data[index] = value

En este ejemplo, el método __setitem__ modifica el elemento en el índice especificado en el atributo de datos del objeto al valor especificado.

6.2 Modificar el valor en el diccionario

def __setitem__(self, key, value):
    self.data[key] = value

En este ejemplo, el método __setitem__ modifica el valor de la clave especificada en el diccionario al valor especificado.

Código de muestra:

class Test(object):
    def __init__(self):
        self.dic = {
            "name": "张三",
            "age": 26
        }

    def __getitem__(self, item):
        return self.dic[item]

    def __setitem__(self, key, value):
        self.dic[key] = value


if __name__ == '__main__':
    test = Test()
    ret = test['name']
    print(ret)
    test['name'] = '李四'
    print(test['name'])
    test['sex'] = '男'
    print(test['sex'])

resultado de la operación:

6.3 Modificación de elementos en contenedores personalizados

def __setitem__(self, index, value):
    for i, item in enumerate(self):
        if i == index:
            self[i] = value
            return
    raise IndexError("Index out of range")

        En este ejemplo, el método __setitem__ atraviesa el objeto contenedor personalizado, encuentra el elemento correspondiente según el valor del índice y lo modifica al valor especificado. Si el índice está fuera de los límites, se lanza una excepción IndexError.

        En resumen, el método __setitem__ es un método especial en Python para la asignación de índices de objetos. Al definir el método __setitem__, puede personalizar el método de asignación de índice de la clase de contenedor. De esta forma, al usar el operador de índice [] para asignar un valor a un contenedor personalizado, se llamará automáticamente al método __setitem__ para modificar el elemento en el índice especificado.

7、__compartir__

        La función mágica __delitem__ es un método especial en Python, que se utiliza para implementar la operación de eliminación de índice del objeto. Cuando se utiliza la palabra clave del para eliminar el índice de un objeto, se llama automáticamente al método __delitem__ del objeto.

El formato de definición del método __delitem__ es el siguiente:

def __delitem__(self, index):
    # 删除指定索引的元素

El método __delitem__ debe aceptar un índice de parámetros, indicando el índice del elemento a eliminar.

El método __delitem__ generalmente se usa para clases de contenedores personalizados, como listas, cadenas, diccionarios, etc. Estos son algunos usos comunes del método __delitem__:

7.1 Eliminación de elementos de una lista o cadena

def __delitem__(self, index):
    del self.data[index]

En este ejemplo, el método __delitem__ elimina el elemento en el índice especificado en el atributo de datos del objeto.

7.2 Eliminar el par clave-valor en el diccionario

def __delitem__(self, key):
    del self.data[key]

En este ejemplo, el método __delitem__ elimina el par clave-valor de la clave especificada en el diccionario.

Código de muestra:

class Test(object):
    def __init__(self):
        self.dic = {
            "name": "张三",
            "age": 26
        }

    def __delitem__(self, key):
        del self.dic[key]

    def __str__(self):
        return f"dic: {self.dic}"


if __name__ == '__main__':
    test = Test()
    print(test)
    del test['age']
    print(test)

resultado de la operación:

7.3 Eliminar elementos en contenedores personalizados

def __delitem__(self, index):
    del self[index]

En este ejemplo, el método __delitem__ llama recursivamente al método __delitem__ del objeto contenedor personalizado para eliminar el elemento en el índice especificado.

En resumen, el método __delitem__ es un método especial en Python que se usa para implementar la operación de eliminación de índice del objeto. Al definir el método __delitem__, puede personalizar el método de eliminación de índice de la clase contenedora. De esta forma, cuando se elimina el índice de un objeto con la palabra clave del, se llama automáticamente al método __delitem__ para eliminar el elemento en el índice especificado.

8,__getattr__

        La función mágica __getattr__ es un método especial en Python que se llama automáticamente cuando se accede a un atributo inexistente de un objeto. Al acceder a un atributo de un objeto, si el atributo no existe, Python llamará automáticamente al método __getattr__ del objeto.

El formato de definición del método __getattr__ es el siguiente:

def __getattr__(self, name):
    # 处理不存在的属性

El método __getattr__ debe aceptar un nombre de parámetro, indicando el nombre del atributo al que se accede.

El método __getattr__ se usa a menudo para el procesamiento dinámico cuando los atributos del objeto no existen. Algunos usos comunes son:

8.1 Proporcionar valores predeterminados

def __getattr__(self, name):
    return "default value"

En este ejemplo, el método __getattr__ devuelve un valor predeterminado si el atributo al que se accede no existe.

Código de muestra:

class Test(object):
    def __init__(self, name):
        self.name = name

    def __getattr__(self, item):
        return f"{item} is not exist!"


if __name__ == '__main__':
    test = Test('dgw')
    print(test.name)
    print(test.age)

resultado de la operación:

8.2 Propiedades dinámicas calculadas

def __getattr__(self, name):
    if name == "attribute":
        return 10
    else:
        raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")

        En este ejemplo, el valor de un atributo se calcula dinámicamente en función del nombre del atributo. Si el nombre del atributo al que se accede es atributo, el valor de retorno del método __getattr__ es 10; de lo contrario, se lanza una excepción AttributeError.

8.3 Activar otras acciones al acceder a propiedades inexistentes

def __getattr__(self, name):
    print(f"Accessing non-existent attribute: {name}")
    return None

En este ejemplo, el método __getattr__ imprime un mensaje y devuelve Ninguno al acceder a un atributo inexistente.

En resumen, el método __getattr__ es un método especial en Python que se llama automáticamente cuando se accede a un atributo no existente de un objeto. Al definir un método __getattr__, puede personalizar cómo se comporta un objeto al acceder a un atributo que no existe.

9,__setattr__

        La función mágica __setattr__ es un método especial en Python para manejar la configuración de atributos de objetos. Al asignar un valor al atributo de un objeto, Python llama automáticamente al método __setattr__ del objeto.

El formato de definición del método __setattr__ es el siguiente:

def __setattr__(self, name, value):
    # 处理属性设置

El método __setattr__ recibe tres parámetros, self representa el objeto en sí, name representa el nombre del atributo que se establecerá y value representa el valor del atributo que se establecerá.

El uso del método __setattr__ se explica en detalle a continuación:

9.1 Evitar que se modifiquen las propiedades

def __setattr__(self, name, value):
    if name == "attribute":
        raise AttributeError("Cannot modify attribute")
    else:
        self.__dict__[name] = value

        En este ejemplo, si el nombre del atributo que se establecerá es atributo, el método __setattr__ generará una excepción AttributeError, lo que evitará la modificación del atributo. De lo contrario, el valor del atributo se almacena en el atributo __dict__ del objeto.

Código de muestra:

class Test(object):
    def __init__(self, name):
        self.name = name

    def __getattr__(self, item):
        return f"{item} is not exist!"

    def __setattr__(self, key, value):
        self.__dict__[key] = value


if __name__ == '__main__':
    test = Test('dgw')
    print(test.name)
    print(test.age)
    test.age = 26
    print(test.age)

resultado de la operación:

9.2 Operación de establecimiento de propiedad de intercepción

def __setattr__(self, name, value):
    print(f"Setting attribute: {name} = {value}")
    self.__dict__[name] = value

        En este ejemplo, el método __setattr__ imprime un mensaje al configurar el atributo y almacena el valor del atributo en el atributo __dict__ del objeto. Esto se puede usar para interceptar operaciones de conjuntos de propiedades y manejarlas en consecuencia.

9.3 Evite la recursividad infinita

def __setattr__(self, name, value):
    if name == "attribute":
        self.attribute = value
    else:
        self.__dict__[name] = value

        En este ejemplo, si el nombre del atributo que se establecerá es atributo, el método __setattr__ asignará directamente el valor a self.attribute sin llamar al método __setattr__, evitando el problema de la recursividad infinita.

Código de muestra:

class Test(object):
    def __init__(self, name):
        self.name = name

    def __setattr__(self, key, value):
        self.__dict__[key] = value


if __name__ == '__main__':
    test = Test('dgw')
    print(test.name)
    if not getattr(test, 'age', None):
        test.age = 26
        setattr(test, 'sex', '男')
    print(test.age)
    print(test.sex)

resultado de la operación:

        En resumen, el método __setattr__ es un método especial en Python que se llama automáticamente cuando se asigna un valor al atributo de un objeto. Al definir un método __setattr__, puede personalizar cómo se comporta un objeto cuando se establece un atributo. Se puede usar para evitar que se modifiquen las propiedades, interceptar operaciones de configuración de propiedades o evitar la repetición infinita. Esto permite una mayor flexibilidad y control sobre el comportamiento de la configuración de propiedades del objeto.

10、__llamar__

        La función mágica __call__ es un método especial en Python que se usa para hacer que los objetos sean invocables. Cuando se llama a un objeto, Python llama automáticamente al método __call__ del objeto.

El formato de definición del método __call__ es el siguiente:

def __call__(self, *args, **kwargs):
    # 处理调用操作

Los parámetros recibidos por el método __call__ incluyen la representación del propio objeto, *args que representan cualquier número de parámetros posicionales y **kwargs que representan cualquier número de parámetros de palabras clave.

El uso del método __call__ se explica en detalle a continuación:

10.1 Llamar objetos como funciones

class MyClass:
    def __call__(self, *args, **kwargs):
        print("Calling MyClass")

obj = MyClass()
obj()

En este ejemplo, la clase MyClass define el método __call__. Cuando se llama al objeto obj, el método __call__ se llamará automáticamente y generará "Llamando a MyClass".

Código de muestra:

class Test(object):
    def __init__(self, name):
        self.name = name

    def __call__(self, *args, **kwargs):
        print(f"name: {self.name}")


if __name__ == '__main__':
    test = Test('dgw')
    print(test.name)
    test()

resultado de la operación:

10.2 Implementando un estilo de programación funcional

class Adder:
    def __init__(self, num):
        self.num = num

    def __call__(self, x):
        return self.num + x

add_5 = Adder(5)
result = add_5(10)
print(result)  # 输出 15

        En este ejemplo, la clase Adder define el método __call__ para que el objeto se pueda llamar como una función. Cuando se llama al objeto add_5, agregará los parámetros entrantes a self.num y devolverá el resultado.

10.3 Implementando decoradores

class Decorator:
    def __init__(self, func):
        self.func = func

    def __call__(self, *args, **kwargs):
        print("Before calling function")
        result = self.func(*args, **kwargs)
        print("After calling function")
        return result

@Decorator
def my_function():
    print("Inside my_function")

my_function()

        En este ejemplo, la clase Decorator define el método __call__ para que el objeto se pueda llamar como un decorador. Cuando se llama a la función my_function, primero ejecutará el método __call__ del objeto Decorator para la decoración y luego ejecutará la función original.

Código de muestra:

class Decorator(object):
    def __init__(self, func):
        self.func = func

    def __call__(self, *args, **kwargs):
        print("Before calling function")
        result = self.func(*args, **kwargs)
        print("After calling function")
        return result


@Decorator
def my_func(x, y):
    return x + y


if __name__ == '__main__':
    ret = my_func(5, 6)
    print(ret)

resultado de la operación:

        En resumen, el método __call__ es un método especial en Python que se usa para hacer que un objeto sea invocable. Al definir el método __call__, el objeto se puede llamar como una función, implementando un estilo de programación funcional o implementando funciones como decoradores. Esto hace que el comportamiento de llamada del objeto sea más flexible y personalizable.

Consulte la publicación del blog para obtener más información: Explicación detallada del uso de __call__ en Python

11、__siguiente__

        La función mágica __next__() es un método especial en el protocolo iterador, que se utiliza para definir el comportamiento de iteración de un objeto iterable. Cuando se usa la función incorporada next() para iterar sobre un objeto iterable, en realidad se llama al método __next__() del objeto. La siguiente es una explicación detallada del uso del método __next__().

class MyIterator:
    def __init__(self, data):
        self.data = data
        self.index = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.index >= len(self.data):
            raise StopIteration
        value = self.data[self.index]
        self.index += 1
        return value

# 创建一个可迭代对象
my_iter = MyIterator([1, 2, 3, 4, 5])

# 使用迭代器进行迭代
for num in my_iter:
    print(num)

resultado de la operación:

        En el ejemplo anterior, definimos una clase iteradora denominada MyIterator, que contiene el constructor __init__(), el método __iter__() y el método __next__(). El método __init__() se usa para inicializar los datos y los índices del objeto iterador. El método __iter__() devuelve el propio objeto iterador, ya que los objetos iteradores también son iterables. El método __next__() define la lógica de iteración del objeto iterador, devuelve un valor cada vez que itera y actualiza el índice. Cuando el índice está fuera de rango, se lanza una excepción StopIteration para marcar el final de la iteración.

        En el uso real, podemos usar la función next() para llamar manualmente al método __next__() del iterador para obtener el siguiente valor, o usar el bucle for para iterar automáticamente el objeto iterable. En un bucle for, cada iteración llamará automáticamente al método __next__() del iterador y asignará el valor devuelto a la variable de bucle.

12,__iter__

        La función mágica __iter__() es un método especial en el protocolo iterador, que se utiliza para definir el comportamiento de iteración de un objeto iterable. Cuando un objeto se usa en un bucle for o se itera usando la función incorporada iter(), en realidad se llama al método __iter__() del objeto. La siguiente es una explicación detallada del uso del método __iter__().

class MyIterable:
    def __init__(self, data):
        self.data = data

    def __iter__(self):
        return MyIterator(self.data)

class MyIterator:
    def __init__(self, data):
        self.data = data
        self.index = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.index >= len(self.data):
            raise StopIteration
        value = self.data[self.index]
        self.index += 1
        return value

# 创建一个可迭代对象
my_iterable = MyIterable([1, 2, 3, 4, 5])

# 使用迭代器进行迭代
for num in my_iterable:
    print(num)

resultado de la operación:

        En el ejemplo anterior, definimos una clase de objeto iterable llamada MyIterable y una clase de iterador llamada MyIterator. El método __iter__() se define en la clase MyIterable, que devuelve un objeto iterador. En el constructor de la clase MyIterable, pasamos los datos del objeto iterador como parámetro y los almacenamos en los datos de la variable de instancia.

        El método __iter__() también se define en la clase MyIterator, que devuelve el propio objeto iterador, porque los objetos iteradores también son iterables. El método __next__() define la lógica de iteración para el objeto iterador como en el ejemplo anterior.

        En la práctica, podemos usar un bucle for para iterar automáticamente sobre un iterable. En el bucle for, primero se llama al método __iter__() del objeto iterable para obtener un objeto iterador, y luego se llama automáticamente al método __next__() del objeto iterador para cada iteración, y el valor devuelto se asigna al bucle. variables

        Cabe señalar que los objetos iterables y los objetos iteradores pueden ser instancias de la misma clase o instancias de diferentes clases. Sin embargo, el objeto iterable debe implementar el método __iter__() para devolver un objeto iterador, y el objeto iterador debe implementar el método __iter__() y el método __next__().

13,__nombre__

        La función mágica __name__ es un atributo especial que se utiliza para obtener el nombre de un objeto. En Python, el atributo __name__ se puede usar para obtener el nombre de objetos como funciones, clases, módulos, etc. La siguiente es una explicación detallada del uso del atributo __name__.

13.1 Obtener el nombre de la función:

def my_function():
    pass

print(my_function.__name__)
# 输出："my_function"

En el ejemplo anterior, my_function.__name__ devuelve el nombre de la función my_function.

Código de muestra:

def my_function():
    return 666


if __name__ == '__main__':
    test = my_function
    print(test.__name__)  # 输出：my_function
    test = my_function()
    # print(test.__name__)  # 抛出异常：AttributeError: 'int' object has no attribute '__name__'. Did you mean: '__ne__'?

resultado de la operación:

13.2 Obtener el nombre de la clase:

class MyClass:
    pass

print(MyClass.__name__)
# 输出："MyClass"

En el ejemplo anterior, MyClass.__name__ devuelve el nombre de la clase MyClass.

Código de muestra:

class MyClass(object):
    def func(self):
        print("__name__ is {}".format(self.__class__.__name__))


if __name__ == '__main__':
    test = MyClass
    print(test.__name__)  # 输出：MyClass
    test = MyClass()
    test.func()  # 输出： __name__ is MyClass
    print(test.__name__)  # 抛出异常：AttributeError: 'MyClass' object has no attribute '__name__'. Did you mean: '__ne__'?

resultado de la operación:

13.3 Obtener el nombre del módulo:

import math

print(math.__name__)
# 输出："math"

En el ejemplo anterior, math.__name__ devuelve el nombre del módulo math.

Código de muestra:

import math
from flask import Flask


if __name__ == '__main__':
    print(math.__name__)  # 输出："math"
    print(Flask.__name__)  # 输出：Flask
    

resultado de la operación:

13.4 Obtener el nombre de un objeto:

my_variable = 123

print(my_variable.__name__)
# 抛出AttributeError异常，因为变量没有__name__属性

En el ejemplo anterior, dado que la variable my_variable no tiene el atributo __name__, acceder a my_variable.__name__ arrojará una excepción AttributeError.

Cabe señalar que el atributo __name__ es un atributo de solo lectura y el nombre del objeto no se puede cambiar por asignación. Se utiliza principalmente para obtener el nombre del objeto, como en la depuración, el registro y otros escenarios.

14、__clase__

        La función mágica __class__ es un atributo especial que se utiliza para obtener la clase a la que pertenece un objeto. En Python, el atributo __class__ se puede usar para obtener una referencia a la clase a la que pertenece un objeto. La siguiente es una explicación detallada del uso del atributo __class__.

14.1 Obtenga la clase a la que pertenece la instancia:

class MyClass:
    pass

obj = MyClass()
print(obj.__class__)
# 输出："<class '__main__.MyClass'>"

En el ejemplo anterior, obj.__class__ devuelve una referencia a la clase MyClass a la que pertenece la instancia obj.

14.2 Modificar la clase a la que pertenece una instancia:

class ClassA:
    pass

class ClassB:
    pass

obj = ClassA()
print(obj.__class__)
# 输出："<class '__main__.ClassA'>"

obj.__class__ = ClassB
print(obj.__class__)
# 输出："<class '__main__.ClassB'>"

        En el ejemplo anterior, primero se crea una instancia obj y su clase es ClassA. Luego, mediante la operación de asignación obj.__class__ = ClassB, la clase de la instancia obj se cambia a ClassB. Finalmente, se imprime obj.__class__ y la salida es "<class '__main__.ClassB'>".

Cabe señalar que modificar la clase a la que pertenece una instancia solo es válido para esa instancia, y no afectará la afiliación de otras instancias ni la clase misma.

14.3 Obtener la clase padre de una clase:

class ParentClass:
    pass

class ChildClass(ParentClass):
    pass

obj = ChildClass()
print(obj.__class__.__bases__)
# 输出："(<class '__main__.ParentClass'>,)"

En el ejemplo anterior, obj.__class__.__bases__ devuelve una tupla de la clase padre ParentClass de la clase ChildClass. Si la clase tiene varios padres, se devuelve una tupla de todos los padres.

Código de muestra:

class ParentClass(object):
    pass


class ParentClass2(object):
    pass


class ChildClass(ParentClass):
    pass


class ChildClass2(ParentClass, ParentClass2):
    pass


class ChildClass3(ChildClass2):
    pass


if __name__ == '__main__':
    obj = ChildClass()
    print(obj.__class__)
    print(obj.__class__.__base__)
    print(obj.__class__.__bases__)

    print("*" * 100)

    obj2 = ChildClass2()
    print(obj2.__class__)
    print(obj2.__class__.__base__)
    print(obj2.__class__.__bases__)

    print("*" * 100)

    obj3 = ChildClass3()
    print(obj3.__class__)
    print(obj3.__class__.__base__)
    print(obj3.__class__.__bases__)

resultado de la operación:

Cabe señalar que el atributo __class__ es un atributo de solo lectura y la clase del objeto no se puede cambiar mediante asignación. Se utiliza principalmente para obtener una referencia a la clase a la que pertenece un objeto.

Consulte la publicación del blog para obtener más información: Explicación detallada del uso de self.__class__ en python

15,__módulo__

        La función mágica __módulo__ es un atributo especial que se utiliza para obtener el nombre del módulo al que pertenece un objeto. En Python, el atributo __module__ se puede usar para obtener el nombre del módulo al que pertenece un objeto. La siguiente es una explicación detallada del uso del atributo __module__.

15.1 Obtener el nombre del módulo al que pertenece una clase o función:

# module.py
class MyClass:
    pass

def my_function():
    pass

print(MyClass.__module__)
# 输出："__main__"

print(my_function.__module__)
# 输出："__main__"

        En el ejemplo anterior, MyClass.__module__ devuelve el nombre del módulo al que pertenece la clase MyClass, que es "__main__". De manera similar, my_function.__module__ devuelve el nombre del módulo al que pertenece la función my_function, también "__main__".

15.2 Obtener el nombre del módulo al que pertenece la instancia:

# module.py
class MyClass:
    pass

obj = MyClass()
print(obj.__module__)
# 输出："__main__"

En el ejemplo anterior, obj.__module__ devuelve el nombre del módulo al que pertenece la instancia obj, que es "__main__".

15.3 Obtenga el nombre del módulo al que pertenece la variable global en el módulo:

# module.py
my_var = 10

print(my_var.__module__)
# 输出："__main__"

En el ejemplo anterior, my_var.__module__ devuelve el nombre del módulo al que pertenece la variable global my_var, también "__main__".

Cabe señalar que para las funciones integradas y los módulos integrados, el valor del atributo __module__ puede ser Ninguno, porque estas funciones y módulos no tienen un módulo claro.

El atributo __module__ es un atributo de solo lectura y el módulo al que pertenece el objeto no se puede cambiar por asignación. Se utiliza principalmente para obtener el nombre del módulo al que pertenece el objeto.

Consulte la publicación del blog para obtener más detalles: explicación detallada del uso del módulo __module__ en python