Heim >Backend-Entwicklung >Python-Tutorial >OOP-Konzepte in Python für C-Programmierer 98
OOP-Konzepte in Python für C-Programmierer 98
- Mary-Kate OlsenOriginal
- 2024-11-16 15:50:03466Durchsuche
Hier ist eine umfassende Demonstration von OOP-Konzepten in Python für einen C 98-Programmierer:
Klassendefinition und Objekterstellung
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 << "Animal(name='" << name << "', age=" << _age << ",>
<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 << "Woof!" << std::endl;
}
private:
std::string breed;
};
Mehrfachvererbung
Python
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) {}
};
Abstrakte Klasse
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;
};
Anwendungsbeispiel
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 << dog.name << std::endl; // Público
std::cout << dog.get_age() << std::endl; // Protegido (ainda acessível)
// std::cout << dog.__id << std::endl; // Isso falhará (privado)
// Propriedades
dog.set_age(5); // Usa setter
std::cout << dog.get_age() << std::endl; // Usa getter
// Métodos estáticos e de classe
std::cout << Animal::get_kingdom() << std::endl;
std::cout << Animal::get_species_count() << std::endl;
// Equivalente aos "métodos especiais":
// Verifica herança
if (dog.isinstance<Animal>()) {
std::cout << "dog é uma instância de Animal" << std::endl;
}
std::cout << dog.to_string() << std::endl; // Usa to_string
std::cout << dog.repr() << std::endl; // Usa repr
std::cout << dog["name"] << std::endl; // Usa operador []
}
Hauptunterschiede zwischen Python und C 98
- Keine öffentlichen/privaten/geschützten Schlüsselwörter (Namenskonventionen verwenden)
- Mehrfachvererbung unterscheidet sich:
- Python verwendet Method Resolution Order (MRO) mit C3-Linearisierung
- Keine virtuelle Vererbung wie in C erforderlich
- super() folgt automatisch dem MRO
- Die Reihenfolge der Basisklassen ist in Python wichtig
- Sie können den Abwicklungsauftrag bei __mro__ einsehen.
- Alle Methoden sind standardmäßig virtuell
- Es gibt keinen Unterschied zwischen Hinweisen/Referenzen
- Keine Speicherverwaltung (Garbage Collector) erforderlich
- Dynamisches Tippen statt statisches Tippen
- Eigenschaftsdekorateure anstelle von Getter/Setter-Methoden
- Spezielle Methoden verwenden das __name__-Format anstelle des Operators Schlüsselwort
- Mehr pythonische Syntax für das Überladen von Operatoren (z. B. __eq__ vs. Operator==)
Verwenden Sie dir(object), um alle Attribute und Methoden eines Objekts anzuzeigen, und help(object) für die Dokumentation.
Spezielle Themen:
Diamant-Vererbungsproblem
Animal
. ' ,
_______
_ .`_|___|_`. _
Pet \ \ / / WorkingAnimal
\ ' ' /
\ " /
\./
DomesticDog
Probleme mit der Diamantenvererbung in C 98
Diamond-Vererbung tritt auf, wenn eine Klasse von zwei Klassen erbt, die wiederum von einer gemeinsamen Basisklasse erben. Dies kann mehrere Probleme verursachen:
- Mehrdeutigkeit: Methoden und Attribute der gemeinsamen Basisklasse können mehrdeutig werden.
- Datenduplizierung: Jede abgeleitete Klasse kann eine eigene Kopie der Mitglieder der gemeinsamen Basisklasse haben, was zu Datenduplizierung führt.
Beispiel für die Diamantenvererbung in C 98
class Animal {
public:
Animal() {
std::cout << "Animal constructor" << std::endl;
}
virtual void make_sound() {
std::cout << "Some generic animal sound" << std::endl;
}
};
class Pet : public Animal {
public:
Pet() : Animal() {
std::cout << "Pet constructor" << std::endl;
}
void make_sound() override {
std::cout << "Pet sound" << std::endl;
}
};
class WorkingAnimal : public Animal {
public:
WorkingAnimal() : Animal() {
std::cout << "WorkingAnimal constructor" << std::endl;
}
void make_sound() override {
std::cout << "Working animal sound" << std::endl;
}
};
class DomesticDog : public Pet, public WorkingAnimal {
public:
DomesticDog() : Animal(), Pet(), WorkingAnimal() {
std::cout << "DomesticDog constructor" << std::endl;
}
void make_sound() override {
Pet::make_sound(); // Ou WorkingAnimal::make_sound(), dependendo do comportamento desejado
}
};
int main() {
DomesticDog dog;
dog.make_sound();
return 0;
}
Erwartetes Verhalten
Animal constructor Pet constructor WorkingAnimal constructor DomesticDog constructor Pet sound
In diesem Beispiel erbt DomesticDog von Pet und WorkingAnimal, die beide von Animal erben. Dadurch entsteht ein Erbstückdiamant. Virtuelle Vererbung wird verwendet, um Datenduplizierung und Mehrdeutigkeit zu vermeiden.
Wie Python die Diamond-Vererbung automatisch verhindert
Python verwendet Method Resolution Order (MRO) mit C3-Linearisierung, um Diamantvererbungsprobleme automatisch zu lösen. MRO bestimmt die Reihenfolge, in der Klassen bei der Suche nach einer Methode oder einem Attribut überprüft werden.
Beispiel für die Diamantvererbung in 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)
Erwartetes Verhalten
#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 << "Animal(name='" << name << "', age=" << _age << ",>
<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!"
In diesem Beispiel löst Python die Diamantenvererbung automatisch mithilfe von MRO auf. Sie können MRO mithilfe des Attributs __mro__:
überprüfen
class Dog : public Animal {
public:
Dog(const std::string& name, const std::string& breed) : Animal(name), breed(breed) {}
void make_sound() override {
std::cout << "Woof!" << std::endl;
}
private:
std::string breed;
};
MRO in Python stellt sicher, dass DomesticDog korrekt von Pet und WorkingAnimal erbt und dass Animal vor dem Objekt aufgelöst wird. Daher beeinflusst die Deklarationsreihenfolge die MRO, aber die C3-Linearisierung stellt sicher, dass die Hierarchie eingehalten wird.
Erläuterung:
- Deklarationsreihenfolge: MRO beginnt mit der am meisten abgeleiteten Klasse und folgt der Reihenfolge, in der die Basisklassen deklariert werden.
- C3-Linearisierung: Stellt sicher, dass jede Klasse vor ihren Oberklassen erscheint und dass die Reihenfolge der Vererbung beibehalten wird.
Datenstrukturen: Stapel, Warteschlange und Karte
Stapel
Python
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) {}
};
Warteschlange
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;
};
Karte
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 << dog.name << std::endl; // Público
std::cout << dog.get_age() << std::endl; // Protegido (ainda acessível)
// std::cout << dog.__id << std::endl; // Isso falhará (privado)
// Propriedades
dog.set_age(5); // Usa setter
std::cout << dog.get_age() << std::endl; // Usa getter
// Métodos estáticos e de classe
std::cout << Animal::get_kingdom() << std::endl;
std::cout << Animal::get_species_count() << std::endl;
// Equivalente aos "métodos especiais":
// Verifica herança
if (dog.isinstance<Animal>()) {
std::cout << "dog é uma instância de Animal" << std::endl;
}
std::cout << dog.to_string() << std::endl; // Usa to_string
std::cout << dog.repr() << std::endl; // Usa repr
std::cout << dog["name"] << std::endl; // Usa operador []
}
Vielen Dank, dass Sie diesem Leitfaden zu OOP-Konzepten in Python und C 98 gefolgt sind. Wir hoffen, dass er für Ihre Lernreise nützlich war. Wenn Ihnen der Inhalt gefallen hat, hinterlassen Sie bitte einen Kommentar, liken Sie ihn und teilen Sie ihn mit Ihren Freunden und Kollegen. Wenn Sie einen Fehler gefunden haben, hinterlassen Sie Ihren Kommentar und ich werde ihn korrigieren! Bis zum nächsten Mal!
Das obige ist der detaillierte Inhalt vonOOP-Konzepte in Python für C-Programmierer 98. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
Stellungnahme：
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn
Vorheriger Artikel：Warum schlägt os.makedirs bei der Tilde-Erweiterung in Pfaden fehl?Nächster Artikel：Warum schlägt os.makedirs bei der Tilde-Erweiterung in Pfaden fehl?