Objektorientierte Python-Programmierung – Grundkenntnisse

Vorwort

Objektorientiert: Verwendung des Konzepts von Objekten (Entitäten), um Modelle zu erstellen und die objektive Welt zu simulieren, um Software zu analysieren, zu entwerfen und zu implementieren. Die objektorientierte Programmierung (kurz OOP) ist eine Entwurfs- und Programmiermethode, die die Wiederverwendung von Software in Form von Klassen und Objekten beschreibt das Softwaresystem zur Verbesserung der Softwareentwicklungseffizienz.

Objektorientierte Programmierung ist ein äußerst wichtiges Konzept in Python.

1. Objektorientiert und prozessorientiert

1. Zwei Arten von Softwareentwicklungs- und Designmethoden: Prozessorientierte Programmierung: Kapseln Sie den zu verwendenden Funktionscode von oben nach unten Funktionen, Schwerpunkt auf Entwicklungsschritten und -prozessen, typische Codes sind C-Sprache (Fokus auf den Prozess)

Objektorientierte Programmierung: Funktionen oder erforderliche Funktionen klassifizieren und kapseln, Schwerpunkt darauf, welche spezifischen Klassen und Funktionen die Funktionen implementieren, typische Codes sind Java, C++ und andere Sprachen (Folgen Sie den Ergebnissen)
2. 2. Objektorientierte verwandte Begriffe

Klasse: wird verwendet, um eine Sammlung von Objekten mit denselben Eigenschaften und Methoden zu beschreiben. Sie definiert die gemeinsamen Eigenschaften und Methoden zu jedem Objekt in der Sammlung. Objekte sind Instanzen von Klassen.

Instanz: auch Objekt genannt. Durch die von der Klasse definierte Initialisierungsmethode erhält sie einen bestimmten Wert und wird zu einer „Entität aus Fleisch und Blut“.
• Klassenvariablen: Klassenvariablen sind im gesamten instanziierten Objekt öffentlich. Klassenvariablen werden in der Klasse und außerhalb des Funktionskörpers definiert. Klassenvariablen werden im Allgemeinen nicht als Instanzvariablen verwendet.
• Datenmitglieder: Klassenvariablen oder Instanzvariablen, die zur Verarbeitung von Daten im Zusammenhang mit Klassen und ihren Instanzobjekten verwendet werden.
• Umschreiben der Methode: Wenn die von der übergeordneten Klasse geerbte Methode die Anforderungen der Unterklasse nicht erfüllen kann, kann dieser Vorgang als Methodenüberschreibung oder Methodenumschreiben bezeichnet werden.
• Lokale Variablen: In Methoden definierte Variablen wirken sich nur auf die Klasse der aktuellen Instanz aus.
• Instanzvariablen: In der Deklaration einer Klasse werden Attribute durch Variablen dargestellt. Solche Variablen werden Instanzvariablen genannt und innerhalb der Klassendeklaration, jedoch außerhalb anderer Mitgliedsmethoden der Klasse deklariert.
• Methode: In der Klasse definierte Funktion.
• Umschreiben der Methode: Wenn die von der übergeordneten Klasse geerbte Methode die Anforderungen der Unterklasse nicht erfüllen kann, kann dieser Vorgang als Methodenüberschreibung oder Methodenumschreiben bezeichnet werden.
• Statische Methode: Eine Methode, die von einer Klasse ohne Instanziierung ausgeführt werden kann.
• Klassenmethoden: Klassenmethoden sind Methoden, die die Klasse selbst als Objekt bearbeiten.
• Drei Hauptmerkmale der Objektorientierung:

Kapselung: Umhüllen Sie die interne Implementierung, machen Sie sie nach außen transparent und stellen Sie einen Mechanismus zum Aufrufen der API-Schnittstelle bereit.

Vererbung: Das heißt, eine abgeleitete Klasse erbt die Variablen und Methoden der übergeordneten Klasse (Basisklasse).
• Polymorphismus: Je nach Objekttyp unterschiedlich verarbeitet.
• 2. Klassen und Objekte

1. Objekte

Objekte sind der Kern der objektorientierten Programmierung, um eine Gruppe von Objekten mit gemeinsamen Eigenschaften und Verhaltensweisen abstrakt zu definieren gebildet

2. Klasse

1) Konzept

Eine Klasse ist eine Art von Sache, und das Objekt ist die spezifische Implementierung dieser Art von Sache. Klassen haben die gleichen Attribute und Verhaltensweisen

