Esplora la programmazione [orientata agli oggetti Python]: spiegazione dettagliata dei paradigmi di programmazione avanzati nel nuovo era

Programmazione orientata agli oggetti (OOP) È un paradigma di programmazione implementato organizzando i programmi in raccolte di oggetti. Gli oggetti contengono non solo dati ma anche metodi per manipolarli. I concetti fondamentali dell'OOP includono classi, oggetti, proprietà e metodi.

1.1 Cosa sono le classi e gli oggetti?

Classe È un modello o un progetto utilizzato per creare oggetti. Le classi definiscono le proprietà e il comportamento degli oggetti.
Oggetto È un'istanza della classe. Creare un oggetto significa creare un'istanza specifica in base alla classe.

esempio:


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 Definizione di classe

In Python, le classi passano class Definizione delle parole chiave. Le funzioni di una classe sono chiamate metodi e le variabili sono chiamate proprietà.I metodi di classe di solito iniziano conself Come primo parametro, rappresenta l'istanza stessa.

esempio:


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 Relazione tra classi e oggetti

Una classe è un modello per un oggetto e definisce la struttura e il comportamento dell'oggetto. Gli oggetti sono istanze di classi e ogni oggetto ha proprietà e metodi indipendenti.


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 Comprensione di Xiao Li

Una classe è come uno stampo per biscotti, definisce la forma e la dimensione del biscotto. Gli oggetti sono come biscotti di cemento ricavati da uno stampo. Ogni biscotto può avere sapori (proprietà) diversi, ma la loro forma e dimensione (struttura e comportamento) sono le stesse.

2. Astrazione

astratto Si riferisce alla semplificazione di problemi complessi del mondo reale cogliendone le caratteristiche principali e ignorando i dettagli. Nella programmazione, l'astrazione ci aiuta a creare un codice più conciso e gestibile.

2.1 Concetti astratti

L'astrazione consiste nell'estrarre le caratteristiche principali di un oggetto ignorando i dettagli non importanti. Attraverso l'astrazione, possiamo concentrarci sulla funzionalità principale di un oggetto senza essere distratti dalle caratteristiche secondarie.

esempio:


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 Classi e metodi astratti

In Python, possiamo ottenere l'astrazione definendo classi e metodi astratti. Le classi astratte non possono essere istanziate, ma solo ereditate. I metodi astratti sono definiti nella classe astratta ma implementati nelle sottoclassi.

esempio:


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 Comprensione di Xiao Li

L'astrazione è come ridurre un dipinto complesso a forme geometriche. Ad esempio, un gatto specifico ha molte caratteristiche (colore del mantello, taglia, età, ecc.), ma ci concentreremo solo sulla caratteristica del miagolio. Questa è l'astrazione del gatto.

3. Classi e istanze

Classi e istanze È la base dell'OOP. Le classi sono modelli e le istanze sono oggetti concreti. Le istanze vengono create da una classe e hanno le proprietà e i metodi definiti dalla classe.

3.1 Definizione e istanziazione delle classi

La definizione di una classe e la creazione di un'istanza sono le operazioni di base dell'OOP. Le classi definiscono proprietà e metodi e le istanze sono oggetti concreti della classe.

esempio:


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 Attributi e metodi delle classi

Gli attributi di una classe sono lo stato dell'oggetto e i metodi sono il comportamento dell'oggetto.Gli attributi della classe passano__init__ Inizializzazione del metodo, il metodo è definito nella classe.

esempio:


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 Comprensione di Xiao Li

Le classi e le istanze sono come il disegno di una casa e di una casa reale. I disegni (classi) definiscono la struttura e la funzionalità della casa, mentre la casa vera e propria (istanza) è l'oggetto concreto costruito secondo i disegni.

4. Incapsulamento/Interfaccia

incapsulamento Nasconde lo stato (proprietà) e il comportamento (metodi) dell'oggetto all'interno della classe e interagisce con il mondo esterno attraverso l'interfaccia (metodi). L'incapsulamento migliora la sicurezza e la manutenibilità del codice.

4.1 Concetto di incapsulamento

L'incapsulamento è uno dei concetti fondamentali dell'OOP. Protegge i dati dell'oggetto nascondendo lo stato interno dell'oggetto ed esponendo solo le interfacce necessarie. In questo modo, il codice esterno non può accedere o modificare direttamente lo stato interno dell'oggetto e può solo manipolare i dati attraverso i metodi forniti dall'oggetto.

esempio:


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 Concetto di interfaccia

Un'interfaccia è l'unico modo in cui un oggetto interagisce con il mondo esterno. Attraverso le interfacce, il codice esterno può chiamare i metodi dell'oggetto ma non può accedere direttamente allo stato interno dell'oggetto.

esempio:


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 Comprensione di Xiao Li

