Analyse du rendement et générateur en python

Nous importons d'abord à partir d'un petit programme, définissons chacun une liste et y trouvons les nombres premiers. Nous écrirons comme ceci

import math
def is_Prims(number):

    if number == 2:
        return True
    //除2以外的所有偶数都不是素数
    elif number % 2 == 0:
        return False
    //如果一个数能被除1和本身之外的数整除，则为合数。其实我们的判定范围到根号n就可以
    for cur in range(2,int(math.sqrt(number))+1,2):
        if number % cur == 0:
            return False
        else:
            return True

def get_Prims(input_list):

    result_list = list()
    for element in input_list:
        if is_Prims(element):
            result_list.append(element)
    return result_list

aa = get_Prims([1,2,3,4,5,6,7,8,9])
print (aa)

Mais si nous voulons donner un nombre, puis lister. les nombres plus petits que ce nombre Qu'en est-il de tous les nombres premiers qui sont grands ? Nous pourrions écrire comme ceci :

def get_Prims(number):    
if is_Prims(number):        
return number

Mais une fois que la fonction return cède le contrôle à l'appelant et se termine complètement, toutes les variables locales et le travail de la fonction sont ignorés, et l'appel suivant recommencera à zéro. On peut donc utiliser la méthode d'écriture suivante :

def get_Prims(number):
    while(True):
        if is_Prims(number):
            yield number
        number += 1

def get_numbers():
    total = list()
    for next_prim in get_Prims(2):
        if next_prim < 100:
            total.append(next_prim)
        else:
            print(total)
            return

get_numbers()

Expliquons la fonction génératrice. Le code def d'une fonction contient du rendement, et la fonction devient automatiquement une fonction génératrice (même si elle contient toujours du retour). , générateur La fonction crée un générateur (une forme spéciale d'itérateur, cet itérateur a une méthode __next__() intégrée). Lorsqu'une valeur est nécessaire, elle est générée via le rendement au lieu du retour direct. Par conséquent, contrairement aux fonctions ordinaires, à. cette fois, le contrôle n'est pas remis.

La boucle for appellera implicitement la fonction next(). La fonction next() est chargée d'appeler la méthode __next__() dans le générateur. À ce stade, le générateur est responsable de renvoyer une valeur à n'importe quel. méthode qui appelle next(). Use Yield renvoie cette valeur, ce qui équivaut à l'instruction return.

Pour plus d'articles liés au rendement de Python et à l'analyse du générateur, veuillez faire attention au site Web PHP chinois !