diveintopython3-it / iteratori.html

<!DOCTYPE html>
<meta charset=utf-8>
<title>Classi &amp; iteratori - Immersione in Python 3</title>
<!--[if IE]><script src=j/html5.js></script><![endif]-->
<link rel=stylesheet href=dip3.css>
<style>
body{counter-reset:h1 7}
</style>
<link rel=stylesheet media='only screen and (max-device-width: 480px)' href=mobile.css>
<link rel=stylesheet media=print href=print.css>
<meta name=viewport content='initial-scale=1.0'>
<form action=http://www.google.com/cse><div><input type=hidden name=cx value=014021643941856155761:l5eihuescdw><input type=hidden name=ie value=UTF-8>&nbsp;<input type=search name=q size=25 placeholder="powered by Google&trade;">&nbsp;<input type=submit name=sa value=Search></div></form>
<p>Voi siete qui: <a href=index.html>Inizio</a> <span class=u>&#8227;</span> <a href=indice.html#iteratori>Immersione in Python 3</a> <span class=u>&#8227;</span>
<p id=level>Livello di difficoltà: <span class=u title=intermedio>&#x2666;&#x2666;&#x2666;&#x2662;&#x2662;</span>
<h1>Classi <i class=baa>&amp;</i> iteratori</h1>
<blockquote class=q>
<p><span class=u>&#x275D;</span> L&#8217;Oriente è l&#8217;Oriente e l&#8217;Occidente è l&#8217;Occidente, e mai i due si incontreranno. <span class=u>&#x275E;</span><br>&mdash; <a href=http://en.wikiquote.org/wiki/Rudyard_Kipling>Rudyard Kipling</a>
</blockquote>
<p id=toc>&nbsp;
<h2 id=divingin>Immersione!</h2>
<p class=f>In verità, gli iteratori sono l&#8217;&#8220;ingrediente segreto&#8221; di Python 3: si trovano ovunque, nascosti dietro le quinte di ogni funzionalità, sempre appena fuori vista. Le <a href=descrizioni.html>descrizioni</a> sono solo un caso speciale di <i>iteratori</i>. Anche i generatori sono solo un caso speciale di <i>iteratori</i>: una funzione che produce valori tramite <code>yield</code> è un modo gradevole e compatto di costruire un iteratore senza costruire un iteratore. Lasciate che vi mostri cosa voglio dire.

<p>Ricordate il <a href=generatori.html#a-fibonacci-generator>generatore di Fibonacci</a>? Qui di seguito lo trovate reimplementato da zero sotto forma di iteratore:

<p class=d>[<a href=esempi/fibonacci2.py>scarica <code>fibonacci2.py</code></a>]
<pre class=pp><code>class Fib:
    '''iteratore che produce i numeri della sequenza di Fibonacci'''
    def __init__(self, max):
        self.max = max

    def __iter__(self):
        self.a = 0
        self.b = 1
        return self

    def __next__(self):
        fib = self.a
        if fib > self.max:
            raise StopIteration
        self.a, self.b = self.b, self.a + self.b
        return fib</code></pre>

<p>Analizziamolo una riga alla volta.

<pre class='nd pp'><code>class Fib:</code></pre>

<p><code>class</code>? Classe? Che cos&#8217;è una classe?

<p class=a>&#x2042;

<h2 id=defining-classes>Definire le classi</h2>

<p>Python è completamente orientato agli oggetti: potete definire le vostre classi, ereditare dalle vostre classi o dalle classi built-in e istanziare le classi che avete definito.

<p>Definire una classe in Python è semplice. Come per le funzioni, non c&#8217;è una definizione di interfaccia separata. Vi basta definire la classe e cominciare a programmarla. Una classe Python comincia con la parola riservata <code>class</code>, seguita dal nome della classe. Tecnicamente, questo è tutto quello che è richiesto, in quanto una classe non ha bisogno di ereditare da nessun&#8217;altra classe.

<pre class=pp><code><a>class PapayaWhip:  <span class=u>&#x2460;</span></a>
<a>    pass           <span class=u>&#x2461;</span></a></code></pre>
<ol>
<li>Il nome di questa classe è <code>PapayaWhip</code>, e non eredita da nessun&#8217;altra classe. I nomi delle classi solitamente cominciano con una lettera maiuscola, <code>OgniParolaInQuestoModo</code>, ma questa è solo una convenzione, non un obbligo.
<li>Lo avrete probabilmente già indovinato, ma ogni cosa in una classe è indentata, esattamente come il codice all&#8217;interno di una funzione, di un&#8217;istruzione <code>if</code>, di un ciclo <code>for</code>, o di ogni altro blocco di codice. La prima riga non indentata non fa più parte della definizione di classe.
</ol>

