Explore la programación [orientada a objetos de Python]: explicación detallada de los paradigmas de programación avanzados en la nueva era

Programación orientada a objetos (POO) Es un paradigma de programación implementado organizando programas en colecciones de objetos. Los objetos contienen no sólo datos sino también métodos para manipularlos. Los conceptos centrales de la programación orientada a objetos incluyen clases, objetos, propiedades y métodos.

1.1 ¿Qué son clases y objetos?

Clase Es una plantilla o plano que se utiliza para crear objetos. Las clases definen las propiedades y el comportamiento de los objetos.
Objeto Es una instancia de la clase. Crear un objeto es crear una instancia específica basada en la clase.

ejemplo:


class Dog:
    # 类的初始化方法
    def __init__(self, name, age):
        self.name = name  # 属性
        self.age = age    # 属性
 
    # 方法
    def bark(self):
        return f"{self.name} says Woof!"
 
# 创建对象
my_dog = Dog("Rex", 5)
print(my_dog.bark())

1.2 Definición de clase

En Python, las clases pasan. class Definición de palabras clave. Las funciones de una clase se llaman métodos y las variables se llaman propiedades.Los métodos de clase generalmente comienzan conself Como primer parámetro, representa la instancia misma.

ejemplo:


class Cat:
    def __init__(self, name):
        self.name = name
 
    def meow(self):
        return f"{self.name} says Meow!"
 
# 创建对象
my_cat = Cat("Whiskers")
print(my_cat.meow())

1.3 Relación entre clases y objetos

Una clase es una plantilla para un objeto y define la estructura y el comportamiento del objeto. Los objetos son instancias de clases y cada objeto tiene propiedades y métodos independientes.


class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
 
    def greet(self):
        return f"Hello, my name is {self.name} and I am {self.age} years old."
 
# 创建多个对象
person1 = Person("Alice", 30)
person2 = Person("Bob", 25)
 
print(person1.greet())
print(person2.greet())

1.4 La comprensión de Xiao Li

Una clase es como un molde para galletas, define la forma y el tamaño de la galleta. Los objetos son como galletas de hormigón hechas a partir de un molde. Cada galleta puede tener diferentes sabores (propiedades), pero su forma y tamaño (estructura y comportamiento) son los mismos.

2. Abstracción

abstracto Se refiere a la simplificación de problemas complejos del mundo real aprovechando las características principales e ignorando los detalles. En programación, la abstracción nos ayuda a crear código más conciso y fácil de mantener.

2.1 Conceptos abstractos

La abstracción consiste en extraer las características principales de un objeto ignorando detalles sin importancia. A través de la abstracción, podemos centrarnos en la funcionalidad principal de un objeto sin distraernos con características secundarias.

ejemplo:


class Animal:
    def __init__(self, name):
        self.name = name
 
    def make_sound(self):
        pass  # 抽象方法，不具体实现
 
class Dog(Animal):
    def make_sound(self):
        return "Woof!"
 
class Cat(Animal):
    def make_sound(self):
        return "Meow!"
 
# 创建对象
dog = Dog("Rex")
cat = Cat("Whiskers")
 
print(dog.make_sound())
print(cat.make_sound())

2.2 Clases y métodos abstractos

En Python, podemos lograr la abstracción definiendo clases abstractas y métodos abstractos. Las clases abstractas no se pueden crear instancias, solo se pueden heredar. Los métodos abstractos se definen en la clase abstracta pero se implementan en subclases.

ejemplo:


from abc import ABC, abstractmethod
 
class Vehicle(ABC):
    @abstractmethod
    def start_engine(self):
        pass
 
class Car(Vehicle):
    def start_engine(self):
        return "Car engine started"
 
class Motorcycle(Vehicle):
    def start_engine(self):
        return "Motorcycle engine started"
 
# 创建对象
car = Car()
motorcycle = Motorcycle()
 
print(car.start_engine())
print(motorcycle.start_engine())

2.3 La comprensión de Xiao Li

La abstracción es como reducir una pintura compleja a formas geométricas. Por ejemplo, un gato específico tiene muchas características (color de pelaje, tamaño, edad, etc.), pero solo nos centramos en la característica del maullido. Esta es la abstracción del gato.

3. Clases e instancias

Clases e instancias Es la base de la programación orientada a objetos. Las clases son plantillas y las instancias son objetos concretos. Las instancias se crean a partir de una clase y tienen las propiedades y métodos definidos por la clase.

3.1 Definición de clase e instanciación

Definir una clase y crear una instancia son las operaciones básicas de la programación orientada a objetos. Las clases definen propiedades y métodos, y las instancias son objetos concretos de la clase.

ejemplo:


class Student:
    def __init__(self, name, grade):
        self.name = name
        self.grade = grade
 
    def introduce(self):
        return f"Hi, I am {self.name} and I am in grade {self.grade}."
 
# 创建实例
student1 = Student("Alice", 10)
student2 = Student("Bob", 12)
 
