Bagaimana untuk melaksanakan operasi tertunda dalam python

Python melaksanakan operasi tertunda

Jika anda ingin melaksanakan operasi tertunda dalam python, anda perlu menggunakan masa, dan kemudian menggunakan kaedah tidur masa

Sebagai contoh, saya ingin menulis operasi yang mencetak dengan kelewatan selama 1 saat

import time
for i in range(0, 10):
    time.sleep(1)
    print(i)

Masalah pemuatan malas Python

Pemuatan malas banyak digunakan dalam Python Idea utama adalah untuk menangguhkan instantiasi kelas yang akan diperkenalkan dan menjimatkan sedikit masa dan ruang yang diperlukan untuk permulaan.

Idea ini juga digunakan secara meluas dalam Django, seperti QuerySet ORM, dan request.user dalam middleware pengesahan, dll. Ini semua menggunakan idea memuatkan malas.

Artikel ini menganalisis idea malas memuatkan melalui contoh.

Idea asas untuk melaksanakan pemuatan malas adalah untuk mencipta kelas, dan kami lulus kelas yang kami perlukan untuk membuat seketika, kelas itu akan menjadi kelas pemuatan malas , Walaupun saya membuat instantiated kelas malas ini, kelas yang kami ingin rujuk tidak instantiated.

Seperti berikut:

class User(object):
    def __init__(self):
        self.name = 'haibo'
        self.age = 23
def test():
    return User()
#初始化该延迟加载类
user = CommonLazyObject(lambda :test())
#此时我们要引用的类才执行
user.age = 28

Di atas saya mentakrifkan kelas Pengguna, iaitu kelas yang ingin kami rujuk dalam program, dan CommonLazyObject ialah kelas memuatkan malas yang kami takrifkan (lebih lanjut mengenai ini kemudian ). Dengan malas memuatkan kelas, kami tidak perlu memulakannya terlebih dahulu. Ia akan dibuat instantiated hanya apabila kami mahu melaksanakan operasi seperti user.age di bawah.

Baiklah, mari kita lihat proses pelaksanaan khusus kelas pemuatan malas.

Fikir: Operasi instantiasi kami akhirnya akan bermuara kepada operator seperti __getattr__, __setattr__, dsb., jadi selagi kami mentakrifkan operator ini, kami boleh mencapai kelewatan ini, iaitu, hanya pelaksanaan Sahaja semasa operasi ini, bolehkah kita membuat instantiate kelas yang ingin kita nyatakan:

#建立一个空的对象
empty = object()
#一个装饰器，对__getattr__进行装饰，使得其可以进行类的实例化
def proxy_getattr(func):
    def wrapper(self,*args):
        if self._wrapper is empty:
            self._init_object()
        return func(self._wrapper,*args)
    return wrapper
class LazyObject(object):
    def __init__(self):
        self._wrapper = empty
    __getattr__ = proxy_getattr(getattr)
        #进行赋值操作的时候，看是实例化类，还是对类的实例进行赋值操作。因为下面我们要进行实例化类的操作。
    def __setattr__(self, key, value):
        if key == '_wrapper':
            self.__dict__['_wrapper'] = value
        else:
            if self._wrapper is empty:
                self._init_object()
            setattr(self._wrapper,key,value)
        #在子类中，你应该重新定义它，你通过它，来实现你想要通过何种方式实例化你的类。
    def _init_object(self):
        pass

Mula-mula lihat __setattr__ di atas Apabila kita melakukan operasi tugasan user.age=28, ini akan dipanggil operator, jika kelas kami ingin memperkenalkan tidak instantiated dalam kelas tertangguh, ia akan instantiated terlebih dahulu, iaitu, memanggil diri._init_object dan memberikannya kepada _wrapper. Jika instantiasi selesai, kaedah __setattr__ bagi contoh itu akan dilaksanakan serta-merta.

Begitu juga, __getattr_ juga sama. Jika saya ingin mencetak nama pengguna, saya mesti menyemak sama ada kelas yang dirujuk telah dibuat instantiat, kemudian panggil __getattr__ contoh itu. .

Baiklah, mari lihat subkelas yang melaksanakan instantiasi:

class CommonLazyObject(LazyObject):
    def __init__(self,func):
        self.__dict__['_wrapperfunc'] = func
        super(CommonLazyObject,self).__init__()
    def _init_object(self):
        self._wrapper = self._wrapperfunc()

Proses instantiasi subkelas ini sangat mudah, cuma panggil terus.

Atas ialah kandungan terperinci Bagaimana untuk melaksanakan operasi tertunda dalam python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!