<p>Questa classe <code>PapayaWhip</code> non definisce alcun metodo o attributo, ma sintatticamente la definizione deve contenere qualcosa, ed ecco il motivo per la presenza di quella istruzione <code>pass</code>. Questa è una parola riservata di Python che significa solo &#8220;circolate, non c&#8217;è nulla da vedere&#8221;. &Egrave; un&#8217;istruzione che non fa nulla, e un buon segnaposto da sfruttare quando state definendo lo scheletro di funzioni o classi.

<blockquote class='note compare java'>
<p><span class=u>&#x261E;</span>L&#8217;istruzione <code>pass</code> in Python è come un insieme vuoto di parentesi graffe (<code>{}</code>) in Java o C.
</blockquote>

<p>Molte classi ereditano da altre classi, ma questa non lo fa. Molte classi definiscono metodi, ma questa non lo fa. Non c&#8217;è nulla che una classe Python debba assolutamente avere, a parte un nome. In particolare, i programmatori <abbr>C++</abbr> potrebbero trovare strano che le classi Python non abbiano costruttori e distruttori espliciti. Sebbene non sia obbligatorio, le classi Python <em>possono</em> avere qualcosa di simile a un costruttore: il metodo <code>__init__()</code>.

<h3 id=init-method>Il metodo <code>__init__()</code></h3>

<p>Questo esempio mostra l&#8217;inizializzazione della classe <code>Fib</code> usando il metodo <code>__init__()</code>.

<pre class=pp><code>class Fib:
<a>    '''iteratore che produce i numeri della sequenza di Fibonacci'''  <span class=u>&#x2460;</span></a>

<a>    def __init__(self, max):                                          <span class=u>&#x2461;</span></a></code></pre>
<ol>
<li>Anche le classi possono (e dovrebbero) avere una <code>docstring</code>, esattamente come i moduli e le funzioni.
<li>Il metodo <code>__init__()</code> viene chiamato immediatamente dopo la creazione di un&#8217;istanza della classe. Sarebbe allettante&nbsp;&mdash;&nbsp;ma tecnicamente scorretto&nbsp;&mdash;&nbsp;dire che questo metodo è il &#8220;costruttore&#8221; della classe. &Egrave; allettante perché il metodo somiglia a un costruttore <abbr>C++</abbr> (per convenzione, il metodo <code>__init__()</code> è il primo metodo definito nella classe), agisce come un costruttore (è il primo frammento di codice eseguito in un&#8217;istanza appena creata della classe) e ha persino un nome che suona come quello di un costruttore. Ma è scorretto perché l&#8217;oggetto è già stato costruito nel momento in cui il metodo <code>__init__()</code> viene invocato, e un riferimento valido alla nuova istanza della classe è già disponibile.
</ol>

<p>Il primo argomento di ogni metodo in una classe, compreso il metodo <code>__init__()</code>, è sempre un riferimento all&#8217;istanza corrente della classe. Per convenzione, questo argomento viene chiamato <var>self</var>. Questo argomento occupa il ruolo della parola riservata <code>this</code> in <abbr>C++</abbr> o Java, ma <var>self</var> non è una parola riservata in Python, bensì semplicemente una convenzione nominale. Nondimeno, per favore non chiamatelo in modi diversi da <var>self</var> perché questa è una convenzione molto forte.

<p>Nel metodo <code>__init__()</code> <var>self</var> si riferisce all&#8217;oggetto appena creato; in altri metodi della classe si riferisce all&#8217;istanza il cui metodo è stato invocato. Sebbene abbiate bisogno di specificare esplicitamente <var>self</var> quando definite il metodo, <em>non</em> dovete specificarlo quando chiamate il metodo; Python lo aggiungerà per voi automaticamente.

<p class=a>&#x2042;

<h2 id=instantiating-classes>Istanziare le classi</h2>