print(student1.introduce())
print(student2.introduce())

3.2 Atributos y métodos de clase

Los atributos de una clase son el estado del objeto y los métodos son el comportamiento del objeto.Pase de atributos de clase__init__ Inicialización del método, el método se define en la clase.

ejemplo:


class Book:
    def __init__(self, title, author):
        self.title = title
        self.author = author
 
    def get_info(self):
        return f"'{self.title}' by {self.author}"
 
# 创建实例
book = Book("1984", "George Orwell")
print(book.get_info())

3.3 La comprensión de Xiao Li

Las clases e instancias son como un dibujo de una casa y una casa real. Los dibujos (clases) definen la estructura y funcionalidad de la casa, mientras que la casa real (instancia) es el objeto concreto construido según los dibujos.

4. Encapsulación/Interfaz

encapsulación Oculta el estado (propiedades) y el comportamiento (métodos) del objeto dentro de la clase e interactúa con el mundo exterior a través de la interfaz (métodos). La encapsulación mejora la seguridad y el mantenimiento del código.

4.1 Concepto de encapsulación

La encapsulación es uno de los conceptos centrales de la programación orientada a objetos. Protege los datos del objeto ocultando el estado interno del objeto y exponiendo solo las interfaces necesarias. De esta manera, el código externo no puede acceder ni modificar directamente el estado interno del objeto y solo puede manipular datos a través de los métodos proporcionados por el objeto.

ejemplo:


class Account:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.__balance = balance  # 私有属性
 
    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
        else:
            raise ValueError("Deposit amount must be positive")
 
    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount
        else:
            raise ValueError("Insufficient funds or invalid amount")
 
    def get_balance(self):
        return self.__balance
 
# 创建实例
account = Account("John")
account.deposit(100)
print(account.get_balance())

4.2 Concepto de interfaz

Una interfaz es la única forma en que un objeto interactúa con el mundo exterior. A través de interfaces, el código externo puede llamar a los métodos del objeto pero no puede acceder directamente al estado interno del objeto.

ejemplo:


class Car:
    def __init__(self, model):
        self.model = model
        self.__engine_started = False
 
    def start_engine(self):
        if not self.__engine_started:
            self.__engine_started = True
            return "Engine started"
        else:
            return "Engine is already running"
 
    def stop_engine(self):
        if self.__engine_started:
            self.__engine_started = False
            return "Engine stopped"
        else:
            return "Engine is not running"
 
# 创建实例
car = Car("Toyota")
print(car.start_engine())
print(car.stop_engine())

4.3 La comprensión de Xiao Li

El embalaje es como la carcasa de un teléfono móvil. Los circuitos y componentes (estado del objeto) dentro del teléfono móvil están encapsulados en la carcasa. El usuario sólo puede interactuar con el teléfono móvil a través de los botones y la pantalla (interfaz), pero no puede contactar directamente con los componentes internos.

5. Herencia

heredar Es otro concepto central de la programación orientada a objetos, que nos permite crear una nueva clase basada en una clase existente. La nueva clase hereda todas las propiedades y métodos de la clase existente.

5.1 El concepto de herencia

La herencia es cuando una clase (subclase) obtiene propiedades y métodos de otra clase (clase principal). A través de la herencia, las subclases pueden reutilizar el código de la clase principal, agregar nuevas propiedades y métodos o anular los métodos de la clase principal.

ejemplo:


class Animal:
    def __init__(self, name):
        self.name = name
 
    def speak(self):
        pass
 
class Dog(Animal):
    def speak(self):
        return "Woof!"
 
class Cat(Animal):
    def speak(self):
        return "Meow!"
 
# 创建实例
dog = Dog("Rex")
cat = Cat("Whiskers")
 
print(dog.speak())
print(cat.speak())

5.2 Método de reescritura

Una subclase puede anular el método de la clase principal, es decir, definir un método con el mismo nombre que la clase principal en la subclase para lograr diferentes funciones.

ejemplo:


class Shape:
    def area(self):
        return 0
 
class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height
 
    def area(self):
        return self.width * self.height
 
class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
 
    def area(self):
        return 3.14 * (self.radius ** 2)
 
# 创建实例
rectangle = Rectangle(3, 4)
circle = Circle(5)
 
print(rectangle.area())
print(circle.area())

5.3 La comprensión de Xiao Li

La herencia es como un legado que los padres dan a sus hijos. Los padres (clase principal) pasan sus propiedades (propiedades y métodos) a sus hijos (subclases), y los hijos no solo pueden usar estas propiedades, sino que también pueden enriquecerse con sus propios esfuerzos (agregando nuevas propiedades y métodos).

6. Polimorfismo

Polimorfismo Significa que el mismo método tiene diferentes manifestaciones en diferentes objetos. El polimorfismo nos permite llamar a métodos de diferentes objetos a través de la misma interfaz para lograr diferentes funciones.

6.1 El concepto de polimorfismo

