Cara menggunakan kelas dan objek Python

Objek = Atribut + Kaedah

Kami sebenarnya telah bersentuhan dengan konsep enkapsulasi sebelum ini. 🎜> ;Membungkus segmen kod yang biasa digunakan ke dalam fungsi juga merupakan sejenis pengkapsulan ialah pengkapsulan peringkat pernyataan; objeknya adalah untuk mensimulasikan dunia sebenar, merangkum kedua-dua data dan kod bersama-sama. Sebagai contoh, kura-kura ialah objek di dunia nyata, dan ia biasanya digambarkan dalam dua bahagian.

(1) Penerangan daripada

ciri statik
: Contohnya, hijau, mempunyai empat kaki, mempunyai cangkerang, dsb. Ini ialah perihalan statik. (2) Penerangan daripada tingkah laku dinamik
: Contohnya, ia akan merangkak, jika anda mengejarnya, ia akan berlari, kadang-kadang ia akan menggigit, tidur, dan lain-lain, ini semua dari tingkah laku. aspek yang diterangkan. Hal yang sama berlaku untuk objek dalam Python,

ciri objek dipanggil "sifat"

dan kelakuan objek dipanggil "kaedah". :

Jika anda menulis penyu sebagai kod, ia akan menjadi seperti berikut:

class Turtle: # Python中的类名约定以大写字母开头
    
    # 特征的描述称为属性，在代码层面看来其实就是变量
    color = 'green'
    legs = 4
    shell = True

    # 方法实际就是函数，通过调用这些函数来完成某些工作
    def climb(self):
        print('向前爬')
    def run(self):
        print('向前跑')
    def bite(self):
        print('咬人')
    def sleep(self):
        print('睡觉')

Kod di atas mentakrifkan ciri (sifat) dan tingkah laku (kaedah)

objek

, tetapi ia belum lagi menjadi objek yang lengkap. Takrifan ini dipanggil Kelas (Kelas) . Anda perlu menggunakan kelas untuk mencipta objek sebenar. Objek ini dipanggil Instance kelas ini, juga dipanggil Objek Instance. Sebagai contoh, ini seperti kilang yang perlu menghasilkan satu siri mainan Ia perlu membuat acuan untuk mainan itu terlebih dahulu, dan kemudian mengeluarkannya secara besar-besaran berdasarkan acuan.
Jadi bagaimana untuk mencipta objek contoh sebenar?

Mencipta objek, juga dipanggil instantiasi kelas

, sebenarnya sangat mudah:

# 首先要有上面那一段类的定义
tt = Turtle()

Nota:

Nama kelas ialah diikuti dengan Tanda kurung kecil, ini sama seperti memanggil fungsi. Oleh itu, dalam Python, nama kelas bermula dengan huruf besar , dan fungsi bermula dengan huruf kecil , yang menjadikannya lebih mudah untuk dibezakan. Selain itu, operasi penugasan tidak diperlukan , tetapi jika objek contoh yang dicipta tidak ditetapkan kepada pembolehubah, objek itu tidak boleh digunakan kerana tiada rujukan kepada contoh dan akhirnya akan menjadi sampah yang dikumpul oleh Python. Mekanisme ini dikitar semula secara automatik.

Jika anda mahu

memanggil kaedah dalam objek, gunakan pengendali titik (.)

.

Seterusnya mari kita lihat sekeping kod dan fahami lebih mendalam tentang

kelas

, kelas objek dan objek contoh tiga konsep:

Seperti yang dapat dilihat daripada contoh ini,

Selepas memberikan nilai kepada atribut kiraan objek contoh c

, yang bersamaan dengan meliputi atribut kiraan objek kelas C. Seperti yang ditunjukkan dalam rajah di bawah, jika tiada liputan tugasan, maka atribut kiraan objek kelas dirujuk.

Perlu diambil perhatian bahawa atribut yang ditakrifkan dalam kelas ialah

pembolehubah statik

Atribut kelas terikat pada objek kelas dan tidak akan bergantung padanya mana-mana objek contoh. Selain itu,

Jika nama atribut adalah sama dengan nama kaedah, atribut akan mengatasi kaedah

