python - Overhead su looping su una classe iterable

Question

Stavo armeggiando con i generatori Python e la classe iterabile, solo per divertimento. Fondamentalmente volevo testare qualcosa di cui non sono mai stato tanto sicuro: le classi in Pythons hanno un overhead significativo ed è meglio fare affidamento sui metodi che implementano yield invece di classi che implementano un protocollo iteratore, se è possibile.

non riuscivo a trovare una spiegazione soddisfacente su questo argomento in Google, così ho deciso di provare loro fuori da solo con questi due semplici script: func_iter.py e class_iter.py

Ecco func_iter.py:

#!/usr/bin/env python 

import time 

x = 0 
def create_generator(num): 
    mylist = range(num) 
    for i in mylist: 
     yield i 

t = time.time() 
gen = create_generator(100000) 

for i in gen: 
    x = x + i 

print "%.3f" % (time.time() - t) 

Ed ecco class_iter.py:

#!/usr/bin/env python 

import time 

x = 0 

class Generator(object): 

    def __init__(self, num): 
     self.start = 0 
     self.end = num 

    def __iter__(self): 
     return self 

    def next(self): 
     if self.start == self.end: 
      raise StopIteration 
     else: 
      self.start = self.start + 1 
      return self.start 

t = time.time() 
gen = Generator(100000) 

for i in gen: 
    x = x + i 

print "%.3f" % (time.time() - t) 

allora ho fatto funzionare ciascuno di essi 10 volte utilizzando Thi s in bash (per class_iter.py, per esempio):

for i in {1..10}; do ./class_iter.py; done 

E qui sono i tempi medi di funzionamento per ciascuna di esse:

class_iter.py: 0.0864 
func_iter.py: 0.0307 

Ora, le mie domande sono:

1. Are i miei metodi sono corretti? Il mio confronto è giusto?
2. Se sì, perché la grande differenza? Perché lo class_iter.py ha impiegato quasi tre volte il tempo di esecuzione di func_iter.py?
3. In caso contrario, come posso migliorare i miei metodi o ottenere un confronto migliore?

EDIT: Come suggerito Dacav, ho anche provato a fare funzionare func_iter.py utilizzando xrange invece di range. Ciò riduce il tempo di esecuzione medio a 0,0263 secondi.

Answer 1

La versione di classe impiega molto tempo ad accedere alle proprie variabili. Ogni ciclo di costi self.whatever.Se si definisce la vostra __iter__ come generatore e ridurre al minimo l'uso di variabili di istanza, la differenza tra le versioni di classe e la funzione sarà trascurabile:

setup = """ 
def create_generator(num): 
    mylist = range(num) 
    for i in mylist: 
     yield i 

class Generator(object): 

    def __init__(self, num): 
     self.start = 0 
     self.end = num 

    def __iter__(self): 
     return self 

    def next(self): 
     if self.start == self.end: 
      raise StopIteration 
     else: 
      self.start = self.start + 1 
      return self.start 

class Generator2(object): 

    def __init__(self, num): 
     self.mylist = range(num) 

    def __iter__(self): 
     for i in self.mylist: 
      yield i 
""" 

import timeit 

print timeit.timeit('for p in create_generator(1000):p', setup, number=1000) 
print timeit.timeit('for p in Generator(1000):p', setup, number=1000) 
print timeit.timeit('for p in Generator2(1000):p', setup, number=1000) 

Risultati:

0.158941984177 
0.696810007095 
0.160784959793 

così la seconda classe del generatore è quasi veloce come la versione della funzione.

Si prega di notare che Generator e Generator2 nell'esempio non sono del tutto equivalente, ci sono casi in cui non si può semplicemente sostituire un iteratore "semplice" con un generatore (ad esempio marshalling).

Answer 2

Se si utilizza Python ci sono buone probabilità che non si miri alle prestazioni del software, ma si preoccupa di più di essere rapido e agile nello sviluppo.

Detto questo, penso che il metodo di confronto sia abbastanza equo purché il codice sia abbastanza intelligente da evitare pregiudizi per una soluzione.

Ad esempio, un possibile miglioramento per la versione basata su yield potrebbe rimuovere la funzione range utilizzando la funzione xrange. La differenza (in python 2.x) è che range crea un elenco di valori (quindi deve allocare spazio nella memoria per esso) mentre xrange crea un oggetto iterabile che varia sui valori specificati.

Answer 3

Sembra che tu sia completamente corretto e il tuo paragone è giusto. Quando si confronta solo l'overhead, la classe che supporta il protocollo iteratore sarà più lenta di una funzione di generatore.

Tuttavia, nel mondo reale, se il codice è complicato abbastanza per giustificare una classe, il tempo di esecuzione dell'algoritmo farà impallidire l'overhead, e quindi sarà del tutto irrilevante per il tempo di esecuzione del programma.

Qui ti preoccupi delle micro-ottimizzazioni. Non dovresti. Concentrati sulla scrittura di un codice buono e leggibile e sull'algoritmo corretto per il lavoro. La quantità di tempo speso per le ricerche di attributi e le chiamate di metodo nella versione di classe non sarà il collo di bottiglia.