La confezione è come la custodia di un telefono cellulare. I circuiti e i componenti (stato dell'oggetto) all'interno del telefono cellulare sono incapsulati nell'involucro. L'utente può interagire con il telefono cellulare solo attraverso i pulsanti e lo schermo (interfaccia), ma non può contattare direttamente i componenti interni.

5. Eredità

ereditare È un altro concetto fondamentale dell'OOP, che ci consente di creare una nuova classe basata su una classe esistente. La nuova classe eredita tutte le proprietà e i metodi della classe esistente.

5.1 Il concetto di eredità

L'ereditarietà avviene quando una classe (sottoclasse) ottiene proprietà e metodi da un'altra classe (classe genitore). Attraverso l'ereditarietà, le sottoclassi possono riutilizzare il codice della classe genitore, aggiungere nuove proprietà e metodi o sovrascrivere i metodi della classe genitore.

esempio:


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 Riscrittura del metodo

Una sottoclasse può sovrascrivere il metodo della classe genitore, ovvero definire un metodo con lo stesso nome della classe genitore nella sottoclasse per ottenere funzioni diverse.

esempio:


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 Comprensione di Xiao Li

L’eredità è come un lascito lasciato dai genitori ai propri figli. I genitori (classe genitore) trasmettono le loro proprietà (proprietà e metodi) ai figli (sottoclassi), e i figli non solo possono utilizzare queste proprietà, ma anche diventare più ricchi grazie ai propri sforzi (aggiungendo nuove proprietà e metodi).

6. Polimorfismo

Polimorfismo Significa che lo stesso metodo ha manifestazioni diverse su oggetti diversi. Il polimorfismo ci consente di chiamare metodi di oggetti diversi attraverso la stessa interfaccia per ottenere funzioni diverse.

6.1 Il concetto di polimorfismo

Il polimorfismo è una delle caratteristiche importanti dell'OOP. Punta a oggetti sottoclasse tramite riferimenti alla classe genitore, consentendo allo stesso metodo di avere implementazioni diverse. Il polimorfismo aumenta la flessibilità e la scalabilità del codice.

esempio:


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 Implementare il polimorfismo

In Python, il polimorfismo viene solitamente implementato tramite l'override del metodo e i riferimenti alla classe genitore. Puntando all'oggetto sottoclasse tramite il riferimento alla classe genitore, è possibile chiamare il metodo della sottoclasse.

esempio:


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 Comprensione di Xiao Li

Il polimorfismo è come un telecomando universale. Che si tratti di controllare una TV, un condizionatore d'aria o uno stereo, purché questi dispositivi dispongano di interfacce (metodi) corrispondenti, il telecomando (riferimento alla classe principale) può implementare diverse funzioni tramite gli stessi pulsanti (chiamate al metodo).

7. Introspezione/Riflessione

introspezione Ciò significa che l'oggetto può conoscere le proprie informazioni in fase di esecuzione. Python fornisce alcune funzioni integrate per l'introspezione, cometype()、id()、hasattr() Aspettare.

7.1 Il concetto di introspezione

L'introspezione significa che un oggetto può ottenere le proprie informazioni in fase di esecuzione, come proprietà, metodi, ecc. L'introspezione rende i programmi Python altamente dinamici e flessibili.

esempio:


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 Utilizzo dell'introspezione per operazioni dinamiche

Attraverso l'introspezione, possiamo manipolare dinamicamente le proprietà e i metodi degli oggetti in fase di esecuzione, rendendo il programma più flessibile e dinamico.

esempio:


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 Comprensione di Xiao Li

Auto-esaminarsi è come guardarsi allo specchio. Attraverso lo specchio (meccanismo di introspezione), le persone possono vedere il loro aspetto (proprietà e metodi degli oggetti) e apportare le modifiche necessarie (manipolazione dinamica degli oggetti).

8. Metodi statici e metodi di classe

metodo statico Emetodo di classe sono metodi associati alla classe, non all'istanza.Utilizzo del metodo statico@staticmethod Decoratore, utilizzo del metodo di classe@classmethod Decoratore.

8.1 Metodi statici

Un metodo statico è un metodo di una classe, ma non è legato ad alcuna istanza della classe. I metodi statici non possono accedere alle istanze di una classe, né possono modificare lo stato della classe. Di solito vengono utilizzati per eseguire operazioni che non hanno nulla a che fare con la classe, ma che logicamente appartengono alla funzionalità della classe.

esempio:


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

8.2 Metodi di classe

I metodi di classe sono metodi legati alla classe anziché all'istanza.Il primo argomento di un metodo di classe è la classe stessa, solitamente denominatacls . I metodi della classe possono accedere alle proprietà della classe e ad altri metodi della classe.

esempio:


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

Riassumere

Tutti gli aspetti della programmazione orientata agli oggetti in Python, inclusi i concetti di base della programmazione orientata agli oggetti, astrazioni, classi e istanze, incapsulamento, ereditarietà, polimorfismo, introspezione e metodi statici e di classe.

Spero che questo blog dettagliato possa aiutarti a comprendere a fondo la programmazione orientata agli oggetti in Python e ad applicare queste conoscenze a progetti reali. Se avete domande o avete bisogno di ulteriore assistenza, non esitate a contattarmi!

Condivisione della tecnologia

Esplora la programmazione [orientata agli oggetti Python]: spiegazione dettagliata dei paradigmi di programmazione avanzati nella nuova era

1. Concetti di programmazione orientata agli oggetti (OOP)

1.1 Cosa sono le classi e gli oggetti?

1.2 Definizione di classe

1.3 Relazione tra classi e oggetti

1.4 Comprensione di Xiao Li

2. Astrazione

2.1 Concetti astratti

2.2 Classi e metodi astratti

2.3 Comprensione di Xiao Li

3. Classi e istanze

3.1 Definizione e istanziazione delle classi

3.2 Attributi e metodi delle classi

3.3 Comprensione di Xiao Li

4. Incapsulamento/Interfaccia

4.1 Concetto di incapsulamento

4.2 Concetto di interfaccia

4.3 Comprensione di Xiao Li

5. Eredità

5.1 Il concetto di eredità

5.2 Riscrittura del metodo

5.3 Comprensione di Xiao Li

6. Polimorfismo

6.1 Il concetto di polimorfismo

6.2 Implementare il polimorfismo

6.3 Comprensione di Xiao Li

7. Introspezione/Riflessione

7.1 Il concetto di introspezione

7.2 Utilizzo dell'introspezione per operazioni dinamiche

7.3 Comprensione di Xiao Li

8. Metodi statici e metodi di classe

8.1 Metodi statici

8.2 Metodi di classe

Riassumere

Profilo personale

le mie informazioni di contatto