<p>Istanziare le classi in Python è semplice. Per istanziare una classe vi basta invocare la classe come se fosse una funzione, passando gli argomenti richiesti dal metodo <code>__init__()</code>. Il valore di ritorno sarà l&#8217;oggetto appena creato.
<pre class=screen>
<samp class=p>>>> </samp><kbd class=pp>import fibonacci2</kbd>
<a><samp class=p>>>> </samp><kbd class=pp>fib = fibonacci2.Fib(100)</kbd>  <span class=u>&#x2460;</span></a>
<a><samp class=p>>>> </samp><kbd class=pp>fib</kbd>                        <span class=u>&#x2461;</span></a>
<samp>&lt;fibonacci2.Fib object at 0x00DB8810></samp>
<a><samp class=p>>>> </samp><kbd class=pp>fib.__class__</kbd>              <span class=u>&#x2462;</span></a>
<samp class=pp>&lt;class 'fibonacci2.Fib'></samp>
<a><samp class=p>>>> </samp><kbd class=pp>fib.__doc__</kbd>                <span class=u>&#x2463;</span></a>
<samp class=pp>'iteratore che produce i numeri della sequenza di Fibonacci'</samp></pre>
<ol>
<li>State creando un&#8217;istanza della classe <code>Fib</code> (definita nel modulo <code>fibonacci2</code>) e assegnando l&#8217;istanza appena creata alla variabile <var>fib</var>. State passando un parametro, <code>100</code>, che finirà per diventare l&#8217;argomento <var>max</var> del metodo <code>__init__()</code> in <code>Fib</code>.
<li><var>fib</var> è ora un&#8217;istanza della classe <code>Fib</code>.
<li>Ogni istanza di una classe ha un attributo built-in chiamato <code>__class__</code> che è la classe dell&#8217;oggetto. I programmatori Java potrebbero avere familiarità con la classe <code>Class</code>, che contiene metodi come <code>getName()</code> e <code>getSuperclass()</code> per ottenere metainformazioni su un oggetto. In Python, questo tipo di metadati si può ottenere attraverso gli attributi, ma l&#8217;idea è la stessa.
<li>Potete accedere alla <code>docstring</code> dell&#8217;istanza esattamente come con una funzione o un modulo. Tutte le istanze di una classe condividono la stessa <code>docstring</code>.
</ol>

<blockquote class='note compare java'>
<p><span class=u>&#x261E;</span>In Python, vi basta invocare una classe come se fosse una funzione per creare una nuova istanza della classe. Non c&#8217;è nessun operatore <code>new</code> esplicito come in <abbr>C++</abbr> o in Java.
</blockquote>

<p class=a>&#x2042;

<h2 id=instance-variables>Variabili di istanza</h2>

<p>Sulla riga successiva troviamo:

<pre class=pp><code>class Fib:
    def __init__(self, max):
<a>        self.max = max        <span class=u>&#x2460;</span></a></code></pre>
<ol>
<li>Che cos&#8217;è <var>self.max</var>? &Egrave; una variabile di istanza. &Egrave; completamente separata da <var>max</var>, che è passato al metodo <code>__init__()</code> come un argomento. <var>self.max</var> è &#8220;globale&#8221; per l&#8217;istanza. Questo significa che potete accedervi da altri metodi.
</ol>

<pre class=pp><code>class Fib:
    def __init__(self, max):
<a>        self.max = max        <span class=u>&#x2460;</span></a>
    .
    .
    .
    def __next__(self):
        fib = self.a
<a>        if fib > self.max:    <span class=u>&#x2461;</span></a></code></pre>
<ol>
<li><var>self.max</var> è definito nel metodo <code>__init__()</code>&hellip;
<li>&hellip;e riferito nel metodo <code>__next__()</code>.
</ol>

<p>Le variabili di istanza sono specifiche per un&#8217;istanza di una classe. Per esempio, se create due istanze di <code>Fib</code> con differenti valori massimi, ognuna manterrà in memoria il proprio valore.

<pre class='nd screen'>
<samp class=p>>>> </samp><kbd class=pp>import fibonacci2</kbd>
<samp class=p>>>> </samp><kbd class=pp>fib1 = fibonacci2.Fib(100)</kbd>
<samp class=p>>>> </samp><kbd class=pp>fib2 = fibonacci2.Fib(200)</kbd>
<samp class=p>>>> </samp><kbd class=pp>fib1.max</kbd>
<samp class=pp>100</samp>
<samp class=p>>>> </samp><kbd class=pp>fib2.max</kbd>
<samp class=pp>200</samp></pre>

<p class=a>&#x2042;

<h2 id=a-fibonacci-iterator>Un iteratore di Fibonacci</h2>

<p><em>Ora</em> siete pronti per imparare come si costruisce un iteratore. Un iteratore è semplicemente una classe che definisce un metodo <code>__iter__()</code>.

<aside class=ots>
Tutti e tre i metodi di classe <code>__init__</code>, <code>__iter__</code> e <code>__next__</code> cominciano e finiscono con una coppia di caratteri di sottolineatura (<code>_</code>). Come mai? Non c&#8217;è nulla di magico in questo, ma di solito indica che questi metodi sono &#8220;<dfn>metodi speciali</dfn>&#8221;. L&#8217;unica cosa &#8220;speciale&#8221; dei metodi speciali è che non vengono invocati direttamente, ma Python li chiama quando usate qualche altra sintassi sulla classe o su un&#8217;istanza della classe. <a href=nomi-dei-metodi-speciali.html>Ulteriori informazioni sui metodi speciali</a>.
</aside>

<p class=d>[<a href=esempi/fibonacci2.py>scarica <code>fibonacci2.py</code></a>]
<pre class=pp><code><a>class Fib:                                        <span class=u>&#x2460;</span></a>
<a>    def __init__(self, max):                      <span class=u>&#x2461;</span></a>
        self.max = max

