pitón uso detallado en el rendimiento - el más simple, más clara explicación (reimpresión)

En primer lugar, si usted no tiene una comprensión preliminar de puntos de rendimiento, entonces usted debe primero dió considerado como "retorno", esto es intuitivo, que es ante todo un retorno, el retorno normal es lo que se entiende es devolver un valor en el programa de y luego volver al programa ya no se ejecuta abajo de la. Después visto como un retorno a continuación, se ve como parte de un generador (generador) (con función de fluencia es el verdadero iterador), bueno, si usted no entiende estos, entonces visto como el primer retorno de rendimiento, luego mirar directamente siguiente programa, usted entenderá el significado completo del rendimiento:

 def foo():
        print("starting...")
        while True:
            res = yield 4
            print("res:",res)
    g = foo()
    print(next(g))
    print("*"*20)
    print(next(g))

Es así de simple pocas líneas de código que permiten saber cuál es el rendimiento de la producción, este código:

    starting...
    4
    ********************
    res: None
    4

Dirijo la secuencia de ejecución de códigos interpretado, el equivalente a recorrer el código:

1. Después de que el programa iniciado, debido a que la función foo tiene la palabra clave de rendimiento, por lo que la función foo y no realmente realizar, pero para conseguir un generador g (equivalente a un objeto)

2. hasta que llame al método siguiente, la función foo comenzado oficialmente, lleve a cabo la función foo método de impresión, y luego entrar en el bucle while

3. Después de que el programa encuentra la palabra clave de rendimiento, entonces el rendimiento de pensar en el retorno, de regreso a 4, el programa se detiene y no realiza la operación asignada a la res, en este momento se ejecuta siguiente sentencia (g), la salida de las dos primeras líneas (el primero es un resultado de la impresión anterior, mientras que el segundo es para devolver un resultado) es el resultado de realizar la impresión (al lado (g)), y

4. La ejecución del programa de impresión ( "*" * 20), la salida 20 *

5. comenzaron a realizar la siguiente impresión (al lado (g)), y encima de que esta vez casi, pero la diferencia está, esta vez desde el siguiente lugar de simplemente dejar que el programa comenzó, es decir para ejecutar la res de asignación , esta vez a prestar atención a la correcta esta vez la asignación es ningún valor (como eso es el retorno a cabo, a la izquierda y no le dio la tarea de pasar parámetros), por lo que esta asignación res de tiempo es Ninguno, por lo que entonces la siguiente salida es res: Ninguno,

6. El programa continuará en mientras allí, se reunió de nuevo el rendimiento, este tiempo para devolver el mismo 4, a continuación, los topes de programa, el retorno es de 4 sobre la función de salida 4 de impresión.

 

Aquí es posible entender la relación entre el rendimiento y retorno y distinguido, con un rendimiento es un generador de funciones, en lugar de una función, y que ha generado es una función de la próxima función, junto al equivalente de generación de "próxima", que número, el lugar esta vez el próximo inicio es seguido por la siguiente parada en un lugar de la ejecución, así que llame la próxima vez, el generador no se iniciará la ejecución de la función foo de la etapa anterior y luego lugar justo parada para empezar, entonces el evento al rendimiento, devolver el número a ser generado, este paso ha terminado.

************************************************** ************************************************** ************************************

   

def foo():
        print("starting...")
        while True:
            res = yield 4
            print("res:",res)
    g = foo()
    print(next(g))
    print("*"*20)
    print(g.send(7))

Un ejemplo de este aspecto en el generador de función de envío, la última línea de este ejemplo tomó sustituyó el ejemplo anterior, la salida:

    starting...
    4
    ********************
    res: 7
    4

En términos generales primero sobre el concepto de función de envío: En este punto se debe tener en cuenta que la palabra púrpura por encima y por qué el valor es superior a la res Ninguno, esto se convierte en un 7, al final por qué, es porque, enviar un envío de una argumentos a la res, como se mencionó anteriormente, el tiempo de retorno y no res asignar 4, cuando la siguiente ejecución tuvo que continuar con el operador de asignación, la asignación tenido en ninguno, pero si enviarlo, comenzó cuando, a continuación, la primera vez (después de la vuelta 4) ejecutar, 7 primero asignado a la res, y luego realizar la siguiente acción, se reunió próxima vez que el rendimiento, el retorno después del final de los resultados.

 

El g.send la ejecución del programa (7), el programa seguirá funcionando desde la línea de abajo de la palabra clave de rendimiento, enviar el valor 7 será asignado a las variables res

6. Dado que el método comprende enviar método next (), la ejecución del programa continuará a correr por el método de impresión, y luego volver a entrar en el bucle while

7. Después de los encuentros ejecución del programa dió palabra clave otra vez, dará lugar a una posterior valor de retorno, hacer una pausa en el programa de nuevo hasta la siguiente llamada al método o envíe método de nuevo.

 

 

 

Este es el final algo, por ejemplo, por qué el uso de este generador, ya que si la lista, se ocupan más espacio, por ejemplo, tomar 0,1,2,3,4,5,6 ...... ...... 1000

Es posible que como este:

   

 for n in range(1000):
        a=n

Este rango de tiempo (1000) para generar una lista predeterminada 1000 contiene un número, por lo que se tiene en cuenta la memoria.

Esta vez sólo se puede utilizar una combinación de rendimiento para ser realizada generador se puede lograr mediante xrange (1000) este generador

producir combinación:

   

def foo(num):
        print("starting...")
        while num<10:
            num=num+1
            yield num
    for n in foo(0):
        print(n)

salida:

    a partir ...
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
 

xrange(1000):

    for n in xrange(1000):
        a=n

 Hay que señalar que no tiene python3 cuando xrange (), y en python3 en, range () es xrange (), se puede ver en el rango python3 tipo (), que ya es un <clase 'rango'> a, en lugar de una lista, después de todo, esto es para ser optimizado.

                                                                                                 Gracias

Si usted siente que tiene para ayudar a su apreciación es el mayor apoyo para mí!
----------------
responsabilidad: Este artículo es RDCC blogger "artículo original von abundante', siga el CC 4.0 BY-SA acuerdo de derecho de autor, que se reproduce, por favor incluya la fuente original y este enlace comunicado.
fuente original: https: //blog.csdn.net/mieleizhi0522/article/details/82142856