Apakah kaedah asas menggunakan kelas Python?

1. Berorientasikan objek

Kelas (kelas): Ia ialah koleksi objek yang digunakan untuk menerangkan atribut dan kaedah yang sama.

Pembolehubah kelas: Pembolehubah kelas adalah awam di seluruh objek yang diinstantiate. Ditakrifkan secara amnya di dalam kelas dan di luar badan fungsi.

Kaedah: Fungsi dalam kelas

Ahli data: Pembolehubah kelas atau pembolehubah instance digunakan untuk memproses data yang berkaitan dengan kelas dan objek instancenya.

Penulisan semula kaedah: Jika kaedah yang diwarisi daripada kelas induk tidak dapat memenuhi keperluan subkelas, ia boleh ditulis semula Proses ini dipanggil penggantian kaedah, juga dikenali sebagai penulisan semula kaedah.

Pembolehubah setempat: Pembolehubah yang ditakrifkan dalam kaedah hanya bertindak pada kelas tika semasa.

Pembolehubah instance: Dalam pengisytiharan kelas, atribut diwakili oleh pembolehubah sedemikian dipanggil pembolehubah instance ialah pembolehubah yang diubah suai dengan diri.

Warisan: Kelas terbitan mewarisi medan dan kaedah kelas asas. Warisan juga membenarkan objek kelas terbitan untuk dianggap sebagai objek kelas asas. Sama seperti kita mentakrifkan kelas buah-buahan, dan kemudian mentakrifkan epal kelas terbitan, yang mempunyai beberapa sifat dan kaedah kelas buah-buahan, dan juga mempunyai beberapa sifat unik dan kaedahnya sendiri, yang serupa dengan kelas buah-buahan hubungan 'adalah-sebuah'.

Instantiation: Objek khusus kelas Imej kelas adalah bersamaan dengan templat Hanya selepas kami menjadikannya sebagai objek, kami boleh melakukan operasi yang sepadan padanya.

Objek: Contoh struktur data yang ditakrifkan oleh kelas. Objek termasuk dua ahli data (pembolehubah kelas dan pembolehubah contoh) dan kaedah.

---

2. Definisi kelas

Tentukan kelas:

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

Adalah disyorkan bahawa nama kelas dinamakan dalam kes unta, atau semua huruf besar

---

3 Gunakan kaedah objek kelas

Objek kelas menyokong dua operasi: rujukan atribut dan instantiasi

Rujukan atribut: dan dalam python Sintaks yang lain adalah sama, obj.name

Atribut dengan __ dalam kelas ialah atribut peribadi kelas tidak boleh diakses terus di luar kelas, seperti __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()))

Hasil keluaran ialah:

We have 100 fruitsWe have 200 fruits

---

4 Kaedah pembinaan

Terdapat kaedah khas yang dipanggil __init__() dalam kelas python, dipanggil pembinaan. kaedah, yang dilaksanakan dalam kelas Ia akan dipanggil secara automatik semasa instantiasi (boleh digunakan untuk permulaan atribut kelas, dll.), serupa dengan pembina kelas dalam C++. Kelas

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

mentakrifkan kaedah __init__() dan operasi instantiasi kelas akan memanggil kaedah __init__() secara automatik.

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

Hasil keluaran

你已经实例化了一个对象

Kaedah init_() boleh mempunyai parameter dan parameter dihantar ke operasi instantiasi kelas melalui init().

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()

Hasil keluaran adalah seperti berikut:

complex real is 3.50 , image is -3.00

diri mewakili contoh kelas, bukan kelas. Terdapat hanya satu perbezaan istimewa antara kaedah kelas dan fungsi biasa - mereka mesti mempunyai nama parameter pertama tambahan, yang mengikut konvensyen adalah diri. Tetapi diri bukan kata kunci dalam Python.

Saya tertanya-tanya sama ada ia boleh difahami dengan cara ini, diri mewakili alamat objek selepas anda membuat instantiat objek mengikut kelas. Sama seperti penunjuk ini dalam kelas C++

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

Output:

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

---

5. Kaedah kelas

Di dalam kelas, gunakan Kata Kunci def untuk mentakrifkan kaedah Tidak seperti definisi fungsi umum, kaedah kelas mesti mengandungi parameter diri, yang merupakan parameter pertama. Jika anda tidak memerlukan diri untuk lulus parameter, anda perlu menambah @staticmethod di hadapan fungsi, menunjukkan bahawa kaedah statik

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)

mengeluarkan hasil

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

---

6. Warisan

Python juga menyokong warisan kelas, formatnya adalah seperti berikut:

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

Nama kelas asas (nama kelas asas) mesti ditakrifkan dalam skop yang sama dengan kelas terbitan. Selain kelas, anda juga boleh menggunakan ungkapan, yang sangat berguna apabila kelas asas ditakrifkan dalam modul lain:

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()

Output:

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

Warisan berbilang

Python boleh juga Mewarisi berbilang kelas asas:

class Derivedclassname(basename1,basename2,...):    ...    ...    ...

Anda perlu memberi perhatian kepada susunan kelas induk dalam kurungan Jika terdapat nama kaedah yang sama dalam kelas induk, tetapi ia tidak dinyatakan semasa menggunakan subclass, Python mencari dari kiri ke kanan, iaitu Apabila kaedah tidak ditemui dalam subkelas, cari dari kiri ke kanan untuk melihat sama ada kaedah itu termasuk dalam kelas induk.

class Fruit:def __init__(self, sweet):        self.sweetness = sweetdef describe(self):        print('Our fruit has a sweetness of %.2f' % self.sweetness)

class Food:def __init__(self, uprice, num):        self.unit_price = uprice        self.number = num        self.total_price = num * upricedef cost(self):        print('You need to pay {0:.3} yuan, thank you'.format(self.total_price))

class Apple(Fruit, Food):def __init__(self, sweet, color, uprice, num):        self.color = color        Fruit.__init__(self, sweet)        Food.__init__(self, uprice, num)def describe(self):        print('Our fruit has a sweetness of {0:.2f}%,and color is {1}'.format(self.sweetness, self.color))

rrree

Output:

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__: 乘方

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

Atas ialah kandungan terperinci Apakah kaedah asas menggunakan kelas Python?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!