<a>    def __iter__(self):                           <span class=u>&#x2462;</span></a>
        self.a = 0
        self.b = 1
        return self

<a>    def __next__(self):                           <span class=u>&#x2463;</span></a>
        fib = self.a
        if fib > self.max:
<a>            raise StopIteration                   <span class=u>&#x2464;</span></a>
        self.a, self.b = self.b, self.a + self.b
<a>        return fib                                <span class=u>&#x2465;</span></a></code></pre>
<ol>
<li>Per costruire un iteratore partendo da zero, <code>Fib</code> deve essere una classe, non una funzione.
<li>&#8220;Invocare&#8221; <code>Fib(max)</code> vuol dire in realtà creare un&#8217;istanza di questa classe e chiamare il suo metodo <code>__init__()</code> con <var>max</var>. Il metodo <code>__init__()</code> salva il valore massimo come una variabile di istanza in modo che altri metodi possano usarlo più tardi.
<li>Il metodo <code>__iter__()</code> viene invocato ogni volta che qualcuno chiama <code>iter(fib)</code>. (Come vedrete fra un minuto, un ciclo <code>for</code> chiama questo metodo automaticamente, ma potete chiamarlo anche voi manualmente.) Dopo aver eseguito l&#8217;inizializzazione che prepara l&#8217;iterazione (in questo caso, impostando i valori di <code>self.a</code> e <code>self.b</code>, i nostri due contatori), il metodo <code>__iter__()</code> può restituire qualsiasi oggetto che implementi un metodo <code>__next__()</code>. In questo caso (e nella maggior parte dei casi) <code>__iter__()</code> restituisce semplicemente <var>self</var>, dato che questa classe implementa il proprio metodo <code>__next__()</code>.
<li>Il metodo <code>__next__()</code> viene invocato ogni volta che qualcuno chiama <code>next()</code> su un iteratore di un&#8217;istanza di una classe. Questo avrà più senso fra un minuto.
<li>Quando il metodo <code>__next__()</code> solleva un&#8217;eccezione di tipo <code>StopIteration</code>, questo segnala al chiamante che l&#8217;iterazione è esaurita. A differenza della maggior parte delle eccezioni questa non rappresenta un errore, ma una condizione normale che significa solamente che l&#8217;iteratore non ha più valori da generare. Se il chiamante è un ciclo <code>for</code>, noterà questa eccezione di tipo <code>StopIteration</code> e uscirà normalmente dal ciclo. (In altre parole, sopprimerà l&#8217;eccezione.) Questo piccolo tocco di magia è in realtà la chiave per usare gli iteratori nei cicli <code>for</code>.
<li>Per produrre in uscita il valore successivo, il metodo <code>__next__()</code> di un iteratore restituisce semplicemente il valore tramite l&#8217;istruzione <code>return</code>. Qui <code>yield</code> non viene usato; quello è zucchero sintattico che si applica solo quando state usando i generatori. Qui invece state creando il vostro iteratore da zero; quindi, usate <code>return</code>.
</ol>

<p>Non siete ancora completamente confusi? Eccellente. Vediamo come invocare questo iteratore:

<pre class='nd screen'>
<samp class=p>>>> </samp><kbd class=pp>from fibonacci2 import Fib</kbd>
<samp class=p>>>> </samp><kbd class=pp>for n in Fib(1000):</kbd>
<samp class=p>... </samp><kbd class=pp>    print(n, end=' ')</kbd>
<samp class=pp>0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987</samp></pre>

<p>Ehi, è esattamente lo stesso! Identico byte per byte al modo di invocare il <a href=generatori.html#a-fibonacci-generator>generatore di Fibonacci</a> (a parte una lettera maiuscola). Ma com&#8217;è possibile?

<p>C&#8217;è un pizzico di magia nel funzionamento dei cicli <code>for</code>. Ecco cosa succede.

<ul>
<li>Il ciclo <code>for</code> invoca <code>Fib(1000)</code>, come mostrato. Questo restituisce un&#8217;istanza della classe <code>Fib</code>. Chiamiamo questa istanza <var>fib_inst</var>.
<li>Segretamente, e piuttosto ingegnosamente, il ciclo <code>for</code> chiama <code>iter(fib_inst)</code>, che restituisce un oggetto iteratore. Chiamiamo questo oggetto <var>fib_iter</var>. In questo caso <var>fib_iter</var> == <var>fib_inst</var>, perché il metodo <code>__iter__()</code> restituisce <var>self</var> anche se il ciclo <code>for</code> non lo sa (o non se ne cura).
<li>Per &#8220;attraversare&#8221; l&#8217;iteratore, il ciclo <code>for</code> chiama <code>next(fib_iter)</code>, che chiama il metodo <code>__next__()</code> sull&#8217;oggetto <var>fib_iter</var>, che calcola il successivo numero di Fibonacci e restituisce un valore. Il ciclo <code>for</code> prende questo valore e lo assegna a <var>n</var>, poi esegue il corpo del ciclo <code>for</code> per quel valore di <var>n</var>.
<li>Come fa il ciclo <code>for</code> a sapere quando fermarsi? Sono contento che lo abbiate chiesto! Quando <code>next(fib_iter)</code> solleva un&#8217;eccezione di tipo <code>StopIteration</code>, il ciclo <code>for</code> sopprimerà l&#8217;eccezione e uscirà normalmente. (Ogni altra eccezione vi passerà attraverso e verrà sollevata come al solito.) E dov&#8217;è che avete visto un&#8217;eccezione di tipo <code>StopIteration</code>? Nel metodo <code>__next__()</code>, naturalmente!
</ul>