2) Die Zusammensetzung einer Klasse

Klassenname: der Name der Klasse

Attribute: Eigenschaften von Dingen
• Methoden: Was konkret zu tun ist
• 3) Abstraktion

Objekte mit gleichen oder ähnlichen Attributen und Verhaltensweisen können in eine Klasse abstrahiert werden

4) Klassifizierung von Klassen

Erstellen Sie eine Klasse mit dem Klassennamen, dann Klammern, mit dem Objekt innerhalb der Klammern, wird als Klasse neuen Stils bezeichnet und kann auch ohne Klammern und das darin enthaltene Objekt verwendet werden die Klammern, und eine solche Klasse wird klassische Klasse genannt.

# 新式类 
class Meeting2(object): 
pass 
# 经典类 
class Meeting2: 
pass

5) Erstellen Sie ein Objekt

A = Meeting1() 
B

6) self

Der erste Parameter der Klassenmethode muss self sein (er ist laut Konvention self, es können auch andere Namen sein) und muss nicht übergeben werden beim Anrufen. self stellt eine Instanz einer Klasse dar

3. Objektattribute abrufen oder hinzufügen

In der Klasse werden Attribute wie Name, Alter, Geschlecht, Adresse und Angriff sowie zwei Methoden initialisiert Einführung und Angriff sind definiert:

class Meeting(object):
"""meeting类的类描述"""

def __init__(self, name, age, sex, address, attack):
"""构造函数"""
self.name = name
self.age = int(age)
self.sex = sex
self.address = address
self.attack = int(attack)

def introduction(self):
print("姓名：{}".format(self.name))
print("年龄：{}".format(self.age))
print("性别：{}".format(self.sex))
print("地址：{}".format(self.address))

def attacked(self):
print(f"{self.name}正在向您发起攻击，攻击力为{self.attack}！")

def foreign_fun():
print("我是外部函数")

1.hasattr-Überprüfen Sie, ob das Objekt das angegebene Attribut oder die angegebene Methode enthält

Verwendung:

hasattr(object,name)

Funktion: Überprüfen Sie, ob das Objekt das angegebene Attribut oder die angegebene Methode enthält

Rückgabewert: Gibt „true“ zurück, wenn vorhanden, andernfalls gibt die Existenz „false“ zurück.

# 实例化meeting类
Meeting = Meeting("张三", 20, "男", "南京", 108)

# 获取Meeting对象中是否存在name属性
print(hasattr(Meeting, "name"))# True
# 获取Meeting对象中是否存在mobile属性
print(hasattr(Meeting, "mobile"))# False
# 获取Meeting对象中是否存在attacked方法
print(hasattr(Meeting, "attacked"))# True

2.getattr – Ruft den Attributwert des angegebenen Attributs im Objekt ab Funktion: Rufen Sie den Attributwert des angegebenen Attributs im Objekt ab

Rückgabewert: Wenn vorhanden, geben Sie den Attributwert des Attributs zurück, wenn er nicht vorhanden ist, geben Sie den angegebenen Inhalt zurück

# 实例化meeting类
Meeting = Meeting("张三", 20, "男", "南京", 108)

# 获取Meeting对象中name属性的属性值
print(getattr(Meeting, "name"))# 张三
# 获取Meeting对象中kills属性或方法的值，若不存在则返回指定内容
print(getattr(Meeting, "kills", "未找到kills方法或属性"))# 未找到kills方法或属性
# 获取Meeting对象中attacked方法，返回值为函数地址
print(getattr(Meeting, "attacked"))
# 使用getattr方法可以直接调用Meeting对象中的方法
f = getattr(Meeting, "attacked")
f()

Das Druckergebnis lautet wie folgt:

3.setattr-为object对象的name属性设置指定value

用法：

setattr(object,name,value)

作用：为object对象的指定属性设置指定value

返回值：

# 实例化meeting类
Meeting = Meeting("张三", 20, "男", "南京", 108)

# 将对象中name属性的值改为“刘德华”
setattr(Meeting, "name", "刘德华")
# 获取对象中name的属性值
print(getattr(Meeting, "name"))# 刘德华
# 将对象外部的名为foreign_fun的方法引入对象内部，并重新命名为“new_foreign_fun”
setattr(Meeting, "new_foreign_fun", foreign_fun)
# 获取对象中是否存在foreign_fun的属性或方法，返回值为True或False
print(hasattr(Meeting, "foreign_fun"))# False
# 获取对象中是否存在new_foreign_fun的属性或方法，返回值为True或False
print(hasattr(Meeting, "new_foreign_fun"))# True