:

Untuk mengelakkan konflik nama, Beberapa peraturan konvensional harus dipatuhi:

(1) Jangan cuba mentakrifkan semua ciri dan kaedah yang boleh dibayangkan dalam kelas Anda harus menggunakan mekanisme pewarisan dan gabungan untuk pengembangan.

(2) Gunakan bahagian pertuturan yang berbeza untuk menamakan, seperti kata nama untuk nama atribut, kata kerja untuk nama kaedah dan gunakan penamaan huruf unta.

Apakah itu diri?

Pembaca yang teliti akan mendapati bahawa kaedah objek akan mempunyai parameter diri, jadi apakah diri ini? Jika anda telah bersentuhan dengan C++, maka anda sepatutnya dapat mengetahuinya dengan mudah

Diri Python sebenarnya bersamaan dengan penunjuk C++ ini

. Sekiranya anda tidak pernah didedahkan kepada mana-mana bahasa pengaturcaraan sebelum ini, maka secara ringkasnya, jika

kelas dibandingkan dengan lukisan

, maka objek yang diwujudkan oleh kelas adalah rumah sebenar yang boleh didiami dalam . Beribu-ribu rumah boleh direka berdasarkan satu lukisan Mereka semua kelihatan serupa, tetapi setiap rumah mempunyai pemilik yang berbeza. Semua orang nak cari rumah sendiri, maka diri sendiri bersamaan dengan nombor rumah di sini Dengan diri sendiri, anda boleh mencari rumah sendiri dengan mudah. Parameter diri Python adalah sebab yang sama Objek yang tidak terkira boleh dijana daripada kelas Apabila kaedah objek dipanggil, objek akan menghantar rujukannya sendiri kepada kaedah sebagai parameter pertama, maka Python akan mengetahui yang mana kaedah objek perlu dikendalikan

.

Contoh mudah:

公有和私有

一般面向对象的编程语言都会区分公有和私有的数据类型，像C++和Java它们使用public和private关键字用于声明数据是公有的还是私有的，但在Python中并没有类似的关键字来修饰。

默认上对象的属性和方法都是公开的，可以直接通过点操作符（.）进行访问：

为了实现类似私有变量的特征，Python内部采用了一种叫name mangling（名字改编）的技术，在Python中定义私有变量只需要在变量名或函数名前加上“_ _”两个下划线，那么这个函数或变量就会成为私有的了：

这样，在外部将变量名“隐藏”起来了，理论上如果要访问，就要从内部进行：

但是认真想一下这个技术的名字name mangling（名字改编），那就不难发现其实Python只是把双下横线开头的变量进行了改名而已。实际上，在外部使用“_类名_ _变量名”即可访问双下横线开头的私有变量了：

说明：Python目前的私有机制其实是伪私有的，Python的类是没有权限控制的，所有的变量都是可以被外部调用的。

继承

举个例子来说明继承。例如现在有个游戏，需要对鱼类进行细分，有金鱼（Goldfish）、鲤鱼（Carp）、三文鱼（Salmon）以及鲨鱼（Shark）。那么我们能不能不要每次都从头到尾去重新定义一个新的鱼类呢？因为我们知道大多数鱼的属性和方法是相似的，如果有一种机制可以让这些相似的东西得以自动传递，那么就方便多了。这就是继承。

继承的语法很简单：

c l a s s 类 名 （ 被 继 承 的 类 ） : . . . class 类名（被继承的类）: \\ \quad ... class类名（被继承的类）:...

被继承的类称为基类、父类或超类；继承者称为子类，一个子类可以继承它的父类的任何属性和方法。

举个例子：

需要注意的是，如果子类中定义与父类同名的方法或属性，则会自动覆盖父类对应的方法或属性：

接下来，尝试写一下开头提到的金鱼（Goldfish）、鲤鱼（Carp）、三文鱼（Salmon）以及鲨鱼（Shark）的例子。