<p class=a>&#x2042;

<h2 id=a-plural-rule-iterator>Un iteratore di regole per i sostantivi plurali</h2>

<aside>iter(f) chiama f.__iter__<br>next(f) chiama f.__next__</aside>
<p>Ora è il momento del gran finale. Riscriviamo il <a href=generatori.html>generatore di regole per i sostantivi plurali</a> sotto forma di iteratore.

<p class=d>[<a href=esempi/plural6.py>scarica <code>plural6.py</code></a>]
<pre class=pp><code>class LazyRules:
    rules_filename = 'plural6-rules.txt'

    def __init__(self):
        self.pattern_file = open(self.rules_filename, encoding='utf-8')
        self.cache = []

    def __iter__(self):
        self.cache_index = 0
        return self

    def __next__(self):
        self.cache_index += 1
        if len(self.cache) >= self.cache_index:
            return self.cache[self.cache_index - 1]

        if self.pattern_file.closed:
            raise StopIteration

        line = self.pattern_file.readline()
        if not line:
            self.pattern_file.close()
            raise StopIteration

        pattern, search, replace = line.split(None, 3)
        funcs = build_match_and_apply_functions(
            pattern, search, replace)
        self.cache.append(funcs)
        return funcs

rules = LazyRules()</code></pre>

<p>Così questa classe implementa <code>__iter__()</code> e <code>__next__()</code> e perciò può essere usata come un iteratore. Dunque, ne create un&#8217;istanza e l&#8217;assegnate a <var>rules</var>. Questo accade solo una volta, al momento di importare il modulo.

<p>Analizziamo la classe un pezzo alla volta.

<pre class=pp><code>class LazyRules:
    rules_filename = 'plural6-rules.txt'

    def __init__(self):
<a>        self.pattern_file = open(self.rules_filename, encoding='utf-8')  <span class=u>&#x2460;</span></a>
<a>        self.cache = []                                                  <span class=u>&#x2461;</span></a></code></pre>
<ol>
<li>Quando istanziamo la classe <code>LazyRules</code>, apriamo il file dei pattern ma non lo leggiamo. (Lo faremo più tardi.)
<li>Dopo aver aperto il file dei pattern, inizializzate la cache che userete più tardi (nel metodo <code>__next__()</code>) durante la lettura dei pattern dal file.
</ol>

<p>Prima di continuare, diamo un&#8217;occhiata più da vicino a <var>rules_filename</var>. Non è definita all&#8217;interno del metodo <code>__iter__()</code>. In effetti, non è definita all&#8217;interno di <em>nessun</em> metodo. &Egrave; definita a livello della classe. &Egrave; una <i>variabile di classe</i>, e sebbene possiate accedervi esattamente come una variabile di istanza (<var>self.rules_filename</var>), è condivisa da tutte le istanze della classe <code>LazyRules</code>.