El polimorfismo es una de las características importantes de la programación orientada a objetos. Apunta a objetos de subclase a través de referencias de clases principales, lo que permite que el mismo método tenga diferentes implementaciones. El polimorfismo aumenta la flexibilidad y escalabilidad del código.

ejemplo:


class Animal:
    def speak(self):
        pass
 
class Dog(Animal):
    def speak(self):
        return "Woof!"
 
class Cat(Animal):
    def speak(self):
        return "Meow!"
 
def animal_sound(animal):
    print(animal.speak())
 
# 创建实例
dog = Dog()
cat = Cat()
 
animal_sound(dog)
animal_sound(cat)

6.2 Implementar polimorfismo

En Python, el polimorfismo generalmente se implementa mediante la anulación de métodos y referencias a clases principales. Al señalar el objeto de la subclase a través de la referencia de la clase principal, puede llamar al método de la subclase.

ejemplo:


class Shape:
    def draw(self):
        pass
 
class Rectangle(Shape):
    def draw(self):
        return "Drawing a rectangle"
 
class Circle(Shape):
    def draw(self):
        return "Drawing a circle"
 
def draw_shape(shape):
    print(shape.draw())
 
# 创建实例
rectangle = Rectangle()
circle = Circle()
 
draw_shape(rectangle)
draw_shape(circle)

6.3 La comprensión de Xiao Li

El polimorfismo es como un control remoto universal. Ya sea que se trate de controlar un televisor, aire acondicionado o estéreo, siempre que estos dispositivos tengan las interfaces (métodos) correspondientes, el control remoto (referencia de clase principal) puede implementar diferentes funciones a través de los mismos botones (llamadas a método).

7. Introspección/Reflexión

introspección Significa que el objeto puede conocer su propia información en tiempo de ejecución. Python proporciona algunas funciones integradas para la introspección, comotype()、id()、hasattr() esperar.

7.1 El concepto de introspección

La introspección significa que un objeto puede obtener su propia información en tiempo de ejecución, como propiedades, métodos, etc. La introspección hace que los programas Python sean muy dinámicos y flexibles.

ejemplo:


class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
 
person = Person("Alice", 30)
 
# 使用内置函数进行自省
print(type(person))
print(hasattr(person, "name"))
print(getattr(person, "name"))
setattr(person, "name", "Bob")
print(person.name)
delattr(person, "name")

7.2 Uso de la introspección para operaciones dinámicas

A través de la introspección, podemos manipular dinámicamente las propiedades y métodos de los objetos en tiempo de ejecución, haciendo que el programa sea más flexible y dinámico.

ejemplo:


class Car:
    def __init__(self, model):
        self.model = model
        self.speed = 0
 
    def accelerate(self):
        self.speed += 5
        return self.speed
 
car = Car("Toyota")
 
# 动态操作对象
if hasattr(car, "accelerate"):
    method = getattr(car, "accelerate")
    print(method())
    print(method())
 
# 动态设置属性
setattr(car, "color", "red")
print(car.color)

7.3 La comprensión de Xiao Li

El autoexamen es como mirarse en el espejo. A través del espejo (mecanismo de introspección), las personas pueden ver cómo se ven (propiedades y métodos de los objetos) y hacer los ajustes necesarios (manipulación dinámica de los objetos).

8. Métodos estáticos y métodos de clase.

método estático ymétodo de clase Son métodos asociados con la clase, no con la instancia.Uso de métodos estáticos@staticmethod Decorador, uso del método de clase.@classmethod Decorador.

8.1 Métodos estáticos

Un método estático es un método de una clase, pero no está vinculado a ninguna instancia de clase. Los métodos estáticos no pueden acceder a instancias de una clase ni pueden modificar el estado de la clase. Suelen utilizarse para realizar alguna operación que no tiene nada que ver con la clase, pero que lógicamente pertenece a la funcionalidad de la clase.

ejemplo:


class Math:
    @staticmethod
    def add(a, b):
        return a + b
 
print(Math.add(5, 3))

8.2 Métodos de clase

Los métodos de clase son métodos que están vinculados a la clase en lugar de a la instancia.El primer argumento de un método de clase es la clase misma, normalmente denominadacls . Los métodos de clase pueden acceder a las propiedades de la clase y a otros métodos de clase.

ejemplo:


class Math:
    factor = 2
 
    @classmethod
    def multiply(cls, value):
        return cls.factor * value
 
print(Math.multiply(5))

Resumir

Todos los aspectos de la programación orientada a objetos en Python, incluidos los conceptos básicos de la programación orientada a objetos, abstracciones, clases e instancias, encapsulación, herencia, polimorfismo, introspección y métodos estáticos y de clase.

Espero que este blog detallado pueda ayudarlo a comprender profundamente la programación orientada a objetos en Python y aplicar este conocimiento en proyectos reales. Si tiene alguna pregunta o necesita más ayuda, ¡no dude en ponerse en contacto conmigo!

Compartir tecnología