Was sind die grundlegenden Methoden zur Verwendung von Python-Klassen?

1. Objektorientiert

Klasse (Klasse): Es ist eine Sammlung von Objekten, die zur Beschreibung derselben Eigenschaften und Methoden verwendet werden.

Klassenvariablen: Klassenvariablen sind im gesamten instanziierten Objekt öffentlich. Im Allgemeinen in der Klasse und außerhalb des Funktionskörpers definiert.

Methode: Funktion in der Klasse

Datenmitglieder: Klassenvariablen oder Instanzvariablen werden verwendet, um Daten zu verarbeiten, die sich auf die Klasse und ihre Instanzobjekte beziehen.

Methodenumschreibung: Wenn die von der übergeordneten Klasse geerbte Methode die Anforderungen der Unterklasse nicht erfüllen kann, kann sie umgeschrieben werden. Dieser Vorgang wird als Methodenüberschreibung oder Methodenumschreibung bezeichnet.

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. Eine Instanzvariable ist eine mit self modifizierte Variable.

Vererbung: Eine abgeleitete Klasse erbt die Felder und Methoden einer Basisklasse. Durch Vererbung kann ein Objekt einer abgeleiteten Klasse auch als Basisklassenobjekt behandelt werden. Genauso wie wir eine Fruchtklasse definieren und dann eine abgeleitete Klasse Apfel definieren, die einige Eigenschaften und Methoden der Fruchtklasse sowie einige eigene einzigartige Eigenschaften und Methoden aufweist, die der Fruchtklasse ähneln „ist-eine“-Beziehung.

Instantiierung: Ein bestimmtes Objekt der Klasse entspricht einer Vorlage. Erst nachdem wir es in ein Objekt instanziiert haben, können wir entsprechende Operationen daran ausführen.

Objekt: Eine Instanz einer durch eine Klasse definierten Datenstruktur. Zu den Objekten gehören zwei Datenelemente (Klassenvariablen und Instanzvariablen) und Methoden.

---

2. Klassendefinition

Klasse definieren:

class ClassName:....    ....    ....

Es wird empfohlen, es zu verwenden Kamelfall für Klassennamen Formelname oder alle Großbuchstaben

---

3. Verwenden Sie Klassenobjektmethoden

Klassenobjekte unterstützen zwei Operationen: Attributreferenz und Instanziierung

Attributreferenz: Wie andere Syntax in Python, obj.name

Die Attribute mit __ in der Klasse sind private Attribute der Klasse und die Private Attribute befinden sich außerhalb der Klasse und können nicht direkt aufgerufen werden, z. B. __name.

class Fruit:#这是类的一个基本属性self.number = 100def get_number(self):                a = self.number + 100return a

f = Fruit()print('We have {0} fruits'.format(f.number))print('We have {0} fruits'.format(f.get_number()))

Ausgabeergebnis:

We have 100 fruitsWe have 200 fruits

---

4, Konstruktionsmethode #🎜🎜 #

In der Python-Klasse gibt es eine spezielle Methode namens __init__(), die als Konstruktionsmethode bezeichnet wird. Diese Methode wird automatisch aufgerufen, wenn die Klasse instanziiert wird (kann zur Initialisierung von Klassenattributen verwendet werden). usw.), ähnlich der Klasse im Konstruktor von C++.

def __init__(self):self.data = []

Die Klasse definiert die Methode __init__(), und die Instanziierungsoperation der Klasse ruft automatisch die Methode __init__() auf.

class Fruit:def __init__(self):                print('你已经实例化了一个对象')
f = Fruit()

Ausgabeergebnis

你已经实例化了一个对象

init_()-Methode kann Parameter haben, und die Parameter werden über init() an die Instanziierungsoperation der Klasse übergeben.

class Complex:def __init__(self,real,image):self.r = realself.i = imagedef get_complex(self):                print('complex real is %.2f , image is %.2f'%(self.r,self.i))
a = Complex(3.5,-3)a.get_complex()

Die Ausgabe ist wie folgt:

complex real is 3.50 , image is -3.00