<pre class=screen>
<samp class=p>>>> </samp><kbd class=pp>import plural6</kbd>
<samp class=p>>>> </samp><kbd class=pp>r1 = plural6.LazyRules()</kbd>
<samp class=p>>>> </samp><kbd class=pp>r2 = plural6.LazyRules()</kbd>
<a><samp class=p>>>> </samp><kbd class=pp>r1.rules_filename</kbd>                               <span class=u>&#x2460;</span></a>
<samp class=pp>'plural6-rules.txt'</samp>
<samp class=p>>>> </samp><kbd class=pp>r2.rules_filename</kbd>
<samp class=pp>'plural6-rules.txt'</samp>
<a><samp class=p>>>> </samp><kbd class=pp>r2.rules_filename = 'r2-override.txt'</kbd>           <span class=u>&#x2461;</span></a>
<samp class=p>>>> </samp><kbd class=pp>r2.rules_filename</kbd>
<samp class=pp>'r2-override.txt'</samp>
<samp class=p>>>> </samp><kbd class=pp>r1.rules_filename</kbd>
<samp class=pp>'plural6-rules.txt'</samp>
<a><samp class=p>>>> </samp><kbd class=pp>r2.__class__.rules_filename</kbd>                     <span class=u>&#x2462;</span></a>
<samp class=pp>'plural6-rules.txt'</samp>
<a><samp class=p>>>> </samp><kbd class=pp>r2.__class__.rules_filename = 'papayawhip.txt'</kbd>  <span class=u>&#x2463;</span></a>
<samp class=p>>>> </samp><kbd class=pp>r1.rules_filename</kbd>
<samp class=pp>'papayawhip.txt'</samp>
<a><samp class=p>>>> </samp><kbd class=pp>r2.rules_filename</kbd>                               <span class=u>&#x2464;</span></a>
<samp class=pp>'r2-overridetxt'</samp></pre>
<ol>
<li>Ogni istanza della classe eredita l&#8217;attributo <var>rules_filename</var> con il valore definito dalla classe.
<li>Cambiare il valore dell&#8217;attributo in un&#8217;istanza non ha effetto sulle altre istanze&hellip;
<li>&hellip;né modifica l&#8217;attributo di classe. Potete accedere all&#8217;attributo di classe (al contrario dell&#8217;attributo di una singola istanza) usando lo speciale attributo <code>__class__</code> per accedere alla classe stessa.
<li>Se modificate l&#8217;attributo di classe, tutte le istanze che stanno ancora ereditando quel valore (come <var>r1</var> qui) verranno affette dal cambiamento.
<li>Le istanze che hanno sostituito quell&#8217;attributo (come <var>r2</var> qui) non verranno affette.
</ol>

<p>E ora torniamo al nostro spettacolo.

<pre class=pp><code><a>    def __iter__(self):       <span class=u>&#x2460;</span></a>
        self.cache_index = 0
<a>        return self           <span class=u>&#x2461;</span></a>
</code></pre>
<ol>
<li>Il metodo <code>__iter__()</code> verrà chiamato ogni volta che qualcuno&nbsp;&mdash;&nbsp;diciamo, un ciclo <code>for</code>&nbsp;&mdash;&nbsp;chiama <code>iter(rules)</code>.
<li>L&#8217;unica cosa che ogni metodo <code>__iter__()</code> deve fare è restituire un iteratore. In questo caso, il metodo restituisce <var>self</var>, segnalando che questa classe definisce un metodo <code>__next__()</code> che si prenderà cura di restituire i valori durante l&#8217;iterazione.
</ol>

<pre class=pp><code><a>    def __next__(self):                                 <span class=u>&#x2460;</span></a>
        .
        .
        .
        pattern, search, replace = line.split(None, 3)
<a>        funcs = build_match_and_apply_functions(        <span class=u>&#x2461;</span></a>
            pattern, search, replace)
<a>        self.cache.append(funcs)                        <span class=u>&#x2462;</span></a>
        return funcs</code></pre>
<ol>
<li>Il metodo <code>__next__()</code> viene chiamato ogni volta che qualcuno&nbsp;&mdash;&nbsp;diciamo, un ciclo <code>for</code>&nbsp;&mdash;&nbsp;chiama <code>next(rules)</code>. Questo metodo si capisce meglio se cominciamo dalla fine e lo leggiamo all&#8217;indietro. Quindi, facciamolo.
<li>L&#8217;ultima parte di questa funzione dovrebbe sembrare quantomeno familiare. La funzione <code>build_match_and_apply_functions()</code> non è cambiata, è la stessa che è sempre stata.
<li>L&#8217;unica differenza è che, prima di restituire le funzioni di ricerca e sostituzione (che sono memorizzate nella tupla <var>funcs</var>), dobbiamo salvarle in <code>self.cache</code>.
</ol>

<p>Muovendoci all&#8217;indietro&hellip;

<pre class=pp><code>    def __next__(self):
        .
        .
        .
<a>        line = self.pattern_file.readline()  <span class=u>&#x2460;</span></a>
<a>        if not line:                         <span class=u>&#x2461;</span></a>
            self.pattern_file.close()
<a>            raise StopIteration              <span class=u>&#x2462;</span></a>
        .
        .
        .</code></pre>
<ol>
<li>Qui utilizziamo i file in maniera astuta. Il metodo <code>readline()</code> (notate: singolare, non il plurale <code>readlines()</code>) legge esattamente una riga da un file aperto. Nello specifico, la riga successiva. (<em>Anche gli oggetti file sono iteratori! Ci sono iteratori dappertutto&hellip;</em>)
<li>Se <code>readline()</code> legge una riga, <var>line</var> non sarà una stringa vuota. Anche se il file contenesse una riga vuota, <var>line</var> finirebbe per essere la stringa <code>'\n'</code> contenente il carattere di ritorno a capo. Quando <var>line</var> è davvero la stringa vuota significa che non ci sono più righe da leggere nel file.
<li>Quando raggiungiamo la fine del file, dobbiamo chiudere il file e lanciare la magica eccezione di tipo <code>StopIteration</code>. Ricordate, siamo arrivati a questo punto perché avevamo bisogno di una coppia di funzioni di ricerca e sostituzione per la regola successiva. Tale regola proviene dalla riga successiva nel file&hellip; ma non c&#8217;è nessun&#8217;altra riga! Di conseguenza, non abbiamo alcun valore da restituire. L&#8217;iterazione è finita. (<span class=u>&#x266B;</span> The party&#8217;s over&hellip; <span class=u>&#x266B;</span>)
</ol>