import random as r
class Fish:
    def __init__(self):
        self.x = r.randint(0, 10)
        self.y = r.randint(0, 10)
    def move(self):
        # 这里主要演示类的继承机制，就不考虑检查场景边界和移动方向问题
        # 假设所有的鱼都是一路向西游
        self.x -= 1
        print("我的位置是：", self.x, self.y)
# 金鱼
class Goldfish(Fish):
    pass
# 鲤鱼
class Carp(Fish):
    pass
#三文鱼
class Salmon(Fish):
    pass
# 上面三种鱼都是食物，直接继承Fish类的全部属性和方法
# 下面定义鲨鱼类，除了继承Fish类的属性和方法，还要添加一个吃的方法
class Shark(Fish):
    def __init__(self):
        self.hungry = True
    def eat(self):
        if self.hungry:
            print("吃掉你!")
            self.hungry = False
        else:
            print("太饱了，吃不下了~")

首先运行这段代码，然后进行测试：

同样是继承于Fish类，为什么金鱼（goldfish）可以移动，而鲨鱼（shark）一移动就报错呢？
可以看到报错提示为：Shark对象没有x属性，这是因为在Shark类中，重写了_ _init_ _()方法，但新的_ _init_ _()方法里面没有初始化鲨鱼的x坐标和y坐标，因此调用move()方法就会出错。
那么解决这个问题，只要在鲨鱼类中重写_ _init_ _()方法的时候先调用基类Fish的_ _init_ _()方法。

下面介绍两种可以实现的技术：

• （1）调用未绑定的父类方法

• （2）使用super函数

调用未绑定的父类方法

什么是调用未绑定的父类方法？举个例子：

修改之后，再运行下发现鲨鱼也可以成功移动了：

这里需要注意的是，这个self并不是父类Fish的实例对象，而是子类Shark的实例对象。所以这里说的未绑定是指并不需要绑定父类的实例对象，使用子类的实例对象代替即可。

Gunakan fungsi super

Fungsi super boleh membantu kami mencari kaedah kelas asas secara automatik, dan ia juga melepasi parameter diri untuk kami , jadi tidak perlu Lakukan perkara ini:

Dapatkan hasil yang sama selepas berlari:

Pewarisan berbilang

Selain itu, Python juga menyokong warisan berbilang, iaitu, anda boleh mewarisi atribut dan kaedah berbilang kelas induk pada masa yang sama :

nama kelas c l a s (kelas ibu bapa 1, kelas ibu bapa 2, kelas ibu bapa 3, . . . ): . ...): \ quad .. . nama kelas kelas (kelas ibu bapa 1, kelas ibu bapa 2, kelas ibu bapa 3,...):...

Contohnya: <.>

Ini ialah sintaks warisan berbilang asas, tetapi warisan berbilang boleh membawa kepada kekeliruan kod dengan mudah, jadi apabila anda tidak pasti sama ada anda benar-benar perlu menggunakan warisan berbilang, sila cuba elakkan menggunakannya, kerana kadangkala BUG yang tidak dijangka mungkin berlaku.

Komposisi

Kami telah mempelajari konsep pewarisan sebelum ini, dan menyebut pewarisan berbilang, tetapi jika kami kini mempunyai penyu dan ikan, kami kini dikehendaki mentakrifkan kelas yang dipanggil kolam, dan kolam mesti Ada penyu dan ikan. Nampaknya pelik menggunakan pelbagai warisan, kerana kolam, penyu dan ikan adalah spesies yang berbeza, jadi bagaimana untuk menggabungkannya ke dalam kelas kolam?

Sebenarnya, ia sangat mudah dalam Python Hanya
masukkan kelas yang diperlukan ke dalamnya dan nyatakannya Ini dipanggil kombinasi:

.

Mula-mula jalankan kod di atas, dan kemudian uji:

Pembinaan dan pemusnahan

Objek Python mempunyai banyak kaedah magics, jika objek anda melaksanakan salah satu kaedah ini, maka kaedah ini akan dipanggil oleh Python dalam keadaan khas, dan semua ini berlaku

secara automatik.

_ _init_ _(self[, …]) constructor

Biasanya kaedah _ _init_ _() dipanggil constructor Selagi objek dijadikan instantiated,

