Heim >Backend-Entwicklung >Python-Tutorial >Detaillierte Erläuterung von Attributen, Methoden, Kapselung und Vererbung basierend auf Python3-Klassen
Detaillierte Erläuterung von Attributen, Methoden, Kapselung und Vererbung basierend auf Python3-Klassen
- 巴扎黑Original
- 2017-09-21 10:49:582603Durchsuche
Der folgende Editor bietet Ihnen eine beispielhafte Erklärung von Attributen, Methoden, Kapselung und Vererbung basierend auf Python3-Klassen. Der Herausgeber findet es ziemlich gut, deshalb teile ich es jetzt mit Ihnen und gebe es als Referenz. Kommen Sie und schauen Sie sich den Editor an
Python-Klassen
Klassen in Python bieten alle Grundfunktionen der objektorientierten Programmierung: Klassen Die Der Vererbungsmechanismus ermöglicht mehrere Basisklassen. Eine abgeleitete Klasse kann jede Methode in der Basisklasse überschreiben, und die Methode kann die gleichnamige Methode in der Basisklasse aufrufen.
Objekte können jede beliebige Menge und Art von Daten enthalten.
Python-Klassen ähneln C++-Klassen und bieten Klassenkapselung, Vererbung, Mehrfachvererbung, Konstruktoren und Destruktoren.
In Python3 ist die übergeordnete Klasse aller Klassen die Objektklasse. Ähnlich wie in Java ist die Objektklasse ihre direkte übergeordnete Klasse, wenn die übergeordnete Klasse beim Definieren der Klasse nicht geschrieben wird.
Klassendefinition
Das Syntaxformat der Klassendefinition ist wie folgt:
class ClassName: <statement-1> . . . <statement-N>
Klassenobjekt: Nach dem Erstellen einer Klasse können Sie über den Klassennamen auf deren Attribute und Methoden zugreifen und diese ändern.
Instanzobjekt: Nachdem die Klasse instanziiert wurde, können Sie ihre Attribute verwenden und Attribute dynamisch hinzufügen das Instanzobjekt (ähnlich wie Javascript), ohne Auswirkungen auf Klassenobjekte zu haben.
Attribute der Klasse
Mit dem Punkt (.) können Sie auf die Attribute des Objekts zugreifen
Sie kann auch die folgenden Funktionen verwenden. Möglichkeiten, auf Attribute zuzugreifen:
getattr(obj, name[, default]): auf die Attribute eines Objekts zugreifen
hasattr(obj,name): prüfen, ob ein Attribut existiert
setattr(obj,name,value): Setzt ein Attribut. Wenn das Attribut nicht vorhanden ist, wird ein neues Attribut erstellt
delattr(obj, name): Attribut löschen
In Python integriertes Klassenattribut
__dict__: Attribute der Klasse (enthält ein Wörterbuch bestehend aus Datenattributen der Klasse)
__doc__: Dokumentationszeichenfolge der Klasse
__name__: Klassenname
__module__: Das Modul, in dem sich die Klassendefinition befindet (der vollständige Name der Klasse lautet „__main__.className“. Wenn sich die Klasse in einem importierten Modul mymod befindet, ist className.__module__ gleich mymod)
__bases__: Alle übergeordneten Klassenelemente der Klasse (Enthält ein Tupel, das aus allen übergeordneten Klassen besteht)
class Person:
"Person类"
def __init__(self, name, age, gender):
print('进入Person的初始化')
self.name = name
self.age = age
self.gender = gender
print('离开Person的初始化')
def getName(self):
print(self.name)
p = Person('ice', 18, '男')
print(p.name) # ice
print(p.age) # 18
print(p.gender) # 男
print(hasattr(p, 'weight')) # False
# 为p添加weight属性
p.weight = '70kg'
print(hasattr(p, 'weight')) # True
print(getattr(p, 'name')) # ice
print(p.__dict__) # {'age': 18, 'gender': '男', 'name': 'ice'}
print(Person.__name__) # Person
print(Person.__doc__) # Person类
print(Person.__dict__) # {'__doc__': 'Person类', '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__init__': <function Person.__init__ at 0x000000000284E950>, 'getName': <function Person.getName at 0x000000000284EA60>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__module__': '__main__'}
print(Person.__mro__) # (<class '__main__.Person'>, <class 'object'>)
print(Person.__bases__) # (<class 'object'>,)
print(Person.__module__) # __main__Methoden von die Klasse
Innerhalb der Klasse können Sie das Schlüsselwort def verwenden, um eine Methode für die Klasse zu definieren. Anders als bei der allgemeinen Funktionsdefinition muss die Klassenmethode den Parameter self enthalten der erste Parameter.
Proprietäre Methoden der Klasse:
__init__-Konstruktor, der beim Generieren des Objekts aufgerufen wird
__del__-Destruktor, der beim Freigeben des verwendet wird Objekt. >
__repr__ Drucken, konvertieren__setitem__Wert gemäß Index zuweisen__getitem__Wert gemäß Index abrufen__len__Länge abrufen__cmp__Vergleichsvorgang__call__Funktionsaufruf__add__Additionsoperation__sub__Subtraktionsoperation__mul__Multiplikationsoperation__p__division Operation __mod__ Restoperation __pow__ quadrat __init__() Methode ist eine spezielle Methode, die als Konstruktor oder Initialisierungsmethode einer Klasse bezeichnet wird. Diese Methode wird aufgerufen, wenn eine Instanz dieser Klasse erstellt wird, ähnlich dem Konstruktor in C++ . Überschreiben Sie einfach die Methode __init__() in Ihrer benutzerdefinierten Klasse.class Person:
def __init__(self, name, age, gender):
print('进入Person的初始化')
self.name = name
self.age = age
self.gender = gender
print('离开Person的初始化')
def getName(self):
print(self.name)
# Person实例对象
p = Person('ice', 18, '男')
print(p.name)
print(p.age)
print(p.gender)
p.getName()
# 进入Person的初始化
# 离开Person的初始化
# ice
# 18
# 男
# iceDestruktor __del__, __del__ wird aufgerufen, wenn das Objekt nicht mehr verwendet wird, wird die __del__-Methode ausgeführt:
Methode
Instanzmethode: kann nur über die Instanz aufgerufen werden. Der erste definierte Parameter der Instanzmethode kann nur eine Referenz auf die Instanz selbst seinclass Myclass:
def foo(self):
print(id(self),'foo')
a=Myclass()#既然是实例对象，那就要创建实例
a.foo()#输出类里的函数地址
print(id(a))#输出类对象的地址
#结果地址一样Klassenmethode: Um eine Klassenmethode zu definieren, verwenden Sie den Dekorator @classmethod. Der erste definierte Parameter ist ein Verweis auf das Klassenobjekt, das direkt über die Klasse oder Instanz verwendet werden kann
class Myclass:
@classmethod#类装饰器
def foo2(cls):
print(id(cls),'foo2')
#类对象，直接可以调用，不需要实例化
print(id(Myclass),'yy')
Myclass.foo2()#直接可以调用Statische Methode: Definieren Sie eine statische Methode mit dem Dekorator @staticmethod. Es gibt keine standardmäßig erforderlichen Parameter.
class Myclass:
@staticmethod#静态方法
def foo3():
print('foo3')
Myclass.foo3()#没有参数
a.foo3()
#结果foo3Klassenkapselung
Python verwendet Variablennamen, um die Zugriffsberechtigungen von Attributen und Methoden zu unterscheiden entsprechen C++ und Java. Die privaten Attribute der Klasse publicclass Demo:
__id = 123456
def getId(self):
return self.__id
temp = Demo()
# print(temp.__id) # 报错 AttributeError: 'Demo' object has no attribute '__id'
print(temp.getId()) # 123456
print(temp._Demo__id) # 123456Inheritance of class
Einer der Hauptvorteile der objektorientierten Programmierung ist die Wiederverwendung von Code, und eine Möglichkeit, diese Wiederverwendung zu erreichen, ist der Vererbungsmechanismus. Vererbung kann vollständig als Typ- und Subtypbeziehung zwischen Klassen verstanden werden.需要注意的地方：继承语法 class 派生类名（基类名）：//... 基类名写作括号里，基本类是在类定义的时候，在元组之中指明的。
在python中继承中的一些特点：
1：在继承中基类的构造（__init__()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。使用super().__init__()或parentClassName.__init__()
2：在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数
3：Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。
如果在继承元组中列了一个以上的类，那么它就被称作"多重继承" 。
语法：
派生类的声明，与他们的父类类似，继承的基类列表跟在类名之后。
多态
如果父类方法的功能不能满足需求，可以在子类重写父类的方法。实例对象调用方法时会调用其对应子类的重写后的方法
python3.3 类与继承 小例
hon中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法。
class Base:
def __init__(self):
self.data=[]
def add(self,x):
self.data.append(x)
def addtwice(self,x):
self.add(x)
self.add(x)
# child extends base
class Child(Base):
def plus(self,a,b):
return a+b
oChild=Child()
oChild.add("str1")
oChild.add(999)
oChild.addtwice(4)
print(oChild.data)
print(oChild.plus(2,3))对象可以包含任意数量和类型的数据。
python类与c++类相似，提供了类的封装，继承、多继承，构造函数、析构函数。
在python3中，所有类最顶层父类都是object类，与java类似，如果定义类的时候没有写出父类，则object类就是其直接父类。
类定义
类定义语法格式如下：
class ClassName: <statement-1> . . . <statement-N>
类对象：创建一个类之后，可以通过类名访问、改变其属性、方法
实例对象：类实例化后，可以使用其属性，可以动态的为实例对象添加属性(类似javascript)而不影响类对象。
类的属性
可以使用点(.)来访问对象的属性
也可以使用以下函数的方式来访问属性：
getattr(obj, name[, default]) : 访问对象的属性
hasattr(obj,name) : 检查是否存在一个属性
setattr(obj,name,value) : 设置一个属性。如果属性不存在，会创建一个新属性
delattr(obj, name) : 删除属性
Python内置类属性
__dict__ : 类的属性（包含一个字典，由类的数据属性组成）
__doc__ :类的文档字符串
__name__: 类名
__module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod）
__bases__ : 类的所有父类构成元素（包含了以个由所有父类组成的元组）
class Person:
"Person类"
def __init__(self, name, age, gender):
print('进入Person的初始化')
self.name = name
self.age = age
self.gender = gender
print('离开Person的初始化')
def getName(self):
print(self.name)
p = Person('ice', 18, '男')
print(p.name) # ice
print(p.age) # 18
print(p.gender) # 男
print(hasattr(p, 'weight')) # False
# 为p添加weight属性
p.weight = '70kg'
print(hasattr(p, 'weight')) # True
print(getattr(p, 'name')) # ice
print(p.__dict__) # {'age': 18, 'gender': '男', 'name': 'ice'}
print(Person.__name__) # Person
print(Person.__doc__) # Person类
print(Person.__dict__) # {'__doc__': 'Person类', '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__init__': <function Person.__init__ at 0x000000000284E950>, 'getName': <function Person.getName at 0x000000000284EA60>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__module__': '__main__'}
print(Person.__mro__) # (<class '__main__.Person'>, <class 'object'>)
print(Person.__bases__) # (<class 'object'>,)
print(Person.__module__) # __main__类的方法
在类地内部，使用def关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数self，且为第一个参数。
类的专有方法：
__init__ 构造函数，在生成对象时调用
__del__ 析构函数，释放对象时使用
__repr__ 打印，转换
__setitem__按照索引赋值
__getitem__按照索引获取值
__len__获得长度
__cmp__比较运算
__call__函数调用
__add__加运算
__sub__减运算
__mul__乘运算
__p__除运算
__mod__求余运算
__pow__称方
__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法，与c++中构造函数类似。只需在自定义的类中重写__init__()方法即可。
class Person:
def __init__(self, name, age, gender):
print('进入Person的初始化')
self.name = name
self.age = age
self.gender = gender
print('离开Person的初始化')
def getName(self):
print(self.name)
# Person实例对象
p = Person('ice', 18, '男')
print(p.name)
print(p.age)
print(p.gender)
p.getName()
# 进入Person的初始化
# 离开Person的初始化
# ice
# 18
# 男
# ice析构函数 __del__ ，__del__在对象消逝的时候被调用，当对象不再被使用时，__del__方法运行：
类的封装
python通过变量名命名来区分属性和方法的访问权限，默认权限相当于c++和java中的public
类的私有属性： __private_attrs：两个下划线开头，声明该属性为私有，不能在类地外部被使用或直接访问。在类内部的方法中使用时self.__private_attrs。
类的私有方法：__private_method：两个下划线开头，声明该方法为私有方法，不能在类地外部调用。在类的内部调用 self.__private_methods
虽然python不允许实例化的类访问私有数据，但可以使用 object._className__attrName 访问属性。其实python内部私有化的实现只是将attrName属性变为了_className__attrName而已
class Demo:
__id = 123456
def getId(self):
return self.__id
temp = Demo()
# print(temp.__id) # 报错 AttributeError: 'Demo' object has no attribute '__id'
print(temp.getId()) # 123456
print(temp._Demo__id) # 123456类的继承
面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。继承完全可以理解成类之间的类型和子类型关系。
需要注意的地方：继承语法 class 派生类名（基类名）：//... 基类名写作括号里，基本类是在类定义的时候，在元组之中指明的。
在python中继承中的一些特点：
1：在继承中基类的构造（__init__()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。使用super().__init__()或parentClassName.__init__()
2：在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数
3：Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。
如果在继承元组中列了一个以上的类，那么它就被称作"多重继承" 。
语法：
派生类的声明，与他们的父类类似，继承的基类列表跟在类名之后。
多态
如果父类方法的功能不能满足需求，可以在子类重写父类的方法。实例对象调用方法时会调用其对应子类的重写后的方法
python3.3 类与继承 小例
class Base:
def __init__(self):
self.data=[]
def add(self,x):
self.data.append(x)
def addtwice(self,x):
self.add(x)
self.add(x)
# child extends base
class Child(Base):
def plus(self,a,b):
return a+b
oChild=Child()
oChild.add("str1")
oChild.add(999)
oChild.addtwice(4)
print(oChild.data)
print(oChild.plus(2,3))Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung von Attributen, Methoden, Kapselung und Vererbung basierend auf Python3-Klassen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!