<p>Spostandoci all&#8217;indietro fino all&#8217;inizio del metodo <code>__next__()</code>&hellip;

<pre class=pp><code>    def __next__(self):
        self.cache_index += 1
        if len(self.cache) >= self.cache_index:
<a>            return self.cache[self.cache_index - 1]     <span class=u>&#x2460;</span></a>

        if self.pattern_file.closed:
<a>            raise StopIteration                         <span class=u>&#x2461;</span></a>
        .
        .
        .</code></pre>
<ol>
<li><code>self.cache</code> sarà una lista di funzioni per cercare corrispondenze con le singole regole e poi sostituirle. (Almeno <em>questo</em> dovrebbe suonarvi familiare!) <code>self.cache_index</code> tiene traccia di quale elemento in cache dovremo restituire successivamente. Se non abbiamo ancora esaurito la cache (cioè se la lunghezza di <code>self.cache</code> è maggiore di <code>self.cache_index</code>), allora l&#8217;accesso alla cache ha successo! Urrà! Possiamo restituire le funzioni di ricerca e sostituzione dalla cache anziché costruirle da zero.
<li>D&#8217;altra parte, se il tentativo di accesso alla cache fallisce <em>e</em> l&#8217;oggetto file è stato chiuso (cosa che potrebbe accadere più avanti nel metodo, come avete visto nel precedente frammento di codice) allora non c&#8217;è nient&#8217;altro che possiamo fare. Se il file è chiuso, vuol dire che lo abbiamo esaurito&nbsp;&mdash;&nbsp;abbiamo già letto ogni riga dal file dei pattern e abbiamo già costruito e memorizzato le funzioni di ricerca e sostituzione per ogni pattern. Il file è esaurito; la cache è esaurita; anche io sono ormai esaurito... Ma tenete duro, abbiamo quasi finito.
</ol>

<p>Mettendo insieme tutti i pezzi, ecco cosa succede e quando.

<ul>
<li>Quando il modulo viene importato, viene creata una singola istanza della classe <code>LazyRules</code>, chiamata <var>rules</var>, che apre il file dei pattern ma non lo legge.
<li>Quando si richiedono a <var>rules</var> le prime funzioni di ricerca e sostituzione, l&#8217;istanza controlla la propria cache ma scopre che è vuota. Quindi legge una singola riga dal file dei pattern, costruisce le funzioni di ricerca e sostituzione per i pattern di quella riga e le memorizza nella cache.
<li>Diciamo che, per fare un esempio, proprio la prima regola trova una corrispondenza. Se è così, nessuna nuova coppia di funzioni viene costruita e nessun&#8217;altra riga viene letta dal file.
<li>In più, sempre per fare un esempio, supponiamo che il chiamante invochi <em>di nuovo</em> la funzione <code>plural()</code> per costruire il plurale di una parola diversa. Il ciclo <code>for</code> nella funzione <code>plural()</code> chiamerà <code>iter(rules)</code>, che azzererà l&#8217;indice della cache ma non toccherà l&#8217;oggetto file aperto.
<li>Alla prima iterazione, il ciclo <code>for</code> chiederà un valore a <var>rules</var>, che invocherà il proprio metodo <code>__next__()</code>. Questa volta, però, la cache è caricata con una singola coppia di funzioni di ricerca e sostituzione, corrispondenti ai pattern nella prima riga del file dei pattern. Visto che la coppia è stata costruita e memorizzata nel tentativo di pluralizzare la parola precedente, viene recuperata dalla cache. L&#8217;indice della cache viene incrementato e il file aperto non viene mai toccato.
<li>Diciamo ora che, per fare un esempio, la prima regola questa volta non genera alcuna corrispondenza. Quindi il ciclo <code>for</code> ricomincia da capo e chiede un altro valore a <var>rules</var>, che invoca il metodo <code>__next__()</code> una seconda volta. Questa volta la cache è esaurita&nbsp;&mdash;&nbsp;conteneva un solo elemento e noi ne stiamo chiedendo un secondo&nbsp;&mdash;&nbsp;quindi il metodo <code>__next__()</code> prosegue. Legge un&#8217;altra riga dal file aperto, costruisce le funzioni di ricerca e sostituzione sulla base dei pattern e le memorizza in cache.
<li>Questo processo di lettura-costruzione-memorizzazione continuerà fino a quando le regole lette dal file dei pattern non corrisponderanno alla parola che stiamo cercando di pluralizzare. Se troviamo una regola che corrisponde prima della fine del file, semplicemente la usiamo e ci fermiamo, con il file ancora aperto. Il puntatore del file rimarrà ovunque avremo smesso di leggere, aspettando la prossima invocazione di <code>readline()</code>. Nel frattempo, la cache contiene ora più elementi, e se ricominciamo ancora a cercare di pluralizzare una nuova parola ognuno degli elementi in cache verrà provato prima di leggere la riga successiva dal file dei pattern.
</ul>