打印结果如下：

四、魔法方法

1.__init__() 构造函数

__init__()方法是Python中一种特殊的方法，被称为构造函数或初始化方法，当创建这个类的实例时就会调用该方法。

class Meeting(object):
"""meeting类的类描述"""

def __init__(self, name, age, sex, address, attack):
"""构造函数"""
self.name = name
self.age = int(age)
self.sex = sex
self.address = address
self.attack = int(attack)

C = Meeting("张三", 20, "男", "南京", 108)
print(C.name)# 张三
print(C.address)# 南京

2.__del__() 析构函数

当删除对象时，Python解释器会默认调用一个方法__del__()，相当于unittest框架中的tearDown()函数

def __del__(self): 
"""析构函数""" 
print("%s攻击结束" % (self.name)) 

每调用一次对象，都会执行一次__del__()方法

3.引用计数

D = Meeting("张三", 20, "男", "南京", 108)
# 计算当前实例引用计数，D引用一次，sys.getrefcount(D)引用一次
print(sys.getrefcount(D))# 2

D对象的引用计数为2次，一次是D引用，一次是sys.getrefcount所引用的

4.__str()__字符串函数

__str__方法需要返回一个字符串，当做这个对象的描述信息，当使用print输出对象的时候，只要定义了__str__(self)方法，那么就会打印这个方法返回的数据

def __str__(self):
"""字符串函数"""
return "我是Meeting类的字符串描述"
# __str__()：字符串函数，定义__str__()方法时，打印对象，打印的是__str__()方法的返回值，否则打印类的内存地址
print(D)# 我是Meeting类的字符串描述

• 未定义__str__()方法时，打印对象，打印的是Meeting类的内存地址：<__main__.meeting object at0x014a7748>
• 定义了__str__()方法后，打印对象，打印的是__str__()方法的返回值：我是Meeting类的字符串描述

五、Python的内置属性

1.__dict__：获取类的属性

获取类的属性，包含一个字典，由类的数据属性组成

# __dict__：获取类的属性，返回值为字典类型 
print(D.__dict__) 
# {'name': '张三', 'age': 20, 'sex': '男', 'address': '南京', 'attack': 108} 

2.__doc__：获取类的文档字符串

class Meeting(object): 
 """meeting1类的类描述""" 
 
# __doc__：获取类的文档字符串 
print(D.__doc__) # meeting1类的类描述 

3.__name__：获取类名

# __name__：获取类名 
print(Meeting.__name__) # Meeting 

4.__module__：类定义所在的模块

类的全名是'__main__.clssName'，如果类位于一个导入模块mymod中，那么className.__module__等于mymod

from common.http_requests import HttpRequests
# __module__：类定义所在的模块
print(Meeting.__module__)# __main__
print(HttpRequests.__module__)# common.http_requests

Meeting类的路径为__main__，而从common文件的http_requests文件中导入了HttpRequests类，打印其路径，则为common.http_requests

5.__bases__：获取类的所有父类构成元素

获取类的所有父类构成元素（包含了一个由所有父类元素组成的元组）。例如下面有一个Song类，其继承了父类Music，则获取到的Song类的所有父类构成元素为：(,)

class Music(object):
pass

class Song(Music):
pass

print(Song.__bases__)# (<class '__main__.Music'>,)

小结

本篇文章我们介绍了面向对象的相关概念，下面来简单总结一下：

面向对象相关概念：

• 类和对象：类是一类事物，对象即是这一类事物的具体实现，类具有相同的属性和行为；
• 类的组成：类名、属性、方法
• 带object的为新式类，不带object的为经典类

获取或添加对象属性：

• hasattr：检查对象是否包含指定属性或方法
• getattr：获取对象中指定属性的属性值
• setattr：为object对象的name属性设置指定value

魔法方法：

• __init__() 构造函数：又叫初始化方法，用来初始化一些成员变量
• __del__() 析构函数：每调用一次对象，都会执行一次__del__()方法，相当于Unittest框架中的tearDown
• __str()__字符串函数：返回一个字符串，当做这个对象的描述信息

Python内置属性：

• __dict__：获取类的属性，返回值为字典类型
• __doc__：获取类的文档字符串
• __name__：获取类名
• __module__：类定义所在的模块
• __bases__：获取类的所有父类构成元素，返回类型为元组

Das obige ist der detaillierte Inhalt vonObjektorientierte Python-Programmierung – Grundkenntnisse. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!