self repräsentiert eine Instanz einer Klasse, keine Klasse. Es gibt nur einen besonderen Unterschied zwischen Klassenmethoden und gewöhnlichen Funktionen: Sie müssen einen zusätzlichen ersten Parameternamen haben, der laut Konvention self ist. Aber self ist kein Schlüsselwort in Python.

Ich frage mich, ob Self die Adresse des Objekts darstellt, nachdem Sie ein Objekt gemäß einer Klasse instanziiert haben. Ähnlich wie dieser Zeiger in einer C++-Klasse

class Test:def prt(self):        print(self)        print(self.__class__)
t = Test()t.prt()

Ausgabe:

<__main__.Test object at 0x0000025EC6D45608><class &#39;__main__.Test&#39;>

---

5. Klassenmethode #🎜 🎜#Verwenden Sie innerhalb der Klasse das Schlüsselwort def, um eine Methode zu definieren. Anders als bei der allgemeinen Funktionsdefinition muss die Klassenmethode den Parameter self enthalten, der der erste Parameter ist. Wenn Sie keine Parameter selbst übergeben müssen, müssen Sie @staticmethod vor der Funktion hinzufügen, um eine statische Methode anzugeben #

6. Vererbung

Python unterstützt auch Klassenvererbung, das Format ist wie folgt:

class Complex:def __init__(self, real=None, image=None):self.r = realself.i = image
def get_complex(self):        print('complex real is %.2f , image is %.2f' % (self.r, self.i))
    @staticmethoddef test(a, b):        print('complex real is %.2f , image is %.2f' % (a, b))

a = Complex(3.5, -3)a.get_complex()
b = Complex()b.test(3, -2)

---

Baseclassname (Basisklassenname) muss definiert werden im gleichen Bereich wie die abgeleitete Klasse. Zusätzlich zu Klassen können Sie auch Ausdrücke verwenden, was sehr nützlich ist, wenn die Basisklasse in einem anderen Modul definiert ist:

complex real is 3.50 , image is -3.00complex real is 3.00 , image is -3.00

Ausgabe:

class Derivedclassname(Baseclassname):    ...    ...

Mehrfachvererbung#🎜🎜 ## 🎜🎜#Python kann auch mehrere Basisklassen erben:

class Fruit:    def __init__(self,sweet):        self.sweetness = sweet    def describe(self):        print('Our fruit has a sweetness of %.2f'%self.sweetness)
class Apple(Fruit):#单继承，继承fruit类    def __init__(self,sweet,color):        self.color = color        Fruit.__init__(self,sweet)    def describe(self):#改写基类fruit的方法        print('Our apple has a sweetness of {0:.2f}%,and color is {1}'.format(self.sweetness,self.color))

apple = Apple(62.2,'red')apple.describe()

Sie müssen auf die Reihenfolge der übergeordneten Klasse in Klammern achten, wenn in der übergeordneten Klasse derselbe Methodenname vorhanden ist. Wenn Sie es jedoch in der Unterklasse verwenden, wird es nicht angegeben. Python sucht von links nach rechts. Wenn die Methode nicht in der Unterklasse gefunden wird, sucht es von links nach rechts, um festzustellen, ob die Methode in der übergeordneten Klasse enthalten ist.

Our apple has a sweetness of 62.20%,and color is red

rrreeAusgabe:

Our fruit has a sweetness of 62.20%,and color is redYou need to pay 73.5 yuan, thank you

---

7、方法重写

如果父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法,如果想调用已经被覆盖的基类方法，可以用super(子类名，子类实例对象名).父类方法

class Parent_class:def Method(self):         print ('父类方法')

class Child_class(Parent_class): # 定义子类def Method(self):        print ('子类方法')

c = Child_class()                # 子类实例化c.Method()                  # 子类调用重写方法super(Child_class,c).Method()    #用子类对象调用父类已被覆盖的方法

子类继承父类构造函数

如果在子类中需要父类的构造方法就需要显式地调用父类的构造方法，或者不重写父类的构造方法。

class A:def __init__(self, x, y):        self.x = x        self.y = y        print('pos is ({0},{1})'.format(self.x, self.y))
def xxx(self):        print('parent now')

class B(A):def xxx(self):        print('child now')

b = B(10, 3)b.xxx()

输出

pos is (10,3)child now

