Detaillierte Erläuterung von Attributen, Methoden, Kapselung und Vererbung basierend auf Python3-Klassen

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__) # {&#39;__doc__&#39;: &#39;Person类&#39;, &#39;__weakref__&#39;: <attribute &#39;__weakref__&#39; of &#39;Person&#39; objects>, &#39;__init__&#39;: <function Person.__init__ at 0x000000000284E950>, &#39;getName&#39;: <function Person.getName at 0x000000000284EA60>, &#39;__dict__&#39;: <attribute &#39;__dict__&#39; of &#39;Person&#39; objects>, &#39;__module__&#39;: &#39;__main__&#39;}
print(Person.__mro__) # (<class &#39;__main__.Person&#39;>, <class &#39;object&#39;>)
print(Person.__bases__) # (<class &#39;object&#39;>,)
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
# 男
# ice

Destruktor __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 sein

class 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()
#结果foo3

Klassenkapselung

Python verwendet Variablennamen, um die Zugriffsberechtigungen von Attributen und Methoden zu unterscheiden entsprechen C++ und Java. Die privaten Attribute der Klasse public

: __private_attrs: beginnend mit zwei Unterstrichen, deklariert, dass das Attribut privat ist und außerhalb der Klasse nicht verwendet oder direkt darauf zugegriffen werden kann. Bei Verwendung von self.__private_attrs in einer Methode innerhalb einer Klasse.

Private Methoden der Klasse: __private_method: Beginnend mit zwei Unterstrichen wird erklärt, dass die Methode eine private Methode ist und nicht außerhalb der Klasse aufgerufen werden kann. Aufruf von self.__private_methods

innerhalb einer Klasse Obwohl Python instanziierten Klassen den Zugriff auf private Daten nicht zulässt, kann mit object._className__attrName auf Attribute zugegriffen werden. Tatsächlich ändert die Implementierung der internen Privatisierung von Python lediglich das Attribut attrName in _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

Inheritance 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__) # {&#39;__doc__&#39;: &#39;Person类&#39;, &#39;__weakref__&#39;: <attribute &#39;__weakref__&#39; of &#39;Person&#39; objects>, &#39;__init__&#39;: <function Person.__init__ at 0x000000000284E950>, &#39;getName&#39;: <function Person.getName at 0x000000000284EA60>, &#39;__dict__&#39;: <attribute &#39;__dict__&#39; of &#39;Person&#39; objects>, &#39;__module__&#39;: &#39;__main__&#39;}
print(Person.__mro__) # (<class &#39;__main__.Person&#39;>, <class &#39;object&#39;>)
print(Person.__bases__) # (<class &#39;object&#39;>,)
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!