Cara menggunakan kelas dan kaedah dalam Python

Konsep dan contoh kelas dan kaedah

• Kelas (Kelas): Digunakan untuk menerangkan koleksi objek dengan sifat dan kaedah yang sama. Ia mentakrifkan sifat dan kaedah yang biasa kepada setiap objek dalam koleksi. Objek ialah contoh kelas.

• Kaedah : Fungsi yang ditakrifkan dalam kelas.

• Kaedah pembina kelas __init__(): Kelas mempunyai kaedah khas (pembina) yang dipanggil init(), yang digunakan apabila kelas diwujudkan akan menjadi dipanggil secara automatik.

• Pembolehubah instance: Dalam pengisytiharan kelas, atribut diwakili oleh pembolehubah jenis ini dipanggil pembolehubah instance menggunakan pembolehubah Ubahsuai sendiri.

• Instantiation: Buat tika kelas, objek khusus kelas.

• Warisan: Iaitu, kelas terbitan mewarisi medan dan kaedah kelas asas. Warisan juga membenarkan objek kelas terbitan untuk dianggap sebagai objek kelas asas. Sebagai contoh, terdapat reka bentuk sedemikian: objek jenis Anjing berasal daripada kelas Haiwan, yang menyerupai perhubungan "ialah-a" (contohnya, Anjing ialah Haiwan).

1. kelas ular sawa: kelas

Kelas (kelas) Python adalah bersamaan dengan keluarga yang terdiri daripada pelbagai fungsi Jika ada orang bernama Myclass dalam keluarga besar ini f, jika f ini mempunyai fungsi untuk mencetak cuaca, maka jika suatu hari nanti saya memerlukan f ini untuk mencetak cuaca hari ini, maka saya mesti memanggil nama penuhnya MyClass.f sebelum dia boleh mencetaknya kepada saya, iaitu selepas memanggilnya Anda perlu membawa nama keluarganya + namanya.

• Atribut: Atribut ialah pembolehubah dalam kelas ini. Jika pembolehubah ialah item, maka atribut yang berbeza adalah item yang berbeza dalam keluarga ini

• Kaedah : Kaedah ialah fungsi dalam kelas ini. Jika fungsi adalah orang, maka kaedah yang berbeza adalah orang yang berbeza dalam keluarga besar ini.

Instance MyClass:

#Myclass家族，但是这个家族只有一个人f
class MyClass:   
  """一个简单的类实例"""    
  i = 12345    
  def f(self):        
    return 'hello world'
# 实例化类
x = MyClass() 
# 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i) #家族x + 物品名i
print("MyClass 类的方法 f 输出为：", x.f()) #家族x + 人名f

Hasil keluaran:

2. Kaedah pembinaan kelas__init__()

Jika init() juga seorang, tetapi dia adalah penghubung antara keluarga dan dunia luar, apabila orang dari luar mahu memanggil orang dari keluarga mereka sendiri, mereka mesti terlebih dahulu Beritahu dia bahawa selagi ahli keluarga dipanggil, init() akan dilaksanakan terlebih dahulu, dan kemudian dia akan memberitahu orang yang dipanggil untuk melaksanakan yang dipanggil.

init() instance:

class Complex:
    def __init__(self, realpart, imagpart): #必须要有一个self参数，
        self.r = realpart
        self.i = imagpart
x = Complex(3.0, -4.5)
print(x.r, x.i)   # 输出结果：3.0 -4.5

Hasil keluaran:

3. Parameter kaedah dalam kelas self

Di dalam kelas, gunakan kata kunci def untuk mentakrifkan kaedah Berbeza daripada takrifan fungsi umum, kaedah kelas mesti memasukkan parameter diri, yang merupakan parameter pertama. diri mewakili contoh kelas.

• diri: Terdapat hanya satu perbezaan istimewa antara kaedah kelas dan fungsi biasa - mesti ada nama parameter pertama tambahan, mengikut kebiasaannya Nama itu sendiri.

• Instance of class: Ia adalah untuk menggunakan kelas dalam senario instance Contohnya, fungsi dalam kelas ialah f Jika f ini mempunyai cetak pada masa tertentu Keupayaan keadaan cuaca, maka jika saya memerlukan f ini untuk mencetak cuaca pada pukul 12 hari ini, maka tindakan membiarkan dia mencetak cuaca pada pukul 12 hari ini adalah instantiasi kelas, menjadikan keupayaan fungsi dalam tindakan kelas sebenar.

Instance instance:

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    #定义构造方法
    def __init__(self,n,a):
        self.name = n
        self.age = a
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))

# 实例化类
p = people('Python',10,30)
p.speak()

Hasil keluaran:

4. Harta pusaka

Jika ada dua keluarga, satu daripadanya, Keluarga A, mula merosot, dan satu lagi keluarga baru, B, ingin mewarisi bahan dan hamba keluarga A, maka anda boleh melakukan perkara berikut: Kaedah untuk mencapai warisan, di sini, keluarga A ialah kelas induk, keluarga B ialah subkelas. Dari segi penggunaan, jika keluarga B boleh menggunakan barang dan orang suruhan keluarga A sesuka hati.

class [子类]([父类]):

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

• Python juga menyokong warisan berbilang, yang bermaksud anda boleh mewarisi berbilang kelas induk. Kaedah pewarisan adalah sama dengan kaedah pewarisan tunggal, dan kaedahnya adalah seperti berikut:

class [子类]([父类]1, [父类]2, [父类]3):

Contoh pewarisan:

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))

#单继承示例
class student(people): #student为子类，people为父类
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))

s = student('ken',10,60,3)
s.speak()

Keputusan larian:

5.方法重写

如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法。即如果B家族继承了A家族，但是B家族有个佣人只会扫地，于是A家族给这个人洗脑，让他啥都不会，然后再教这个佣人洗碗、擦桌子的技能，那么这个佣人就只会洗碗和擦桌子了。

• super()函数是用于调用父类(超类)的一个方法。

方法重写实例：

class Parent:        # 定义父类
   def myMethod(self):
      print('调用父类方法')

class Child(Parent): # 定义子类
   def myMethod(self):
      print('调用子类方法')

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

输出结果：

类的特殊属性与方法

类的私有属性

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

私有属性实例：

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)  # 报错，实例不能访问私有变量

输出结果：

类的私有方法

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

私有方法实例：

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('Python', 'www.irvingao.com')
x.who()        # 正常输出
x.foo()        # 正常输出
x.__foo()      # 报错

输出结果：

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