如果重写了__init__ 时，实例化子类，就不会调用父类已经定义的 __init__。

如果重写了__init__ 时，要继承父类的构造方法，可以使用 super 关键字super(子类，self).__init__(参数1，参数2，....)，或者父类名称.__init__(self,参数1，参数2，...)

---

8、类的私有属性

两个下划线开头，声明该属性为私有，像__name不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__name。

class JustCounter:     __secretCount = 0  # 私有变量    publicCount = 0  # 公开变量
def count(self):        self.__secretCount += 1        self.publicCount += 1       print(self.__secretCount)

counter = JustCounter()counter.count()counter.count()print(counter.publicCount)print(counter.__secretCount)  # 报错，实例不能访问私有变量

Traceback (most recent call last):File "test.py", line 16, in <module>    print (counter.__secretCount)  # 报错，实例不能访问私有变量AttributeError: 'JustCounter' object has no attribute '__secretCount'

两个下划线开头，声明该方法为私有方法,像__private_method，只能在类的内部调用 ，不能在类的外部调用。self.___private_method。

class Site:def __init__(self, name, url):        self.name = name  # public        self.__url = url  # private
def who(self):        print('name  : ', self.name)        print('url : ', self.__url)
def __foo(self):  # 私有方法        print('这是私有方法')
def foo(self):  # 公共方法        print('这是公共方法')        self.__foo()

x = Site('***', 'www.xxx.com')x.who() # 正常输出x.foo() # 正常输出x.__foo()  # 报错

输出：

'''name  :  ***url :  www.***.com这是公共方法这是私有方法Traceback (most recent call last):  File "F:\Python\Program\test.py", line 61, in <module>    x.__foo()      # 报错AttributeError: 'Site' object has no attribute '__foo''''

类的专有方法

__init__ : 构造函数，在生成对象时调用，类似C++构造函数

__del__: 析构函数，释放对象时使用，类似C++析构函数，常用在释放申请的内存空间

__repr__: 打印，转换。这个个函数就是在打印类的时候，控制类输出的字符串

class Name:def __init__(self, name):        self.name = name

print(Name('s'))

'''<__main__.Name object at 0x0000023744AFD248>'''

class Name:def __init__(self,name):        self.name = name
def __repr__(self): #控制了在打印类时候的输出          return 'Name({!r})'.format(self.name)

print(Name('s'))
'''Name('s')'''

__setitem__ : 每当属性被赋值的时候都会调用该方法，因此不能再该方法内赋值 self.name = value 会死循环

__getitem__: 当访问不存在的属性时会调用该方法

__len__: 获得长度,如果一个类表现得像一个list，要获取有多少个元素，就得用len() 函数。要让len()函数工作正常，类必须提供一个特殊方法__len__()，它返回元素的个数。

class CountList:def __init__(self, *args):        self.list = [x for x in args]        self.count = self.__len__()
def __len__(self):         return len(self.list)
def get_count(self):         return self.count

a = CountList(1, 2, 3, 4, 4, 5)print(a.get_count())print(len(a))

__cmp__: 比较运算

__call__: 函数调用

__add__: 加运算

__sub__: 减运算

class MyClass:
def __init__(self, height, weight):        self.height = height        self.weight = weight
# 两个对象的长相加，宽不变.返回一个新的类def __add__(self, others):        return MyClass(self.height + others.height, self.weight + others.weight)
# 两个对象的宽相减，长不变.返回一个新的类def __sub__(self, others):        return MyClass(self.height - others.height, self.weight - others.weight)
# 说一下自己的参数def intro(self):        print("高为", self.height, " 重为", self.weight)

def main():    a = MyClass(height=10, weight=5)    a.intro()
    b = MyClass(height=20, weight=10)    b.intro()
    c = b - a    c.intro()
    d = a + b    d.intro()

if __name__ == '__main__':    main()

'''高为 10  重为 5高为 20  重为 10高为 10  重为 5高为 30  重为 15'''

__mul__: 乘运算

__truediv__: 除运算

__mod__: 求余运算

__pow__: 乘方

同样的。类的专有方法也可以重写

Das obige ist der detaillierte Inhalt vonWas sind die grundlegenden Methoden zur Verwendung von Python-Klassen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!