面向 C 程式設計師的 Python 中的 OOP 概念 98

這裡為 C 98 程式設計師全面示範了 Python 中的 OOP 概念：

類別定義和物件創建

Python

# Privado por convenção: _underscore_simples
# "Realmente privado": __underscore_duplo (name mangling)
# Público: sem underscore

from abc import abstractmethod
class Animal(ABC):
    # Em python, variáveis declaradas no escopo da classe e não dentro de um
    # método específico, são automaticamente compartilhadas por todas instâncias.
    species_count = 0 # além disso, elas podem ser inicializadas diretamente dentro da classe.

    # Construtor
    def __init__(self, name):
        # Variáveis de instância
        self.name = name       # público
        self._age = 0          # protegido por convenção
        self.__id = id(self)   # privado (mas você consegue acessar com name mangling)
        Animal.species_count += 1

    # Destrutor
    def __del__(self):
        Animal.species_count -= 1

    # Método regular
    @abstractmethod
    def make_sound(self):
        pass  # Equivalente a um método abstrato/virtual (deve ser implementado apenas nas classes filhas)

    # Método estático (não precisa da instância para ser utilizado, nem utiliza seus atributos)
    @staticmethod
    def get_kingdom():
        return "Animalia"

    # Método de classe (recebe a classe como primeiro argumento, pode acessar atributos da classe)
    @classmethod
    def get_species_count(cls):
        return cls.species_count

    # Decorador de propriedade (getter)
    @property
    def age(self):
        return self._age

    # Decorador de propriedade (setter)
    @age.setter
    def age(self, value):
        if value >= 0:
            self._age = value

    # Métodos especiais (sobrecarga de operadores)
    def __str__(self):                # Como toString() - para string legível
        return f"Animal named {self.name}"

    def __repr__(self):               # Para debugging
        return f"Animal(name='{self.name}')"

    def __eq__(self, other):          # Operador de comparação ==
        return isinstance(other, Animal) and self.name == other.name

    def __len__(self):                # Função len()
        return self._age

    def __getitem__(self, key):       # Operador de acesso []
        if key == 'name':
            return self.name
        raise KeyError(key)

C 98

#include <iostream>
#include <string>
#include <sstream>

class Animal {
public:
    static int species_count;

    Animal(const std::string& name) : name(name), _age(0), __id(++id_counter) { // construtor
        ++species_count;
    }

    ~Animal() {    // destrutor
        --species_count;
    }

    virtual void make_sound() = 0; // Método não implementável na classe base (virtual/abstrato)

    static std::string get_kingdom() {  // Não existe distinção entre
    //  @classmethod e @staticmethod em cpp, apenas static methods.
        return "Animalia";
    }

    // static methods podem ser utilizados sem instanciar uma classe e têm
    // acesso às propriedades estáticas da classe:
    static int get_species_count() {
        return species_count;
    }

    // getter:
    int get_age() const {
        return _age;
    }

    // setter:
    void set_age(int age) {
        if (age >= 0) {
            _age = age;
        }
    }

    // Implementação dos métodos especiais que vimos em python:
    std::string to_string() const {
        return "Animal named " + name;
    }

