Hebat! Cadangkan lapan penghias Python yang hebat!

Prakata

Salah satu perkara hebat tentang bahasa pengaturcaraan Python ialah ia mengemas semua ciri ke dalam pakej kecil yang sangat berguna.

Banyak ciri boleh menukar sepenuhnya fungsi kod Python, menjadikan bahasa lebih fleksibel. Jika digunakan dengan betul, beberapa ciri ini boleh mengurangkan masa yang diperlukan untuk menulis program dengan berkesan.

Contoh yang baik untuk mencapai matlamat ini ialah penghias Python.

Penghias

Penghias ialah fungsi yang boleh digunakan untuk menukar gelagat objek fungsi Python. Ia boleh digunakan pada kelas dan fungsi dan boleh melakukan banyak perkara yang sangat menarik!

Penghias boleh digunakan untuk memendekkan kod anda, mempercepatkannya dan mengubah sepenuhnya cara kod anda berkelakuan dalam Python.

Tidak perlu dikatakan, ini sememangnya berguna! Hari ini saya ingin menunjukkan beberapa penghias yang saya rasa patut dilihat.

Terdapat banyak penghias, tetapi saya memilih beberapa yang saya rasa mempunyai ciri paling hebat.

1. @lru_cache

Penghias pertama dalam senarai ini datang daripada modul functools.

Modul ini disertakan dalam perpustakaan standard dan sangat mudah digunakan. Ia juga mengandungi ciri yang lebih sejuk daripada penghias ini, tetapi penghias ini pasti kegemaran saya.

Penghias ini boleh digunakan untuk mempercepatkan larian fungsi berturut-turut menggunakan caching. Sudah tentu, ini harus digunakan dengan mengambil kira beberapa kaveat tentang caching, tetapi dalam kes penggunaan umum, kebanyakan masa penghias ini berbaloi untuk digunakan.

Sangat bagus untuk dapat mempercepatkan kod anda dengan penghias yang ringkas.

Contoh baik fungsi yang boleh mendapat manfaat daripada penghias sedemikian ialah fungsi rekursif, seperti fungsi yang mengira faktorial:

def factorial(n):
 return n * factorial(n-1) if n else 1

Rekursi mungkin dari segi masa pengiraan Sangat sukar, tetapi menambah penghias ini membantu mempercepatkan fungsi ini berjalan secara berterusan.

@lru_cache
def factorial(n):
 return n * factorial(n-1) if n else 1

Sekarang apabila kita menjalankan fungsi ini, beberapa pengiraan faktorial yang pertama akan disimpan ke cache.

Jadi pada kali seterusnya kita memanggil fungsi ini, kita hanya perlu mengira faktorial selepas faktorial yang kita gunakan sebelum ini.

Sudah tentu, bukan semua pengiraan faktorial akan disimpan, tetapi mudah untuk melihat sebab penghias ini merupakan aplikasi yang baik untuk mempercepatkan beberapa kod perlahan secara semula jadi.

2. @jit

JIT ialah singkatan kepada Just In Time. Biasanya setiap kali kita menjalankan beberapa kod dalam Python, perkara pertama yang berlaku ialah kompilasi.

Kompilasi ini memerlukan sedikit overhed kerana jenis tersebut diperuntukkan memori dan disimpan sebagai alias tidak diperuntukkan tetapi dinamakan. Dengan kompilasi tepat dalam masa, kami menyusun hanya pada masa pelaksanaan.

Dalam banyak cara, kita boleh menganggap ini sebagai sesuatu yang serupa dengan pengkomputeran selari, di mana jurubahasa Python mengendalikan dua perkara pada masa yang sama untuk menjimatkan masa.

Pengkompil Numba JIT terkenal kerana menyediakan konsep ini ke dalam Python. Sama seperti @lru_cache, penghias ini boleh dipanggil dengan mudah dan serta-merta meningkatkan prestasi kod anda. Pakej Numba menyediakan penghias jit yang memudahkan untuk menjalankan perisian yang lebih intensif tanpa perlu pergi ke C.

Kes berikut menggunakan penghias @jit untuk mempercepatkan pengiraan kaedah Monte Carlo.

from numba import jit
import random
@jit(nopython=True)
def monte_carlo_pi(nsamples):
 acc = 0
 for i in range(nsamples):
 x = random.random()
 y = random.random()
 if (x ** 2 + y ** 2) < 1.0:
 acc += 1
 return 4.0 * acc / nsamples

3. @do_twice

Penghias do_twice melakukan banyak perkara seperti namanya. Penghias ini boleh digunakan untuk menjalankan fungsi dua kali dengan satu panggilan. Ini sememangnya mempunyai beberapa kegunaan, saya dapati ia amat berguna untuk penyahpepijatan.