<p>Abbiamo raggiunto il nirvana della pluralizzazione.

<ol>
<li><strong>Costo di inizializzazione minimo.</strong> L&#8217;unica cosa che accade durante l&#8217;importazione del modulo è la creazione di una singola istanza di una classe e l&#8217;apertura di un file (ma senza alcuna lettura).
<li><strong>Prestazioni massime.</strong> L&#8217;esempio precedente avrebbe letto tutto il file e costruito funzioni dinamicamente ogni volta che volevate pluralizzare una parola. Questa versione memorizza le funzioni non appena vengono costruite e, nel caso peggiore, leggerà tutto il file dei pattern una volta sola a prescindere dal numero di parole che pluralizzate.
<li><strong>Separazione di codice e dati.</strong> Tutti i pattern sono archiviati in un file separato. Il codice è codice, i dati sono dati, &#8220;e mai i due si incontreranno&#8221;.
</ol>

<blockquote class=note>
<p><span class=u>&#x261E;</span>Questo è veramente il nirvana? Be&#8217;, sì e no. Ecco una cosa da considerare a proposito dell&#8217;esempio con <code>LazyRules</code>: il file dei pattern aperto durante l&#8217;esecuzione di <code>__init__()</code> rimane aperto fino a quando viene ragguinta l&#8217;ultima regola. Python chiuderà il file alla fine, quando uscite dall&#8217;interprete, o dopo che l&#8217;ultima istanza della classe <code>LazyRules</code> viene distrutta, ma l&#8217;intervallo di tempo trascorso fino a quel momento potrebbe ancora essere molto <em>lungo</em>. Se questa classe è parte di un processo Python di lunga durata, l&#8217;interprete potrebbe non terminare mai e l&#8217;oggetto <code>LazyRules</code> potrebbe non venire mai distrutto.
<p>Ci sono alcuni modi per aggirare questo problema. Invece di aprire il file durante l&#8217;esecuzione di <code>__init__()</code> e lasciarlo aperto mentre leggete le regole una alla volta, potreste aprire il file, leggere tutte le regole e chiudere immediatamente il file. Oppue potreste aprire il file, leggere una regola, salvare la posizione di lettura corrente del file con il <a href=file.html#read>metodo <code>tell()</code></a>, chiudere il file e riaprirlo più tardi, usando il <a href=file.html#read>metodo <code>seek()</code></a> per continuare a leggere dal punto in cui eravate rimasti. Oppure potreste non preoccuparvi del problema e lasciare semplicemente il file aperto, come in questo esempio di codice. La programmazione è progettazione, e la progettazione è fatta di compromessi e vincoli. Lasciare un file aperto troppo a lungo potrebbe essere un problema; rendere il vostro codice più complicato potrebbe essere un problema. Qual è il problema più grande dipende dal vostro gruppo di sviluppo, dalla vostra applicazione e dal vostro ambiente di esecuzione.
</blockquote>

<p class=a>&#x2042;

<h2 id=furtherreading>Letture di approfondimento</h2>
<ul>
<li><a href=http://docs.python.org/3.1/library/stdtypes.html#iterator-types>Tipi di iteratore</a>
<li><a href=http://www.python.org/dev/peps/pep-0234/><abbr>PEP</abbr> 234: Iteratori</a>
<li><a href=http://www.python.org/dev/peps/pep-0255/><abbr>PEP</abbr> 255: Generatori semplici</a>
<li><a href=http://www.dabeaz.com/generators/>Trucchi con i generatori per programmatori di sistema</a>
</ul>

<p class=v><a rel=prev href=generatori.html title='indietro a &#8220;Chiusure &amp; generatori&#8221;'><span class=u>&#x261C;</span></a> <a rel=next href=uso-avanzato-degli-iteratori.html title='avanti a &#8220;Uso avanzato degli iteratori&#8221;'><span class=u>&#x261E;</span></a>

<p class=c>&copy; 2001&ndash;10 <a href=informazioni-sul-libro.html>Mark Pilgrim</a><br>
&copy; 2009&ndash;10 <a href=informazioni-sulla-traduzione.html>Giulio Piancastelli</a> per la traduzione italiana
<script src=j/jquery.js></script>
<script src=j/prettify.js></script>
<script src=j/dip3.js></script>
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.