Menaip itik dan menampal monyet dalam Python

Helo semua, saya Lao Wang.

Pembangun Python mungkin pernah mendengar istilah menaip itik dan tampalan monyet. Walaupun mereka tidak melakukannya, mereka mungkin telah menulis kod yang berkaitan, tetapi mereka hanya tidak memahami perkara teknikal di belakangnya .

Semasa saya menemu duga calon baru-baru ini, saya juga akan bertanya tentang dua konsep ini, dan jawapan ramai orang tidak begitu baik. Tetapi selepas saya menerangkannya kepada mereka, mereka biasanya tiba-tiba menyedari: "Oh, ini dia, saya telah menggunakannya sebelum ini."

Jadi, saya memutuskan untuk menulis artikel untuk membincangkan kedua-dua teknologi ini.

Taip itik

Memetik penjelasan daripada Wikipedia:

Taip itik ialah gaya menaip dinamik dalam pengaturcaraan. Dalam gaya ini, semantik berkesan objek ditentukan bukan dengan mewarisi daripada kelas tertentu atau melaksanakan antara muka tertentu, tetapi oleh "set kaedah dan sifat semasa."

Secara lebih popular:

Apabila anda melihat burung yang berjalan seperti itik, berenang seperti itik, dan kuak seperti itik, maka burung ini boleh dipanggil itik.

Dalam erti kata lain, dalam menaip itik, tumpuan adalah pada tingkah laku objek dan perkara yang boleh dilakukannya daripada memfokuskan pada jenis objek itu;

Mari kita lihat contoh untuk menunjukkannya dengan lebih jelas:

# 这是一个鸭子（Duck）类
class Duck:
def eat(self):
print("A duck is eating...")

def walk(self):
print("A duck is walking...")


# 这是一个狗（Dog）类
class Dog:
def eat(self):
print("A dog is eating...")

def walk(self):
print("A dog is walking...")


def animal(obj):
obj.eat()
obj.walk()


if __name__ == '__main__':
animal(Duck())
animal(Dog())

Keluaran program:

A duck is eating...
A duck is walking...
A dog is eating...
A dog is walking...

Python ialah bahasa dinamik dan tidak mempunyai pemeriksaan jenis yang ketat . Selagi Itik dan Anjing melaksanakan kaedah makan dan berjalan masing-masing, mereka boleh dipanggil terus.

Contoh lain ialah kaedah list.extend() Selain senarai, dict dan tuple juga boleh dipanggil, asalkan ia boleh diulang.

Selepas membaca contoh di atas, anda seharusnya mempunyai pemahaman yang lebih mendalam tentang "kelakuan objek" dan "jenis objek".

Mengembangkan sedikit lagi, menaip itik sebenarnya agak serupa dengan antara muka, kecuali tiada antara muka yang ditakrifkan secara eksplisit.

Sebagai contoh, jika anda menggunakan bahasa Go untuk melaksanakan penaipan itik, kodnya adalah seperti berikut:

package main

import "fmt"

// 定义接口，包含 Eat 方法
type Duck interface {
 Eat()
}

// 定义 Cat 结构体，并实现 Eat 方法
type Cat struct{}

func (c *Cat) Eat() {
 fmt.Println("cat eat")
}

// 定义 Dog 结构体，并实现 Eat 方法
type Dog struct{}

func (d *Dog) Eat() {
 fmt.Println("dog eat")
}

func main() {
 var c Duck = &Cat{}
 c.Eat()

 var d Duck = &Dog{}
 d.Eat()

 s := []Duck{
&Cat{},
&Dog{},
 }
 for _, n := range s {
n.Eat()
 }
}

Ini dicapai dengan mentakrifkan antara muka Itik secara eksplisit dan setiap struktur yang melaksanakan kaedah dalam antara muka.

Monyet patch

Monyet patch mempunyai reputasi buruk kerana ia mengubah suai modul, kelas atau fungsi secara dinamik semasa masa jalan, biasanya untuk menambah fungsi atau membetulkan kecacatan.

Tompok monyet berfungsi dalam ingatan dan tidak mengubah suai kod sumber, jadi ia hanya berkesan untuk contoh program yang sedang dijalankan.

Tetapi jika disalahgunakan, ia akan menyukarkan sistem untuk difahami dan diselenggara.

Terdapat dua masalah utama:

• Patch break enkapsulasi dan biasanya digandingkan rapat dengan sasaran dan oleh itu terdedah
• Dua perpustakaan yang ditampal mungkin berinteraksi antara satu sama lain Tie turun, kerana pustaka kedua mungkin membuat asal tampung pustaka pertama

Oleh itu, ia dianggap sebagai penyelesaian sementara dan bukan cara yang disyorkan untuk menyepadukan kod.

Seperti biasa, mari kita berikan contoh untuk menggambarkan:

# 定义一个Dog类
class Dog:
def eat(self):
print("A dog is eating ...")


# 在类的外部给 Dog 类添加猴子补丁
def walk(self):
print("A dog is walking ...")


Dog.walk = walk

# 调用方式与类的内部定义的属性和方法一样
dog = Dog()
dog.eat()
dog.walk()

Output program:

A dog is eating ...
A dog is walking ...

Ini bersamaan dengan menambah kelas Anjing di luar kaedah berjalan kelas , dan kaedah panggilan adalah sama dengan sifat dan kaedah yang ditakrifkan secara dalaman bagi kelas.

Berikan satu lagi contoh praktikal, seperti perpustakaan standard json kami yang biasa digunakan Jika anda ingin menggantikannya dengan ujson dengan prestasi yang lebih tinggi, anda pasti perlu mengimport setiap fail:

import json

Tukar kepada:

import ujson as json

Jika anda menukarnya dengan cara ini, kosnya agak tinggi. Pada masa ini, anda boleh mempertimbangkan untuk menggunakan tampalan monyet Anda hanya perlu menambah:

import json
import ujson


def monkey_patch_json():
json.__name__ = 'ujson'
json.dumps = ujson.dumps
json.loads = ujson.loads


monkey_patch_json()

pada entri program Dengan cara ini, apabila anda memanggil kaedah pembuangan dan beban pada masa hadapan, ia akan menjadi pakej ujson yang dipanggil, yang masih sangat mudah.

Tetapi tampalan monyet adalah pedang bermata dua Masalahnya juga disebutkan di atas dengan berhati-hati bergantung pada keperluan.

Atas ialah kandungan terperinci Menaip itik dan menampal monyet dalam Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!