Ia boleh digunakan untuk mengukur prestasi dua lelaran berbeza. Menggunakan Functools sebagai contoh, kita boleh menjalankan fungsi dua kali untuk menyemak penambahbaikan. Fungsi ini disediakan oleh modul penghias dalam Python, yang terletak di perpustakaan standard.

from decorators import do_twice
@do_twice
def timerfunc():
%timeit factorial(15)

4. @count_calls

Penghias count_calls boleh digunakan untuk memberikan maklumat tentang berapa kali fungsi digunakan dalam perisian.

Seperti do_twice, ini pastinya berguna apabila menyahpepijat.

Apabila ditambahkan pada fungsi tertentu, kami akan menerima output yang memberitahu kami berapa kali fungsi itu telah dijalankan setiap kali ia dijalankan. Penghias ini juga terdapat dalam modul penghias perpustakaan standard.

from decorators import count_calls
@count_calls
def function_example():
print("Hello World!")
function_example()
function_example()
function_example()

5. @dataclass

Untuk menjimatkan masa kelas menulis, salah satu penghias terbaik yang saya gunakan ialah penghias @dataclass.

Penghias ini boleh digunakan untuk menulis kaedah standard biasa dalam kelas dengan cepat yang biasanya akan ditemui dalam kelas yang kami tulis.

Penghias ini datang daripada modul kelas data. Modul ini juga terdapat dalam perpustakaan standard, jadi tiada PIP diperlukan untuk mencuba contoh ini!

from dataclasses import dataclass
@dataclass
class Food:
name: str
unit_price: float
stock: int = 0
 def stock_value(self) -> float:
 return(self.stock * self.unit_price)

Kod ini secara automatik akan mencipta fungsi permulaan init() dengan parameter kedudukan yang diperlukan untuk mengisi data dalam kelas.

Ia juga akan diberikan secara automatik kepada diri sendiri, jadi tidak perlu menulis fungsi yang panjang untuk meletakkan beberapa parameter data ke dalam kelas.

6. @singleton

Untuk memahami tujuan penghias tunggal, kita perlu memahami apa itu singleton. Dari satu segi, singleton ialah versi jenis pembolehubah global.

这意味着类型被定义为只存在一次。尽管这些在 C++ 等语言中很常见，但在 Python 中却很少见到。使用单例，我们可以创建一个只使用一次的类并改变类，而不是通过初始化来构造新的类型。

通常，单例装饰器是由用户自己编写的，实际上并不是导入的。

这是因为单例仍然是对我们单例装饰器中提供的模板的引用。我们可以命名一个单例函数并编写一个包装器，以便在我们的类上使用这个装饰器：

def singleton(cls):
instances = {}
def wrapper(*args, **kwargs):
if cls not in instances:
instances[cls] = cls(*args, **kwargs)
return instances[cls]
return wrapper
@singleton
class cls:
def func(self):

另一种方法是使用元类!

7. @use_unit

在科学计算中经常派上用场的一种装饰器是 @use_unit 装饰器。

此装饰器可用于更改返回结果的表示单位。这对于那些不想在数据中添加度量单位但仍希望人们知道这些单位是什么的人很有用。

这个装饰器也不是在任何模块中真正可用，但它是非常常见的，对科学应用程序非常有用。

def use_unit(unit):
"""Have a function return a Quantity with given unit"""
use_unit.ureg = pint.UnitRegistry()
def decorator_use_unit(func):
@functools.wraps(func)
def wrapper_use_unit(*args, **kwargs):
value = func(*args, *_kwargs)
return value _ use_unit.ureg(unit)
return wrapper_use_unit
return decorator_use_unit
@use_unit("meters per second")
def average_speed(distance, duration):
return distance / duration

8. @singledispatch

Functools 凭借非常有用的@singledispatch 装饰器再次在此列表中脱颖而出。

单调度是一种编程技术，在许多编程语言中都很常见，因为它是一种非常棒的编程方式。虽然我更喜欢多调度，但我认为单调度可以在很多方面扮演相同的角色。

这个装饰器使得在 Python 中使用多类型数据变得更加容易, 尤其当我们希望通过同一方法传递多种类型数据时，情况更是如此。

@singledispatch
def fun(arg, verbose=False):
if verbose:
print("Let me just say,", end=" ")
print(arg)
@fun.register
def _(arg: int, verbose=False):
if verbose:
print("Strength in numbers, eh?", end=" ")
print(arg)
@fun.register
def _(arg: list, verbose=False):
if verbose:
print("Enumerate this:")
for i, elem in enumerate(arg):
print(i, elem)

Atas ialah kandungan terperinci Hebat! Cadangkan lapan penghias Python yang hebat!. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!