kaedah ini akan dipanggil secara automatik apabila objek dibuat. Parameter boleh dihantar masuk apabila membuat seketika objek Parameter ini akan dihantar secara automatik ke dalam kaedah _ _init_ _() Anda boleh menyesuaikan operasi pemulaan objek dengan mengatasi kaedah ini.

Contohnya:

Sesetengah pembaca mungkin bertanya, kadangkala kaedah _ _init_ _() ditulis dalam definisi kelas , kadang-kadang tidak, kenapa? Lihat contoh berikut:

Perlu diperhatikan di sini bahawa nilai pulangan kaedah

_ _init_ _() mestilah Tiada dan tidak boleh yang lain :

Jadi,

secara amnya menulis semula kaedah _ _init_ _() apabila permulaan diperlukan. Jadi kaedah _ _init_ _() ini bukan kaedah pertama yang dipanggil semasa membuat instantiat objek. _ _new_ _(cls[, …]) kaedah

_ _new_ _() kaedah ialah kaedah pertama yang dipanggil apabila

sesuatu objek di instantiated

. Berbeza daripada kaedah lain, parameter pertamanya bukan sendiri tetapi kelas (cls) , dan parameter lain akan dihantar terus ke kaedah _ _init_ _(). Kaedah _ _new_ _() memerlukan

untuk mengembalikan objek contoh

, biasanya objek yang dibuat instantiated oleh kelas cls, anda juga boleh mengembalikan objek lain. Kaedah _ _new_ _() jarang menulis semula secara amnya, Python boleh dilaksanakan dengan skema lalai. Tetapi

terdapat situasi di mana anda perlu mengatasi kaedah ini

, iaitu, apabila mewarisi jenis tidak berubah , ciri-cirinya menjadi sangat penting.

_ _del_ _(self) kaedah pemusnah

Jika kaedah _ _init_ _() dan _ _new_ _() ialah pembina objek , maka Python juga menyediakan pemusnah yang dipanggil kaedah _ _del_ _().

Apabila objek akan dimusnahkan, kaedah ini akan dipanggil

. Walau bagaimanapun, perlu diambil perhatian bahawa del x tidak bersamaan dengan memanggil x secara automatik._ _del_ _() Kaedah _ _del_ _() dipanggil apabila mekanisme pengumpulan sampah mengitar semula objek ini. Contohnya:

Apakah yang mengikat

Konsep mengikat telah disebutkan sebelum ini, tetapi apakah sebenarnya yang mengikat? Python dengan tegas menghendaki kaedah perlu mempunyai contoh sebelum ia boleh dipanggil Sekatan ini sebenarnya yang dipanggil konsep mengikat Python.

Seseorang boleh mencuba ini dan mendapati ia juga boleh dipanggil:

Walau bagaimanapun, terdapat masalah dengan ini, itu ialahObjek yang dibuat instantiated mengikut kelas tidak boleh memanggil fungsi di dalam sama sekali:

Malah, disebabkan mekanisme pengikatan Python, bb objek digunakan secara automatik sebagai Parameter pertama diluluskan, jadi TypeError berlaku.

Lihat contoh lain:

_ _dict_ _ atribut terdiri daripada kamus dan hanya terdapat kejadian dalam kamus Atribut objek tidak memaparkan atribut kelas dan atribut khas Kekunci mewakili nama atribut dan nilai mewakili nilai data yang sepadan atribut.

Kini objek instance dd mempunyai dua atribut baharu dan kedua-dua atribut ini hanya dimiliki oleh objek instance:

Mengapa ini berlaku? Malah, ini sepenuhnya disebabkan oleh parameter diri: apabila objek contoh dd memanggil kaedah setXY, parameter pertama yang dilaluinya ialah dd, jadi self.x = 4, self.y = 5 Bersamaan dengan dd. x = 4, dd.y = 5, jadi anda tidak boleh melihat x dan y dalam objek instance atau objek kelas, kerana dua atribut ini hanya milik objek instance dd .

Jika contoh kelas dipadamkan, bolehkah objek contoh dd masih memanggil kaedah printXY? Jawapannya ya:

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