    std::string repr() const {
        std::ostringstream oss;
        oss 



<h2>
  
  
  Herança
</h2>

<h3>
  
  
  Python
</h3>



<pre class="brush:php;toolbar:false">class Dog(Animal):
    def __init__(self, name, breed):
        # Chama o construtor da classe pai
        super().__init__(name)
        self.breed = breed

    # Sobrescreve o método da classe pai
    def make_sound(self):
        return "Woof!"

C 98

class Dog : public Animal {
public:
    Dog(const std::string& name, const std::string& breed) : Animal(name), breed(breed) {}

    void make_sound() override {
        std::cout 



<h2>
  
  
  多重繼承
</h2>

<h3>
  
  
  Python
</h3>



<pre class="brush:php;toolbar:false">class Pet:
    def is_vaccinated(self):
        return True

class DomesticDog(Dog, Pet):
    pass

C 98

class Pet {
public:
    bool is_vaccinated() const {
        return true;
    }
};

class DomesticDog : public Dog, public Pet {
public:
    DomesticDog(const std::string& name, const std::string& breed) : Dog(name, breed) {}
};

抽象類別

Python

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

C 98

class Shape {
public:
    virtual ~Shape() {}
    virtual double area() const = 0;
};

使用範例

Python

if __name__ == "__main__":
    # Cria objetos
    dog = Dog("Rex", "Golden Retriever")

    # Acessa atributos
    print(dog.name)          # Público
    print(dog._age)         # Protegido (ainda acessível)
    # print(dog.__id)       # Isso falhará 
    print(dog._Animal__id)  # Isso funciona (acessando attribute privado com name mangling)

    # Propriedades
    dog.age = 5             # Usa setter automaticamente
    print(dog.age)          # Usa getter automaticamente

    # Métodos estáticos e de classe
    print(Animal.get_kingdom())
    print(Animal.get_species_count())

    # Verifica herança
    print(isinstance(dog, Animal))  # True
    print(issubclass(Dog, Animal)) # True

    # Métodos especiais em ação
    print(str(dog))        # Usa __str__
    print(repr(dog))       # Usa __repr__
    print(len(dog))        # Usa __len__
    print(dog['name'])     # Usa __getitem__

C 98

int main() {
    // Cria objetos
    Dog dog("Rex", "Golden Retriever");

    // Acessa atributos
    std::cout ()) {
        std::cout 



<h2>
  
  
  Python 和 C 之間的主要區別 98
</h2>

<ol>
<li>沒有公有/私人/受保護的關鍵字（使用命名約定）</li>
<li>多重繼承不同：

<ul>
<li>Python 使用方法解析順序 (MRO) 和 C3 線性化</li>
<li>不需要像 C 那樣的虛擬繼承 </li>
<li>
super() 自動遵循 MRO</li>
<li>Python 中基類的順序很重要</li>
<li>您可以使用 __mro__ 檢查解析順序
</li>
</ul>
</li>
<li>預設所有方法都是虛擬的</li>
<li>指標/引用之間沒有差異</li>
<li>不需要記憶體管理（垃圾收集器）</li>
<li>動態型別而不是靜態型別</li>
<li>屬性裝飾器而不是 getter/setter 方法</li>
<li>特殊方法使用 __name__ 格式而不是運算符</li>關鍵字
<li>更多用於運算子重載的 Pythonic 語法（例如 __eq__ 與運算子 ==）</li>
</ol>

<p>使用 dir(object) 檢視物件的所有屬性和方法，使用 help(object) 檢視文件。 </p>

<h2>
  
  
  專題：
</h2>

<h2>
  
  
  鑽石繼承問題
</h2>



<pre class="brush:php;toolbar:false">                              Animal

                           .    '    ,
                             _______
                        _  .`_|___|_`.  _
                    Pet     \ \   / /     WorkingAnimal
                             \ ' ' /
                              \ " /   
                               \./

                           DomesticDog

C 98 中的鑽石繼承問題

當一個類別繼承自兩個類，而這兩個類別又繼承自一個公共基類時，就會發生鑽石繼承。這可能會導致幾個問題：

1. 歧義：公共基類的方法和屬性可能會變得不明確。
2. 資料重複：每個衍生類別都可以擁有自己的公共基類成員副本，從而導致資料重複。

C 98 中的鑽石繼承範例

class Animal {
public:
    Animal() {
        std::cout 



<h3>
  
  
  預期行為
</h3>



<pre class="brush:php;toolbar:false">Animal constructor
Pet constructor
WorkingAnimal constructor
DomesticDog constructor
Pet sound

在這個例子中，DomesticDog繼承自Pet和WorkingAnimal，它們都繼承自Animal。這創造了一顆傳家鑽石。使用虛擬繼承來避免資料重複和歧義。

Python 如何自動阻止 Diamond 繼承

Python 使用方法解析順序 (MRO) 和 C3 線性化來自動解決菱形繼承問題。 MRO 決定在尋找方法或屬性時檢查類別的順序。

Python 中的 Diamond 繼承範例

# Privado por convenção: _underscore_simples
# "Realmente privado": __underscore_duplo (name mangling)
# Público: sem underscore

from abc import abstractmethod
class Animal(ABC):
    # Em python, variáveis declaradas no escopo da classe e não dentro de um
    # método específico, são automaticamente compartilhadas por todas instâncias.
    species_count = 0 # além disso, elas podem ser inicializadas diretamente dentro da classe.

    # Construtor
    def __init__(self, name):
        # Variáveis de instância
        self.name = name       # público
        self._age = 0          # protegido por convenção
        self.__id = id(self)   # privado (mas você consegue acessar com name mangling)
        Animal.species_count += 1

    # Destrutor
    def __del__(self):
        Animal.species_count -= 1

    # Método regular
    @abstractmethod
    def make_sound(self):
        pass  # Equivalente a um método abstrato/virtual (deve ser implementado apenas nas classes filhas)

    # Método estático (não precisa da instância para ser utilizado, nem utiliza seus atributos)
    @staticmethod
    def get_kingdom():
        return "Animalia"

    # Método de classe (recebe a classe como primeiro argumento, pode acessar atributos da classe)
    @classmethod
    def get_species_count(cls):
        return cls.species_count

    # Decorador de propriedade (getter)
    @property
    def age(self):
        return self._age

    # Decorador de propriedade (setter)
    @age.setter
    def age(self, value):
        if value >= 0:
            self._age = value

    # Métodos especiais (sobrecarga de operadores)
    def __str__(self):                # Como toString() - para string legível
        return f"Animal named {self.name}"

    def __repr__(self):               # Para debugging
        return f"Animal(name='{self.name}')"

    def __eq__(self, other):          # Operador de comparação ==
        return isinstance(other, Animal) and self.name == other.name

    def __len__(self):                # Função len()
        return self._age

    def __getitem__(self, key):       # Operador de acesso []
        if key == 'name':
            return self.name
        raise KeyError(key)

預期行為

#include <iostream>
#include <string>
#include <sstream>

class Animal {
public:
    static int species_count;

    Animal(const std::string& name) : name(name), _age(0), __id(++id_counter) { // construtor
        ++species_count;
    }

    ~Animal() {    // destrutor
        --species_count;
    }

    virtual void make_sound() = 0; // Método não implementável na classe base (virtual/abstrato)

    static std::string get_kingdom() {  // Não existe distinção entre
    //  @classmethod e @staticmethod em cpp, apenas static methods.
        return "Animalia";
    }

    // static methods podem ser utilizados sem instanciar uma classe e têm
    // acesso às propriedades estáticas da classe:
    static int get_species_count() {
        return species_count;
    }

    // getter:
    int get_age() const {
        return _age;
    }

    // setter:
    void set_age(int age) {
        if (age >= 0) {
            _age = age;
        }
    }

    // Implementação dos métodos especiais que vimos em python:
    std::string to_string() const {
        return "Animal named " + name;
    }

    std::string repr() const {
        std::ostringstream oss;
        oss 



<h2>
  
  
  Herança
</h2>

<h3>
  
  
  Python
</h3>



<pre class="brush:php;toolbar:false">class Dog(Animal):
    def __init__(self, name, breed):
        # Chama o construtor da classe pai
        super().__init__(name)
        self.breed = breed

    # Sobrescreve o método da classe pai
    def make_sound(self):
        return "Woof!"

在此範例中，Python 使用 MRO 自動解析菱形繼承。您可以使用 __mro__:
屬性檢查 MRO

class Dog : public Animal {
public:
    Dog(const std::string& name, const std::string& breed) : Animal(name), breed(breed) {}

    void make_sound() override {
        std::cout 



<p>Python中的MRO確保DomesticDog正確繼承自Pet和WorkingAnimal，並且Animal在物件之前被解析。因此，聲明順序會影響 MRO，但 C3 線性化可確保尊重層次結構。 </p>

<h2>
  
  
  解釋：
</h2>

<ol>
<li>
<strong>聲明順序</strong>：MRO 從最衍生的類別開始，遵循基底類別聲明的順序。 </li>
<li>
<strong>C3 線性化</strong>：確保每個類別出現在其超類別之前，並保持繼承順序。 </li>
</ol>

<h2>
  
  
  資料結構：堆疊、佇列和映射
</h2>

<h3>
  
  
  堆疊
</h3>

<h4>
  
  
  Python
</h4>



<pre class="brush:php;toolbar:false">class Pet:
    def is_vaccinated(self):
        return True

class DomesticDog(Dog, Pet):
    pass

C 98

class Pet {
public:
    bool is_vaccinated() const {
        return true;
    }
};

class DomesticDog : public Dog, public Pet {
public:
    DomesticDog(const std::string& name, const std::string& breed) : Dog(name, breed) {}
};

佇列

Python

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

C 98

class Shape {
public:
    virtual ~Shape() {}
    virtual double area() const = 0;
};

地圖

Python

if __name__ == "__main__":
    # Cria objetos
    dog = Dog("Rex", "Golden Retriever")

    # Acessa atributos
    print(dog.name)          # Público
    print(dog._age)         # Protegido (ainda acessível)
    # print(dog.__id)       # Isso falhará 
    print(dog._Animal__id)  # Isso funciona (acessando attribute privado com name mangling)

    # Propriedades
    dog.age = 5             # Usa setter automaticamente
    print(dog.age)          # Usa getter automaticamente

    # Métodos estáticos e de classe
    print(Animal.get_kingdom())
    print(Animal.get_species_count())

    # Verifica herança
    print(isinstance(dog, Animal))  # True
    print(issubclass(Dog, Animal)) # True

    # Métodos especiais em ação
    print(str(dog))        # Usa __str__
    print(repr(dog))       # Usa __repr__
    print(len(dog))        # Usa __len__
    print(dog['name'])     # Usa __getitem__

C 98

int main() {
    // Cria objetos
    Dog dog("Rex", "Golden Retriever");

    // Acessa atributos
    std::cout ()) {
        std::cout 



<p>感謝您關注本有關 Python 和 C 98 中的 OOP 概念的指南。我們希望它對您的學習之旅有所幫助。如果您喜歡內容，請留下您的評論、按讚並分享給您的朋友和同事。如果您發現錯誤，請留下您的評論，我會糾正它！下次見！ </p>


          

            
        

以上是面向 C 程式設計師的 Python 中的 OOP 概念 98的詳細內容。更多資訊請關注PHP中文網其他相關文章！