que es clase
Una clase en Python es una plantilla para crear objetos que se pueden usar para almacenar datos y definir el comportamiento.
- Cree una clase: use la palabra clave class para definir una clase, y la primera letra del nombre de la clase debe estar en mayúscula.
- Crear un objeto: use el nombre de la clase () para crear un objeto.
- Método: una función en una clase se llama método, y el primer parámetro es self, que representa el objeto en sí.
- Constructor: el método init es un método especial que se llama cuando se crea una instancia de la clase.
- Herencia: una clase puede heredar todas las propiedades y métodos de otra clase.
- Polimorfismo: los métodos de una clase pueden ser anulados por subclases.
Las clases son un concepto importante en la programación orientada a objetos. El uso de clases puede organizar mejor el código y mejorar la reutilización del código.
Un breve resumen de la clase.
-
Constructor en una clase: cada vez que se crea un nuevo objeto, Python llamará automáticamente al constructor en la clase, y su nombre es __init__. A través de constructores, se pueden establecer valores de propiedad iniciales para objetos recién creados.
-
Atributos y métodos privados en una clase: los atributos y métodos privados en una clase comienzan con un guión bajo doble (como __private_attr) y solo se puede acceder a ellos dentro de la clase, no fuera de ella. Esto protege los detalles de implementación de la clase de ser interferidos por programas externos.
-
Herencia de clases: las clases pueden heredar propiedades y métodos de otras clases, lo que puede reducir la duplicación de código y mejorar la reutilización del código.
-
Polimorfismo de clase: El polimorfismo significa que los objetos de diferentes clases pueden llamar al mismo método y producir resultados diferentes. Esto se logra definiendo un método común en la clase base y anulando el método en la clase derivada.
-
Decorador de @property: puede acceder a los métodos de la clase como atributos sin usar paréntesis como los métodos de llamada.
-
Modo Singleton: El modo Singleton significa que una clase tiene solo una instancia en todo el programa, lo que se realiza reescribiendo el constructor de la clase y usando decoradores.
-
Clase abstracta: una clase abstracta es una clase especial en la que se definen algunos métodos abstractos. Un método abstracto es un método que no tiene implementación y debe implementarse en una clase derivada. Las clases abstractas no se pueden instanciar.
-
Metaclase: Una metaclase es una clase que se utiliza para crear una clase. Permite realizar operaciones adicionales durante la creación de clases, como la validación de propiedades y métodos de clase.
-
Encapsulación de datos: la encapsulación de datos es una tecnología que encapsula los datos y las operaciones de una clase para que los detalles de implementación de la clase no estén expuestos a programas externos. Esto protege los detalles de implementación de la clase de ser interferidos por programas externos.
Ejemplo simple de clase.
- definición de clase
class Dog:
"""定义 Dog 类"""
def __init__(self, name, age):
"""初始化属性 name 和 age"""
self.name = name
self.age = age
def bark(self):
"""模拟狗叫"""
print(f"{self.name} is barking.")
# 创建 Dog 类的实例
dog1 = Dog("Lucy", 3)
dog1.bark() # 输出 "Lucy is barking."
Este es un ejemplo de una definición de clase simple, la clase Perro tiene dos propiedades, nombre y edad, y un método ladrar.
- heredar
class Animal:
"""定义 Animal 类"""
def __init__(self, name):
"""初始化属性 name"""
self.name = name
def move(self):
"""模拟动物移动"""
print(f"{self.name} is moving.")
class Dog(Animal):
"""定义 Dog 类，继承自 Animal"""
def __init__(self, name, age):
"""初始化属性 name 和 age"""
super().__init__(name)
self.age = age
def bark(self):
"""模拟狗叫"""
print(f"{self.name} is barking.")
dog = Dog("Bob", 3)
dog.move() # 输出 "Bob is moving."
dog.bark() # 输出 "Bob is barking."
La herencia es un concepto importante en la programación orientada a objetos.A través de la herencia, las propiedades y los métodos se pueden heredar de las clases principales, y las nuevas propiedades y métodos se pueden definir en las subclases. En el código anterior, la clase Dog hereda de la clase Animal, por lo que puede llamar directamente al método de movimiento en la clase Animal. Utilice la función super() para llamar a los métodos y propiedades de la clase principal.
- propiedades/métodos privados
class Dog:
"""定义 Dog 类"""
def __init__(self, name, age):
"""初始化属性 name 和 age"""
self.name = name
self._age = age
def bark(self):
"""模拟狗叫"""
print(f"{self.name} is barking.")
def _secret_bark(self):
"""私有方法模拟狗叫"""
print(f"{self.name} is secretly barking.")
# 创建 Dog 类的实例
dog1 = Dog("Lucy", 3)
dog1.bark() # 输出 "Lucy is barking."
dog1._secret_bark() # 可以调用私有方法，但不建议这样做
En una clase, si el atributo o el nombre del método comienza con un guión bajo, como _agey _secret_bark, dichos atributos y métodos se denominan atributos y métodos privados. No se puede acceder directamente a las propiedades y métodos privados fuera de la clase, pero se pueden usar dentro de la clase.
- método estático
class Dog:
"""定义 Dog 类"""
def __init__(self, name, age):
"""初始化属性 name 和 age"""
self.name = name
self.age = age
def bark(self):
"""模拟狗叫"""
print(f"{self.name} is barking.")
@staticmethod
def info():
"""静态方法，显示有关类的信息"""
print("This is a dog class.")
Dog.info() # 输出 "This is a dog class."
Un método estático es un método especial que no requiere acceso a las propiedades de la clase o instancia y se puede llamar directamente a través del nombre de la clase. Un método normal se puede definir como un método estático utilizando @staticmethodel decorador.
- método de clase
class Dog:
"""定义 Dog 类"""
animal_type = "mammal" # 类属性
def __init__(self, name, age):
"""初始化属性 name 和 age"""
self.name = name
self.age = age
def bark(self):
"""模拟狗叫"""
print(f"{self.name} is barking.")
@classmethod
def get_animal_type(cls):
"""类方法，返回 animal_type"""
return cls.animal_type
print(Dog.get_animal_type()) # 输出 "mammal"
Un método de clase es similar a un método estático, pero puede acceder a las propiedades de la clase, y un @classmethodmétodo normal se puede definir como un método de clase usando un decorador. En un método de clase, el primer parámetro debe ser la clase en sí, generalmente clsdenotada con .