<?xml version="1.0"?>
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="it">
	<id>https://wiki.golem.linux.it/api.php?action=feedcontributions&amp;feedformat=atom&amp;user=Jdoe</id>
	<title>GolemWiki - Contributi utente [it]</title>
	<link rel="self" type="application/atom+xml" href="https://wiki.golem.linux.it/api.php?action=feedcontributions&amp;feedformat=atom&amp;user=Jdoe"/>
	<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/Speciale:Contributi/Jdoe"/>
	<updated>2026-05-01T09:41:13Z</updated>
	<subtitle>Contributi utente</subtitle>
	<generator>MediaWiki 1.35.5</generator>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Python_Lezione_11_Giugno_2008&amp;diff=3751</id>
		<title>Python Lezione 11 Giugno 2008</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Python_Lezione_11_Giugno_2008&amp;diff=3751"/>
		<updated>2008-06-13T18:41:42Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: /* IMPORTARE UN FILE */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;QUESTI APPUNTI SONO UNA BOZZA IN ATTESA DI CORREZIONE E, PER QUESTO, NON ATTENDIBILI.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== while ==&lt;br /&gt;
&lt;br /&gt;
Simile al for, si usa per effettuare un ciclo di cui non sappiamo la lunghezza esatta, ovvero si cicla ''finché'' la condizione specificata non risulta vera.&lt;br /&gt;
Torna utile quando vogliamo fare cicli infiniti, che con il for non possiamo fare in maniera &amp;quot;pulita&amp;quot;&lt;br /&gt;
Può essere usato (a discapito della chiarezza) come un ciclo for: ad esempio, se volessimo ciclare 10 volte possiamo scrivere&lt;br /&gt;
&lt;br /&gt;
   a = 0&lt;br /&gt;
   while a &amp;lt; 10:&lt;br /&gt;
        print a&lt;br /&gt;
        a = a + 1&lt;br /&gt;
&lt;br /&gt;
che è del tutto equivalente a &lt;br /&gt;
   for a in xrange(10):&lt;br /&gt;
       print a&lt;br /&gt;
&lt;br /&gt;
Altrimenti, per ciclare all'infinito&lt;br /&gt;
&lt;br /&gt;
  while True:&lt;br /&gt;
      print &amp;quot;y&amp;quot;&lt;br /&gt;
&lt;br /&gt;
che ha come effetto quello del programma ''yes'' dei sistemi *nix, ovvero stampa 'y' finchè non viene interrotto&lt;br /&gt;
&lt;br /&gt;
== Le funzioni ==&lt;br /&gt;
&lt;br /&gt;
quando noi abbiamo fatto il [[http://golem.linux.it/index.php/Lezione_4_Giugno#ESEMPIO_DELLA_SERATA: programma per calcolare le potenze]], abbiamo scritto diverse righe di codice.&lt;br /&gt;
Alcune di queste erano per recuperare e controllare l'input dell'utente, altre proprio per calcolare la potenza del numero.&lt;br /&gt;
Se nel corso del nostro programma ci servisse ripetere il calcolo della potenza base**esponente (facendo finta che non ci sia l'operatore ** che fa esattamente quello che vogliamo) potremmo&lt;br /&gt;
semplicemente fare copia-incolla di quelle righe ogni volta che ci servono. Poi ci accorgiamo che c'è un errore, che abbiamo quindi ripetuto n volte. E dobbiamo correggere n volte.&lt;br /&gt;
Se avessimo creato una funzione, invece, ci sarebbe una sola definizione e n chiamate: una volta trovato l'errore basta correggerlo una volta sola.&lt;br /&gt;
&lt;br /&gt;
La funzione di definisce usando ''def''.&lt;br /&gt;
Per crere una funzione dobbiamo scrivere: def -il nome della funzione- (-variabile1-,-variabile2-) : &lt;br /&gt;
es.&lt;br /&gt;
&lt;br /&gt;
  def potenza (base,esponente):&lt;br /&gt;
          result = 1&lt;br /&gt;
          for i in xrange(esponente):	&lt;br /&gt;
                  result=result*base&lt;br /&gt;
          return result&lt;br /&gt;
&lt;br /&gt;
return &amp;quot;ritorna&amp;quot; al chiamante il contenuto della variabile result.&lt;br /&gt;
&lt;br /&gt;
quindi il nostro programma diviene&lt;br /&gt;
  &lt;br /&gt;
  def potenza(base, esponente):&lt;br /&gt;
      result=1&lt;br /&gt;
      for i in xrange(esponente):&lt;br /&gt;
          result = result * base&lt;br /&gt;
      return result&lt;br /&gt;
&lt;br /&gt;
  base= raw_input (“inserisce la base:”)&lt;br /&gt;
  esponente=raw_input ('inserisci l\' esponente')&lt;br /&gt;
&lt;br /&gt;
  base=int(base)&lt;br /&gt;
  result=int(result)&lt;br /&gt;
&lt;br /&gt;
  print potenza(base, esponente)&lt;br /&gt;
&lt;br /&gt;
Vediamo come, se si omette anche uno o entrambi i parametri, viene generata una eccezione di tipo TypeError:&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; potenza()&lt;br /&gt;
  Traceback (most recent call last):&lt;br /&gt;
    File &amp;quot;&amp;lt;stdin&amp;gt;&amp;quot;, line 1, in &amp;lt;module&amp;gt;&lt;br /&gt;
  TypeError: potenza() takes exactly 2 arguments (0 given)&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; potenza(2)&lt;br /&gt;
  Traceback (most recent call last):&lt;br /&gt;
    File &amp;quot;&amp;lt;stdin&amp;gt;&amp;quot;, line 1, in &amp;lt;module&amp;gt;&lt;br /&gt;
  TypeError: potenza() takes exactly 2 arguments (1 given)&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; potenza (2,8)&lt;br /&gt;
  256&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Se si desiderasse avere il comportamento del tipo &amp;quot;se manca uno dei due parametri allora si intende che la base è 2 e il parametro presente è l'esponente&amp;quot;,&lt;br /&gt;
potrei usare i paramatri di default:&lt;br /&gt;
  &lt;br /&gt;
  def potenza(esponente, base=2):&lt;br /&gt;
      result=1&lt;br /&gt;
      for i in xrange(esponente):&lt;br /&gt;
          result = result * base&lt;br /&gt;
      return result&lt;br /&gt;
&lt;br /&gt;
quindi a questo punto &lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; potenza(8)&lt;br /&gt;
  256&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Da notare come i parametri di default devono necessariamente stare '''dopo''' i parametri che non hanno il valore di default.&lt;br /&gt;
&lt;br /&gt;
Potrei anche mettere entrambi i paramentri di default&lt;br /&gt;
&lt;br /&gt;
  def potenza(base=2, esponente=1):&lt;br /&gt;
      result=1&lt;br /&gt;
      for i in xrange(esponente):&lt;br /&gt;
          result = result * base&lt;br /&gt;
      return result&lt;br /&gt;
&lt;br /&gt;
In questo caso la chiamata&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; potenza()&lt;br /&gt;
  2&lt;br /&gt;
non genera l'eccezione perchè, avendo specificato per entrambi un valore di default l'interprete esegue 2**1 = 2&lt;br /&gt;
&lt;br /&gt;
Quando effettuo chiamate di funzione posso usare la keyword per rendere più chiaro il mio programma:&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; potenza(base=2, esponente=8)&lt;br /&gt;
  256&lt;br /&gt;
&lt;br /&gt;
In questo modo non mi devo ricordare l'ordine in cui sono stati definiti i parametri, e, rileggendo dopo mesi o anni il pezzo di codice, questo sarà sicuramente più chiaro.&lt;br /&gt;
Certe volte, per certi moduli, l'utilizzo delle keyword è indispensabile.&lt;br /&gt;
&lt;br /&gt;
== Moduli e import ==&lt;br /&gt;
&lt;br /&gt;
ammetto che qui mi sono persa.&lt;br /&gt;
&lt;br /&gt;
tutto è nato dalla domanda di raffaele:Quando creiamo il file, ecc....le variabili che validità hanno?&lt;br /&gt;
&lt;br /&gt;
abbiamo parlato del main, che non viene esguito se il file viene importato.&lt;br /&gt;
Abbiamo fatto degli esempi che io non ho avuto il tempo di copiare.&lt;br /&gt;
&lt;br /&gt;
Abbiamo anche parlato di dove il sistema va a cercare un file, del path, ecc...&lt;br /&gt;
Abbiamo fatto un esempio con un file chiamato python.tmp.py,&lt;br /&gt;
abbiamo detto come fare ad importarlo e abbiamo fatto un esempio pratico che ci faceva capire che, poichè il file era importato, non esguiva il main.Purtroppo mi sono persa l'esempio.&lt;br /&gt;
&lt;br /&gt;
== MODULI GANZI ==&lt;br /&gt;
abbiamo parlato di alcuni moduli con cui fare cose carine, mi sono persa la maggior parte degli esempi, ma metterò l'elenco dei moduli:&lt;br /&gt;
os&lt;br /&gt;
walk&lt;br /&gt;
mkdir&lt;br /&gt;
&lt;br /&gt;
== SOTTODIRECTORY ==&lt;br /&gt;
&lt;br /&gt;
qui ero in stato comatoso.Mi sono veramente eclissata.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== ESERCIZIO DELLA SERATA ==&lt;br /&gt;
Funzione che rivolta le stringhe.&lt;br /&gt;
abbiamo fatto vari tentativi ma poi ci siamo accorti che esiste la funzione reversed&lt;br /&gt;
&lt;br /&gt;
*mi sono persa la parte prima*&lt;br /&gt;
&lt;br /&gt;
  reversed(a)&lt;br /&gt;
  for elem in reversed(a):&lt;br /&gt;
          print elem&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Python_Lezione_11_Giugno_2008&amp;diff=3750</id>
		<title>Python Lezione 11 Giugno 2008</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Python_Lezione_11_Giugno_2008&amp;diff=3750"/>
		<updated>2008-06-13T18:40:21Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: /* LE FUNZIONI */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;QUESTI APPUNTI SONO UNA BOZZA IN ATTESA DI CORREZIONE E, PER QUESTO, NON ATTENDIBILI.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== while ==&lt;br /&gt;
&lt;br /&gt;
Simile al for, si usa per effettuare un ciclo di cui non sappiamo la lunghezza esatta, ovvero si cicla ''finché'' la condizione specificata non risulta vera.&lt;br /&gt;
Torna utile quando vogliamo fare cicli infiniti, che con il for non possiamo fare in maniera &amp;quot;pulita&amp;quot;&lt;br /&gt;
Può essere usato (a discapito della chiarezza) come un ciclo for: ad esempio, se volessimo ciclare 10 volte possiamo scrivere&lt;br /&gt;
&lt;br /&gt;
   a = 0&lt;br /&gt;
   while a &amp;lt; 10:&lt;br /&gt;
        print a&lt;br /&gt;
        a = a + 1&lt;br /&gt;
&lt;br /&gt;
che è del tutto equivalente a &lt;br /&gt;
   for a in xrange(10):&lt;br /&gt;
       print a&lt;br /&gt;
&lt;br /&gt;
Altrimenti, per ciclare all'infinito&lt;br /&gt;
&lt;br /&gt;
  while True:&lt;br /&gt;
      print &amp;quot;y&amp;quot;&lt;br /&gt;
&lt;br /&gt;
che ha come effetto quello del programma ''yes'' dei sistemi *nix, ovvero stampa 'y' finchè non viene interrotto&lt;br /&gt;
&lt;br /&gt;
== Le funzioni ==&lt;br /&gt;
&lt;br /&gt;
quando noi abbiamo fatto il [[http://golem.linux.it/index.php/Lezione_4_Giugno#ESEMPIO_DELLA_SERATA: programma per calcolare le potenze]], abbiamo scritto diverse righe di codice.&lt;br /&gt;
Alcune di queste erano per recuperare e controllare l'input dell'utente, altre proprio per calcolare la potenza del numero.&lt;br /&gt;
Se nel corso del nostro programma ci servisse ripetere il calcolo della potenza base**esponente (facendo finta che non ci sia l'operatore ** che fa esattamente quello che vogliamo) potremmo&lt;br /&gt;
semplicemente fare copia-incolla di quelle righe ogni volta che ci servono. Poi ci accorgiamo che c'è un errore, che abbiamo quindi ripetuto n volte. E dobbiamo correggere n volte.&lt;br /&gt;
Se avessimo creato una funzione, invece, ci sarebbe una sola definizione e n chiamate: una volta trovato l'errore basta correggerlo una volta sola.&lt;br /&gt;
&lt;br /&gt;
La funzione di definisce usando ''def''.&lt;br /&gt;
Per crere una funzione dobbiamo scrivere: def -il nome della funzione- (-variabile1-,-variabile2-) : &lt;br /&gt;
es.&lt;br /&gt;
&lt;br /&gt;
  def potenza (base,esponente):&lt;br /&gt;
          result = 1&lt;br /&gt;
          for i in xrange(esponente):	&lt;br /&gt;
                  result=result*base&lt;br /&gt;
          return result&lt;br /&gt;
&lt;br /&gt;
return &amp;quot;ritorna&amp;quot; al chiamante il contenuto della variabile result.&lt;br /&gt;
&lt;br /&gt;
quindi il nostro programma diviene&lt;br /&gt;
  &lt;br /&gt;
  def potenza(base, esponente):&lt;br /&gt;
      result=1&lt;br /&gt;
      for i in xrange(esponente):&lt;br /&gt;
          result = result * base&lt;br /&gt;
      return result&lt;br /&gt;
&lt;br /&gt;
  base= raw_input (“inserisce la base:”)&lt;br /&gt;
  esponente=raw_input ('inserisci l\' esponente')&lt;br /&gt;
&lt;br /&gt;
  base=int(base)&lt;br /&gt;
  result=int(result)&lt;br /&gt;
&lt;br /&gt;
  print potenza(base, esponente)&lt;br /&gt;
&lt;br /&gt;
Vediamo come, se si omette anche uno o entrambi i parametri, viene generata una eccezione di tipo TypeError:&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; potenza()&lt;br /&gt;
  Traceback (most recent call last):&lt;br /&gt;
    File &amp;quot;&amp;lt;stdin&amp;gt;&amp;quot;, line 1, in &amp;lt;module&amp;gt;&lt;br /&gt;
  TypeError: potenza() takes exactly 2 arguments (0 given)&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; potenza(2)&lt;br /&gt;
  Traceback (most recent call last):&lt;br /&gt;
    File &amp;quot;&amp;lt;stdin&amp;gt;&amp;quot;, line 1, in &amp;lt;module&amp;gt;&lt;br /&gt;
  TypeError: potenza() takes exactly 2 arguments (1 given)&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; potenza (2,8)&lt;br /&gt;
  256&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Se si desiderasse avere il comportamento del tipo &amp;quot;se manca uno dei due parametri allora si intende che la base è 2 e il parametro presente è l'esponente&amp;quot;,&lt;br /&gt;
potrei usare i paramatri di default:&lt;br /&gt;
  &lt;br /&gt;
  def potenza(esponente, base=2):&lt;br /&gt;
      result=1&lt;br /&gt;
      for i in xrange(esponente):&lt;br /&gt;
          result = result * base&lt;br /&gt;
      return result&lt;br /&gt;
&lt;br /&gt;
quindi a questo punto &lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; potenza(8)&lt;br /&gt;
  256&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Da notare come i parametri di default devono necessariamente stare '''dopo''' i parametri che non hanno il valore di default.&lt;br /&gt;
&lt;br /&gt;
Potrei anche mettere entrambi i paramentri di default&lt;br /&gt;
&lt;br /&gt;
  def potenza(base=2, esponente=1):&lt;br /&gt;
      result=1&lt;br /&gt;
      for i in xrange(esponente):&lt;br /&gt;
          result = result * base&lt;br /&gt;
      return result&lt;br /&gt;
&lt;br /&gt;
In questo caso la chiamata&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; potenza()&lt;br /&gt;
  2&lt;br /&gt;
non genera l'eccezione perchè, avendo specificato per entrambi un valore di default l'interprete esegue 2**1 = 2&lt;br /&gt;
&lt;br /&gt;
Quando effettuo chiamate di funzione posso usare la keyword per rendere più chiaro il mio programma:&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; potenza(base=2, esponente=8)&lt;br /&gt;
  256&lt;br /&gt;
&lt;br /&gt;
In questo modo non mi devo ricordare l'ordine in cui sono stati definiti i parametri, e, rileggendo dopo mesi o anni il pezzo di codice, questo sarà sicuramente più chiaro.&lt;br /&gt;
Certe volte, per certi moduli, l'utilizzo delle keyword è indispensabile.&lt;br /&gt;
&lt;br /&gt;
== IMPORTARE UN FILE ==&lt;br /&gt;
&lt;br /&gt;
ammetto che qui mi sono persa.&lt;br /&gt;
&lt;br /&gt;
tutto è nato dalla domanda di raffaele:Quando creiamo il file, ecc....le variabili che validità hanno?&lt;br /&gt;
&lt;br /&gt;
abbiamo parlato del main, che non viene esguito se il file viene importato.&lt;br /&gt;
Abbiamo fatto degli esempi che io non ho avuto il tempo di copiare.&lt;br /&gt;
&lt;br /&gt;
Abbiamo anche parlato di dove il sistema va a cercare un file, del path, ecc...&lt;br /&gt;
Abbiamo fatto un esempio con un file chiamato python.tmp.py,&lt;br /&gt;
abbiamo detto come fare ad importarlo e abbiamo fatto un esempio pratico che ci faceva capire che, poichè il file era importato, non esguiva il main.Purtroppo mi sono persa l'esempio.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== MODULI GANZI ==&lt;br /&gt;
abbiamo parlato di alcuni moduli con cui fare cose carine, mi sono persa la maggior parte degli esempi, ma metterò l'elenco dei moduli:&lt;br /&gt;
os&lt;br /&gt;
walk&lt;br /&gt;
mkdir&lt;br /&gt;
&lt;br /&gt;
== SOTTODIRECTORY ==&lt;br /&gt;
&lt;br /&gt;
qui ero in stato comatoso.Mi sono veramente eclissata.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== ESERCIZIO DELLA SERATA ==&lt;br /&gt;
Funzione che rivolta le stringhe.&lt;br /&gt;
abbiamo fatto vari tentativi ma poi ci siamo accorti che esiste la funzione reversed&lt;br /&gt;
&lt;br /&gt;
*mi sono persa la parte prima*&lt;br /&gt;
&lt;br /&gt;
  reversed(a)&lt;br /&gt;
  for elem in reversed(a):&lt;br /&gt;
          print elem&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Python_Lezione_11_Giugno_2008&amp;diff=3749</id>
		<title>Python Lezione 11 Giugno 2008</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Python_Lezione_11_Giugno_2008&amp;diff=3749"/>
		<updated>2008-06-13T18:30:42Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: /* LE FUNZIONI */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;QUESTI APPUNTI SONO UNA BOZZA IN ATTESA DI CORREZIONE E, PER QUESTO, NON ATTENDIBILI.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== while ==&lt;br /&gt;
&lt;br /&gt;
Simile al for, si usa per effettuare un ciclo di cui non sappiamo la lunghezza esatta, ovvero si cicla ''finché'' la condizione specificata non risulta vera.&lt;br /&gt;
Torna utile quando vogliamo fare cicli infiniti, che con il for non possiamo fare in maniera &amp;quot;pulita&amp;quot;&lt;br /&gt;
Può essere usato (a discapito della chiarezza) come un ciclo for: ad esempio, se volessimo ciclare 10 volte possiamo scrivere&lt;br /&gt;
&lt;br /&gt;
   a = 0&lt;br /&gt;
   while a &amp;lt; 10:&lt;br /&gt;
        print a&lt;br /&gt;
        a = a + 1&lt;br /&gt;
&lt;br /&gt;
che è del tutto equivalente a &lt;br /&gt;
   for a in xrange(10):&lt;br /&gt;
       print a&lt;br /&gt;
&lt;br /&gt;
Altrimenti, per ciclare all'infinito&lt;br /&gt;
&lt;br /&gt;
  while True:&lt;br /&gt;
      print &amp;quot;y&amp;quot;&lt;br /&gt;
&lt;br /&gt;
che ha come effetto quello del programma ''yes'' dei sistemi *nix, ovvero stampa 'y' finchè non viene interrotto&lt;br /&gt;
&lt;br /&gt;
== LE FUNZIONI ==&lt;br /&gt;
&lt;br /&gt;
quando noi abbiamo fatto il [[http://golem.linux.it/index.php/Lezione_4_Giugno#ESEMPIO_DELLA_SERATA: programma per calcolare le potenze]], abbiamo scritto diverse righe di codice.&lt;br /&gt;
Alcune di queste erano per recuperare e controllare l'input dell'utente, altre proprio per calcolare la potenza del numero.&lt;br /&gt;
Se nel corso del nostro programma ci servisse ripetere il calcolo della potenza base**esponente (facendo finta che non ci sia l'operatore ** che fa esattamente quello che vogliamo) potremmo&lt;br /&gt;
semplicemente fare copia-incolla di quelle righe ogni volta che ci servono. Poi ci accorgiamo che c'è un errore, che abbiamo quindi ripetuto n volte. E dobbiamo correggere n volte.&lt;br /&gt;
Se avessimo creato una funzione, invece, ci sarebbe una sola definizione e n chiamate: una volta trovato l'errore basta correggerlo una volta sola.&lt;br /&gt;
&lt;br /&gt;
La funzione di definisce usando ''def''.&lt;br /&gt;
Per crere una funzione dobbiamo scrivere: def -il nome della funzione- (-variabile1-,-variabile2-) : &lt;br /&gt;
es.&lt;br /&gt;
&lt;br /&gt;
  def potenza (base,esponente):&lt;br /&gt;
          result = 1&lt;br /&gt;
          for i in xrange(esponente):	&lt;br /&gt;
                  result=result*base&lt;br /&gt;
          return result&lt;br /&gt;
&lt;br /&gt;
return &amp;quot;ritorna&amp;quot; al chiamante il contenuto della variabile result.&lt;br /&gt;
&lt;br /&gt;
quindi il nostro programma diviene&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
base è un parametro quindi quando chiamo potenza lui mi da type error&lt;br /&gt;
potenza (2,8)&lt;br /&gt;
lui mi da 256 altrimenti mi da il type error&lt;br /&gt;
&lt;br /&gt;
se io do pot= potenza(2,8)&lt;br /&gt;
ora pot è il risultato della potenza di due all'ottava.&lt;br /&gt;
&lt;br /&gt;
Posso usare I parametri di default che devono stare dopo queli non di default&lt;br /&gt;
  def potenza (esponent, base=2):&lt;br /&gt;
          result-1&lt;br /&gt;
          for I in xrange(esponent):	&lt;br /&gt;
                  result=result*base&lt;br /&gt;
          return result&lt;br /&gt;
&lt;br /&gt;
lui mi da l'errore solo quando eseguo, non me la da prima, in un linguaggio compilato se io lo compilo l'operatore me lo da subito.&lt;br /&gt;
Potenza(8)&lt;br /&gt;
lui ha valore di default due&lt;br /&gt;
se do due valori lui usa il secondo valore e se ne strafrega del primo.&lt;br /&gt;
&lt;br /&gt;
I parametri hanno la keyword&lt;br /&gt;
potenza(base=2,esponente=8)&lt;br /&gt;
questo modo di scrivere è un pò più chiaro meglio di&lt;br /&gt;
potenza(2,8) che poi magari uno non ha chiaro cosa significhino quei due numeri.&lt;br /&gt;
&lt;br /&gt;
Se base ce l'ho di default non posso scrivere&lt;br /&gt;
potenza(8, base)&lt;br /&gt;
lui mi da errore lui la prende come variabile.&lt;br /&gt;
&lt;br /&gt;
Upper lower e questa cose qui sono funzioni.&lt;br /&gt;
&lt;br /&gt;
== IMPORTARE UN FILE ==&lt;br /&gt;
&lt;br /&gt;
ammetto che qui mi sono persa.&lt;br /&gt;
&lt;br /&gt;
tutto è nato dalla domanda di raffaele:Quando creiamo il file, ecc....le variabili che validità hanno?&lt;br /&gt;
&lt;br /&gt;
abbiamo parlato del main, che non viene esguito se il file viene importato.&lt;br /&gt;
Abbiamo fatto degli esempi che io non ho avuto il tempo di copiare.&lt;br /&gt;
&lt;br /&gt;
Abbiamo anche parlato di dove il sistema va a cercare un file, del path, ecc...&lt;br /&gt;
Abbiamo fatto un esempio con un file chiamato python.tmp.py,&lt;br /&gt;
abbiamo detto come fare ad importarlo e abbiamo fatto un esempio pratico che ci faceva capire che, poichè il file era importato, non esguiva il main.Purtroppo mi sono persa l'esempio.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== MODULI GANZI ==&lt;br /&gt;
abbiamo parlato di alcuni moduli con cui fare cose carine, mi sono persa la maggior parte degli esempi, ma metterò l'elenco dei moduli:&lt;br /&gt;
os&lt;br /&gt;
walk&lt;br /&gt;
mkdir&lt;br /&gt;
&lt;br /&gt;
== SOTTODIRECTORY ==&lt;br /&gt;
&lt;br /&gt;
qui ero in stato comatoso.Mi sono veramente eclissata.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== ESERCIZIO DELLA SERATA ==&lt;br /&gt;
Funzione che rivolta le stringhe.&lt;br /&gt;
abbiamo fatto vari tentativi ma poi ci siamo accorti che esiste la funzione reversed&lt;br /&gt;
&lt;br /&gt;
*mi sono persa la parte prima*&lt;br /&gt;
&lt;br /&gt;
  reversed(a)&lt;br /&gt;
  for elem in reversed(a):&lt;br /&gt;
          print elem&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Python_Lezione_11_Giugno_2008&amp;diff=3748</id>
		<title>Python Lezione 11 Giugno 2008</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Python_Lezione_11_Giugno_2008&amp;diff=3748"/>
		<updated>2008-06-13T18:26:16Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: /* while */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;QUESTI APPUNTI SONO UNA BOZZA IN ATTESA DI CORREZIONE E, PER QUESTO, NON ATTENDIBILI.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== while ==&lt;br /&gt;
&lt;br /&gt;
Simile al for, si usa per effettuare un ciclo di cui non sappiamo la lunghezza esatta, ovvero si cicla ''finché'' la condizione specificata non risulta vera.&lt;br /&gt;
Torna utile quando vogliamo fare cicli infiniti, che con il for non possiamo fare in maniera &amp;quot;pulita&amp;quot;&lt;br /&gt;
Può essere usato (a discapito della chiarezza) come un ciclo for: ad esempio, se volessimo ciclare 10 volte possiamo scrivere&lt;br /&gt;
&lt;br /&gt;
   a = 0&lt;br /&gt;
   while a &amp;lt; 10:&lt;br /&gt;
        print a&lt;br /&gt;
        a = a + 1&lt;br /&gt;
&lt;br /&gt;
che è del tutto equivalente a &lt;br /&gt;
   for a in xrange(10):&lt;br /&gt;
       print a&lt;br /&gt;
&lt;br /&gt;
Altrimenti, per ciclare all'infinito&lt;br /&gt;
&lt;br /&gt;
  while True:&lt;br /&gt;
      print &amp;quot;y&amp;quot;&lt;br /&gt;
&lt;br /&gt;
che ha come effetto quello del programma ''yes'' dei sistemi *nix, ovvero stampa 'y' finchè non viene interrotto&lt;br /&gt;
&lt;br /&gt;
== LE FUNZIONI ==&lt;br /&gt;
&lt;br /&gt;
quando noi abbiamo fatto il [[http://golem.linux.it/index.php/Lezione_4_Giugno#ESEMPIO_DELLA_SERATA: programma per calcolare le potenze]], abbiamo scritto diverse righe di codice.&lt;br /&gt;
per evitare ogni volta di riscrivere quelle righe, potremmo creare una funzione che fa esattamente quella cosa.&lt;br /&gt;
La funzione di definisce ''def''.&lt;br /&gt;
Per crere una funzione dobbiamo scrivere: def -il nome della funzione- (-variabile1-,-variabile2-) : &lt;br /&gt;
es.&lt;br /&gt;
  def potenza (base,esponente):&lt;br /&gt;
          result-1&lt;br /&gt;
          for I in xrange(esponente):	&lt;br /&gt;
                  result=result*base&lt;br /&gt;
          return result&lt;br /&gt;
&lt;br /&gt;
base è un parametro quindi quando chiamo potenza lui mi da type error&lt;br /&gt;
potenza (2,8)&lt;br /&gt;
lui mi da 256 altrimenti mi da il type error&lt;br /&gt;
&lt;br /&gt;
se io do pot= potenza(2,8)&lt;br /&gt;
ora pot è il risultato della potenza di due all'ottava.&lt;br /&gt;
&lt;br /&gt;
Posso usare I parametri di default che devono stare dopo queli non di default&lt;br /&gt;
  def potenza (esponent, base=2):&lt;br /&gt;
          result-1&lt;br /&gt;
          for I in xrange(esponent):	&lt;br /&gt;
                  result=result*base&lt;br /&gt;
          return result&lt;br /&gt;
&lt;br /&gt;
lui mi da l'errore solo quando eseguo, non me la da prima, in un linguaggio compilato se io lo compilo l'operatore me lo da subito.&lt;br /&gt;
Potenza(8)&lt;br /&gt;
lui ha valore di default due&lt;br /&gt;
se do due valori lui usa il secondo valore e se ne strafrega del primo.&lt;br /&gt;
&lt;br /&gt;
I parametri hanno la keyword&lt;br /&gt;
potenza(base=2,esponente=8)&lt;br /&gt;
questo modo di scrivere è un pò più chiaro meglio di&lt;br /&gt;
potenza(2,8) che poi magari uno non ha chiaro cosa significhino quei due numeri.&lt;br /&gt;
&lt;br /&gt;
Se base ce l'ho di default non posso scrivere&lt;br /&gt;
potenza(8, base)&lt;br /&gt;
lui mi da errore lui la prende come variabile.&lt;br /&gt;
&lt;br /&gt;
Upper lower e questa cose qui sono funzioni.&lt;br /&gt;
&lt;br /&gt;
== IMPORTARE UN FILE ==&lt;br /&gt;
&lt;br /&gt;
ammetto che qui mi sono persa.&lt;br /&gt;
&lt;br /&gt;
tutto è nato dalla domanda di raffaele:Quando creiamo il file, ecc....le variabili che validità hanno?&lt;br /&gt;
&lt;br /&gt;
abbiamo parlato del main, che non viene esguito se il file viene importato.&lt;br /&gt;
Abbiamo fatto degli esempi che io non ho avuto il tempo di copiare.&lt;br /&gt;
&lt;br /&gt;
Abbiamo anche parlato di dove il sistema va a cercare un file, del path, ecc...&lt;br /&gt;
Abbiamo fatto un esempio con un file chiamato python.tmp.py,&lt;br /&gt;
abbiamo detto come fare ad importarlo e abbiamo fatto un esempio pratico che ci faceva capire che, poichè il file era importato, non esguiva il main.Purtroppo mi sono persa l'esempio.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== MODULI GANZI ==&lt;br /&gt;
abbiamo parlato di alcuni moduli con cui fare cose carine, mi sono persa la maggior parte degli esempi, ma metterò l'elenco dei moduli:&lt;br /&gt;
os&lt;br /&gt;
walk&lt;br /&gt;
mkdir&lt;br /&gt;
&lt;br /&gt;
== SOTTODIRECTORY ==&lt;br /&gt;
&lt;br /&gt;
qui ero in stato comatoso.Mi sono veramente eclissata.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== ESERCIZIO DELLA SERATA ==&lt;br /&gt;
Funzione che rivolta le stringhe.&lt;br /&gt;
abbiamo fatto vari tentativi ma poi ci siamo accorti che esiste la funzione reversed&lt;br /&gt;
&lt;br /&gt;
*mi sono persa la parte prima*&lt;br /&gt;
&lt;br /&gt;
  reversed(a)&lt;br /&gt;
  for elem in reversed(a):&lt;br /&gt;
          print elem&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Python_Lezione_11_Giugno_2008&amp;diff=3747</id>
		<title>Python Lezione 11 Giugno 2008</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Python_Lezione_11_Giugno_2008&amp;diff=3747"/>
		<updated>2008-06-13T18:24:33Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: /* WHILE */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;QUESTI APPUNTI SONO UNA BOZZA IN ATTESA DI CORREZIONE E, PER QUESTO, NON ATTENDIBILI.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== while ==&lt;br /&gt;
&lt;br /&gt;
Simile al for, si usa per effettuare un ciclo di cui non sappiamo la durata esatta, ovvero si cicla ''finché'' la condizione non risulta vera&lt;br /&gt;
Torna utile quando vogliamo fare cicli infiniti, che con il for non possiamo fare in maniera &amp;quot;pulita&amp;quot;&lt;br /&gt;
Può essere usato (a discapito della chiarezza) come un ciclo for: ad esempio, se volessimo ciclare 10 volte possiamo scrivere&lt;br /&gt;
&lt;br /&gt;
   a = 0&lt;br /&gt;
   while a &amp;lt; 10:&lt;br /&gt;
        print a&lt;br /&gt;
        a = a + 1&lt;br /&gt;
&lt;br /&gt;
che è del tutto equivalente a &lt;br /&gt;
   for a in xrange(10):&lt;br /&gt;
       print a&lt;br /&gt;
&lt;br /&gt;
Altrimenti, per ciclare all'infinito&lt;br /&gt;
&lt;br /&gt;
  while True:&lt;br /&gt;
      print &amp;quot;y&amp;quot;&lt;br /&gt;
&lt;br /&gt;
che ha come effetto quello del programma ''yes'' dei sistemi *nix, ovvero stampa 'y' finchè non viene interrotto&lt;br /&gt;
&lt;br /&gt;
== LE FUNZIONI ==&lt;br /&gt;
&lt;br /&gt;
quando noi abbiamo fatto il [[http://golem.linux.it/index.php/Lezione_4_Giugno#ESEMPIO_DELLA_SERATA: programma per calcolare le potenze]], abbiamo scritto diverse righe di codice.&lt;br /&gt;
per evitare ogni volta di riscrivere quelle righe, potremmo creare una funzione che fa esattamente quella cosa.&lt;br /&gt;
La funzione di definisce ''def''.&lt;br /&gt;
Per crere una funzione dobbiamo scrivere: def -il nome della funzione- (-variabile1-,-variabile2-) : &lt;br /&gt;
es.&lt;br /&gt;
  def potenza (base,esponente):&lt;br /&gt;
          result-1&lt;br /&gt;
          for I in xrange(esponente):	&lt;br /&gt;
                  result=result*base&lt;br /&gt;
          return result&lt;br /&gt;
&lt;br /&gt;
base è un parametro quindi quando chiamo potenza lui mi da type error&lt;br /&gt;
potenza (2,8)&lt;br /&gt;
lui mi da 256 altrimenti mi da il type error&lt;br /&gt;
&lt;br /&gt;
se io do pot= potenza(2,8)&lt;br /&gt;
ora pot è il risultato della potenza di due all'ottava.&lt;br /&gt;
&lt;br /&gt;
Posso usare I parametri di default che devono stare dopo queli non di default&lt;br /&gt;
  def potenza (esponent, base=2):&lt;br /&gt;
          result-1&lt;br /&gt;
          for I in xrange(esponent):	&lt;br /&gt;
                  result=result*base&lt;br /&gt;
          return result&lt;br /&gt;
&lt;br /&gt;
lui mi da l'errore solo quando eseguo, non me la da prima, in un linguaggio compilato se io lo compilo l'operatore me lo da subito.&lt;br /&gt;
Potenza(8)&lt;br /&gt;
lui ha valore di default due&lt;br /&gt;
se do due valori lui usa il secondo valore e se ne strafrega del primo.&lt;br /&gt;
&lt;br /&gt;
I parametri hanno la keyword&lt;br /&gt;
potenza(base=2,esponente=8)&lt;br /&gt;
questo modo di scrivere è un pò più chiaro meglio di&lt;br /&gt;
potenza(2,8) che poi magari uno non ha chiaro cosa significhino quei due numeri.&lt;br /&gt;
&lt;br /&gt;
Se base ce l'ho di default non posso scrivere&lt;br /&gt;
potenza(8, base)&lt;br /&gt;
lui mi da errore lui la prende come variabile.&lt;br /&gt;
&lt;br /&gt;
Upper lower e questa cose qui sono funzioni.&lt;br /&gt;
&lt;br /&gt;
== IMPORTARE UN FILE ==&lt;br /&gt;
&lt;br /&gt;
ammetto che qui mi sono persa.&lt;br /&gt;
&lt;br /&gt;
tutto è nato dalla domanda di raffaele:Quando creiamo il file, ecc....le variabili che validità hanno?&lt;br /&gt;
&lt;br /&gt;
abbiamo parlato del main, che non viene esguito se il file viene importato.&lt;br /&gt;
Abbiamo fatto degli esempi che io non ho avuto il tempo di copiare.&lt;br /&gt;
&lt;br /&gt;
Abbiamo anche parlato di dove il sistema va a cercare un file, del path, ecc...&lt;br /&gt;
Abbiamo fatto un esempio con un file chiamato python.tmp.py,&lt;br /&gt;
abbiamo detto come fare ad importarlo e abbiamo fatto un esempio pratico che ci faceva capire che, poichè il file era importato, non esguiva il main.Purtroppo mi sono persa l'esempio.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== MODULI GANZI ==&lt;br /&gt;
abbiamo parlato di alcuni moduli con cui fare cose carine, mi sono persa la maggior parte degli esempi, ma metterò l'elenco dei moduli:&lt;br /&gt;
os&lt;br /&gt;
walk&lt;br /&gt;
mkdir&lt;br /&gt;
&lt;br /&gt;
== SOTTODIRECTORY ==&lt;br /&gt;
&lt;br /&gt;
qui ero in stato comatoso.Mi sono veramente eclissata.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== ESERCIZIO DELLA SERATA ==&lt;br /&gt;
Funzione che rivolta le stringhe.&lt;br /&gt;
abbiamo fatto vari tentativi ma poi ci siamo accorti che esiste la funzione reversed&lt;br /&gt;
&lt;br /&gt;
*mi sono persa la parte prima*&lt;br /&gt;
&lt;br /&gt;
  reversed(a)&lt;br /&gt;
  for elem in reversed(a):&lt;br /&gt;
          print elem&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3744</id>
		<title>Python Lezione 4 Giugno 2008</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3744"/>
		<updated>2008-06-10T12:20:50Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: /* PRINT */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Python ==&lt;br /&gt;
[http://www.python.it/ Python] è un linguaggio di programmazione [http://it.wikipedia.org/wiki/Interprete_(informatica) interpretato].&lt;br /&gt;
Il linuaggio interpretato è simile agli altri linguaggi in circolazione ma, invece di essere trasformato direttamente in codice binario dal meccanismo automatico, viene interpretato da questo e poi mandato all'hardware.&lt;br /&gt;
Un linguaggio interpretato non ha bisogno di essere ricompilato: il codice scritto viene interpretato da un interprete a run-time (tempo di esecuzione) e tradotto al volo nel linguaggio macchina.&lt;br /&gt;
Quindi i programmi python possono girare su qualsiasi hardware e sistema operativo su cui è stato portato l'interprete. Ovviamente, questa cosa si paga sul tempo di esecuzione pure: l'approccio ha si i suoi vantaggi, ma rispetto a un linguaggio compilato direttamente in linguaggio macchina per creare un eseguibile, python e gli altri liguaggi interpretati risultano essere più lenti.&lt;br /&gt;
&lt;br /&gt;
Esistono vari interpreti: [http://www.python.org Cpython], o classic python, è l'interprete &amp;quot;ufficiale&amp;quot;, scritto in C e disponibile per linux, mac e windows.&lt;br /&gt;
[http://www.jython.org/Project/ Jython] è un interprete scritto al 100% in Java, e si interfaccia strettamente ai programmi e alla libreria Java, &lt;br /&gt;
[http://www.codeplex.com/Wiki/View.aspx?ProjectName=IronPython IronPython] è un interprete python che gira sulla piattaforma .NET mentre &lt;br /&gt;
[http://codespeak.net/pypy/dist/pypy/doc/home.html PyPy] è (anche) un interprete python scritto in.. python&lt;br /&gt;
&lt;br /&gt;
La prima riga di ogni script python deve iniziare con #!/usr/bin/env python&lt;br /&gt;
&lt;br /&gt;
il #! del file fa capire al sistema operativo (solo su sistemi posix, quindi unix/linux) che quello non è un file di testo ma un eseguibile da eseguire con l'inteprete python.&lt;br /&gt;
&lt;br /&gt;
== COMMENTI ==&lt;br /&gt;
&lt;br /&gt;
: sono righe che l'interprete salta e non legge &lt;br /&gt;
es: &lt;br /&gt;
    ''# stampa:”hello word”''&lt;br /&gt;
&lt;br /&gt;
== PRINT ==&lt;br /&gt;
Lo statement [http://docs.python.org/ref/print.html print] valuta tutte le espressioni presenti e quindi le stampa a video.&lt;br /&gt;
L'espressione da valutare può essere anche un semplice numero o una semplice stringa o in generale un oggetto qualsiasi&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; print 3&lt;br /&gt;
  3&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; print &amp;quot;3&amp;quot;&lt;br /&gt;
  3&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; &lt;br /&gt;
&lt;br /&gt;
stampa lo stesso valore anche se abbiamo passato prima un intero, poi una stringa.&lt;br /&gt;
Questo è normale, perchè il numero &amp;quot;tre&amp;quot; viene rappresentato dal simbolo 3 nel sistema decimale.&lt;br /&gt;
&lt;br /&gt;
Invece&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; print 3+2&lt;br /&gt;
  5&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt;&lt;br /&gt;
  &lt;br /&gt;
otteniamo a video 5: l'inteprete ha valutato l'espressione, ha eseguito la somma e stampato il risultato&lt;br /&gt;
Mentre se scriviamo&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; print &amp;quot;3+2&amp;quot;&lt;br /&gt;
  3+2&lt;br /&gt;
  &lt;br /&gt;
in quanto abbiamo passato la stringa composta dal carattere 3, dal simbolo + e dal carattere 2.&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; print &amp;quot;3&amp;quot;+&amp;quot;2&amp;quot;&lt;br /&gt;
  32&lt;br /&gt;
Stampa 3 concatenato a 2, ovvero la stringa 32. Uguale all'esempio del 3+2 tra interi, solo che qui ha usato l'opertatore&lt;br /&gt;
di addizione tra stringhe, che fa la concatenazione&lt;br /&gt;
&lt;br /&gt;
Le variabili in python non devono essere dichiarate: esistono dalla prima volta in cui gli viene assegnato un valore&lt;br /&gt;
&amp;gt;&amp;gt;&amp;gt; messaggio = &amp;quot;Hello, World&amp;quot;&lt;br /&gt;
&amp;gt;&amp;gt;&amp;gt; print messaggio&lt;br /&gt;
Hello, World&lt;br /&gt;
&lt;br /&gt;
l'interprete valuta l'espressione ''messaggio'' e stampa il suo contenuto&lt;br /&gt;
&lt;br /&gt;
== Errori e Eccezioni ==&lt;br /&gt;
&lt;br /&gt;
Commentando l'assegnamento di messaggio, vediamo che l'interprete genera un errore:&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
  jdoe@waste-bin ~ $ python&lt;br /&gt;
  Python 2.5.2 (r252:60911, May 24 2008, 15:28:31) &lt;br /&gt;
  [GCC 4.2.4 (Gentoo 4.2.4 p1.0)] on linux2&lt;br /&gt;
  Type &amp;quot;help&amp;quot;, &amp;quot;copyright&amp;quot;, &amp;quot;credits&amp;quot; or &amp;quot;license&amp;quot; for more information.&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; print messaggio&lt;br /&gt;
  Traceback (most recent call last):&lt;br /&gt;
    File &amp;quot;&amp;lt;stdin&amp;gt;&amp;quot;, line 1, in &amp;lt;module&amp;gt;&lt;br /&gt;
  NameError: name 'messaggio' is not defined&lt;br /&gt;
&lt;br /&gt;
NameError è una eccezione. Vedremo più avanti come queste situazioni di errore possono essere ''catturate'' e ''gestite'' appositamente, sia&lt;br /&gt;
per tentare di risolvere il problema che per migliorare il feedback che il nostro programma da all'utente. Vedremo anche come&lt;br /&gt;
la gestione delle eccezioni è parte della programmazione normale di un programma, ovvero non è sempre legata a una situazione di errore.&lt;br /&gt;
&lt;br /&gt;
Un altro esempio, tendando di sommare mele e pere:&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; print 1 + &amp;quot;a&amp;quot;&lt;br /&gt;
  Traceback (most recent call last):&lt;br /&gt;
    File &amp;quot;&amp;lt;stdin&amp;gt;&amp;quot;, line 1, in &amp;lt;module&amp;gt;&lt;br /&gt;
  TypeError: unsupported operand type(s) for +: 'int' and 'str'&lt;br /&gt;
&lt;br /&gt;
Vediamo che a questo giro l'eccezione lanciata è ValueError.&lt;br /&gt;
&lt;br /&gt;
== LE STRINGHE ==&lt;br /&gt;
Gli oggetti di tipo stringa supportano svariati metodi e proprietà. E' da notare che le stringhe sono immutabili.&lt;br /&gt;
Se una stringa viene dichiarata la seconda volta, quella precedente viene buttata, non viene modificata per fare spazio alla nuova.&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
    messaggio=”ciao mondo”&lt;br /&gt;
    print messaggio''&lt;br /&gt;
stampa&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
In Python non si possono sommare cose diverse, o meglio, lo posso fare solo se è definita una conversione tra i due tipo.&lt;br /&gt;
Le stringhe supportano anche alcuni operatori base:&lt;br /&gt;
    ''print messaggio*2'' &lt;br /&gt;
l'esecuzione darà&lt;br /&gt;
    ''messaggio messaggio&lt;br /&gt;
''&lt;br /&gt;
esempio:&lt;br /&gt;
     ''Print “ciao”+” mondo”''&lt;br /&gt;
lo eseguo e mi darà:&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
== '''Funzione DIR''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
    dir(messaggio)''&lt;br /&gt;
a questo punto il programma da una serie di caratteri incomprensibili.&lt;br /&gt;
Praticamente dà i '''metodi''' che suporta la stringa messaggio.&lt;br /&gt;
&lt;br /&gt;
== I '''metodi''' ==&lt;br /&gt;
sono operazioni che i vari oggetti supportano.&lt;br /&gt;
alcuni metodi, vedendo con la funzione dir(), iniziano e terminano con __ . Tali metodi, chiamati metodi speciali, non dovrebbero essere chiamati direttamente,&lt;br /&gt;
senza che ci sia una ragione specifica per farlo (ovvero: sapete quello che state facendo). In generale possono essere pensati come privati o riservati, anche se non &lt;br /&gt;
essendoci controlli di accesso come in altri linguaggi (public private del java o del c++ ad esempio) nessuno vieta di chiamarli.&lt;br /&gt;
&lt;br /&gt;
Ad esempio, il metodo __add__ delle stringhe è chiamato quando si fa la somma di due stringhe.&lt;br /&gt;
 ''&amp;quot;ciao&amp;quot; + &amp;quot; mondo&amp;quot;'' &lt;br /&gt;
chiama in realtà &lt;br /&gt;
 ''&amp;quot;ciao&amp;quot;.__add__(&amp;quot; mondo&amp;quot;)''&lt;br /&gt;
&lt;br /&gt;
''__ doc__'' ce l'hanno tutti gli oggetti (stringhe, interi...), e contiene una stringa di documentazione dell'oggetto. &lt;br /&gt;
&lt;br /&gt;
i metodi che iniziano per is servono per controllare se una certa proprietà della stringa in esame è vera:&lt;br /&gt;
es: &lt;br /&gt;
    ''messaggio.isalpha()''&lt;br /&gt;
mi dice se messaggio è o meno alfanumerico (composto solo da numeri e cifre, senza spazi, tab, ritorno carrello ecc ecc).&lt;br /&gt;
isalpha è un oggetto quindi ha le proprietà doc .&lt;br /&gt;
se io scrivo&lt;br /&gt;
    ''messaggio.isalpha.__doc__''&lt;br /&gt;
mi dice che fa.&lt;br /&gt;
&lt;br /&gt;
es:&lt;br /&gt;
    '' messaggio=”gigio”&lt;br /&gt;
    messaggio2= messaggio.upper()''&lt;br /&gt;
&lt;br /&gt;
es:&lt;br /&gt;
''TYPE(3)''&lt;br /&gt;
mi dice che variabile  è. se è intero o stringa oppure un complesso, un float o un tipo definito dall'utente.&lt;br /&gt;
Se io scrivo ''DIR(3)''&lt;br /&gt;
mi da tutta la lista dei metodi e delle proprietà degli int (dato che 3 è in intero)&lt;br /&gt;
'''&lt;br /&gt;
&lt;br /&gt;
Esistono stringhe, interi, float (numeri con virgola)booleano (che ha due valori, vero o falso, True e False)e i vari contenitori:&lt;br /&gt;
&lt;br /&gt;
== '''LE LISTE''' ==&lt;br /&gt;
&lt;br /&gt;
es. lo scaffale ha I pc, I pc sono oggetti (pc1,pc2...).Se voglio uno scaffale di pc senza dare I nomi a tutti gli oggetti, definisco lo scaffale.&lt;br /&gt;
Lo scaffale si chiama''' Lista'''  .si usano le parentesi quadre con oggetti separati da virgola&lt;br /&gt;
es.    '' a = [ “pc1” , “schermo rotto” , 2]&lt;br /&gt;
dir (scaffale)''&lt;br /&gt;
da la lista dei metodi, da qui si capisce che la lista è un oggetto.&lt;br /&gt;
Ad esempio:&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a la stringa &amp;quot;4&amp;quot;.&lt;br /&gt;
La lista, a differenza delle stringhe, è un oggetto mutabile, quindi la funzione append di fatto manipola la lista esistente per far spazio al nuovo oggetto da inserir&lt;br /&gt;
&lt;br /&gt;
Se faccio     ''print (“a”)''&lt;br /&gt;
mi da la lista degli oggetti più &amp;quot;4&amp;quot;&lt;br /&gt;
&lt;br /&gt;
Da notare che&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; mialista = []&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; mialista&lt;br /&gt;
  []&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; dir(a)&lt;br /&gt;
  ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__ge__', &lt;br /&gt;
   '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', &lt;br /&gt;
   '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__',&lt;br /&gt;
   '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__str__', 'append', 'count', 'extend', 'index', 'insert', &lt;br /&gt;
   'pop', 'remove', 'reverse', 'sort']&lt;br /&gt;
&lt;br /&gt;
Da qui vediamo che il risultato della funziona dir su una lista ritorna .. una lista.&lt;br /&gt;
&lt;br /&gt;
Vediamo come una lista può contenere qualsiasi oggetto, anche una lista o una tupla (vedi sotto)&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; mialista = [ (1,1,1), [2,2,2], 3, ([4,4,4],(4,4,4))]&lt;br /&gt;
&lt;br /&gt;
Questa è una lista di 4 oggetti, uno dei quali è una tupla, il secondo è una lista, il terzo un intero, il quarto una tupla contenente a sua volta una lista e una tupla.&lt;br /&gt;
&lt;br /&gt;
== '''TUPLE''' ==&lt;br /&gt;
&lt;br /&gt;
simile a una lista, è un contenitore di elementi. La tupla non è mutabile, per cui se definita con 4 oggetti non potrà mai contenerne 5 come non si può cambiare il&lt;br /&gt;
valore a uno degli oggetti&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miatupla = ( 1, 2,  &amp;quot;a&amp;quot; ,(1,2,3))&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miatupla&lt;br /&gt;
  (1, 2, 'a', (1, 2, 3))&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; len(miatupla)&lt;br /&gt;
  4&lt;br /&gt;
  &lt;br /&gt;
Dall'esempio vediamo come una tupla possa contenere al suo interno oggetti di vario tipo (tra cui una tupla stessa): a tal proposito&lt;br /&gt;
si vede che la lunghezza della tupla è 4 , infatti la tupla in essa contenuta - e che a sua volta contiene 3 oggetti - viene considerata&lt;br /&gt;
un unico oggetto (perchè difatto lo è.)&lt;br /&gt;
&lt;br /&gt;
Vediamo come si può accedere posizionalmente agli elementi della tupla (l'indice parte da zero)&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miatupla[0] # primo elemento&lt;br /&gt;
  1&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miatupla[2] # terzo elemento&lt;br /&gt;
  'a'&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; primo, secondo, terzo, quarto = miatupla  # scompatta la tupla in 4 variabili&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; terzo&lt;br /&gt;
  'a'&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; quarto&lt;br /&gt;
  (1, 2, 3)&lt;br /&gt;
&lt;br /&gt;
Inoltre, tentare di assegnare un nuovo valore a un elemento della tupla genera una eccezione&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miatupla[0] = 3&lt;br /&gt;
  Traceback (most recent call last):&lt;br /&gt;
    File &amp;quot;&amp;lt;stdin&amp;gt;&amp;quot;, line 1, in &amp;lt;module&amp;gt;&lt;br /&gt;
  TypeError: 'tuple' object does not support item assignment&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== '''DIZIONARI''' ==&lt;br /&gt;
&lt;br /&gt;
il dizionario si definisce con le parentesi graffe {chiave:valore, chiave:valore}&lt;br /&gt;
a[chiave]&lt;br /&gt;
da il valore associato alla chiave.&lt;br /&gt;
&lt;br /&gt;
Dizionari liste e tuple sono dele sequenze e sono iterable e si possono quindi scorrere.&lt;br /&gt;
&lt;br /&gt;
== '''If elif else''' ==&lt;br /&gt;
&lt;br /&gt;
  if condizione :&lt;br /&gt;
      ''statement1''&lt;br /&gt;
      ''statement2''&lt;br /&gt;
  ''statement3''&lt;br /&gt;
&lt;br /&gt;
Python supporta o tab o spazio, si decide quanti tab o spazi alla prima indentazione.&lt;br /&gt;
Di solito si usa 4 spazi.&lt;br /&gt;
Non c'è la graffa in pyton o I begin o gli end, si chiude e si apre un blocco indentando&lt;br /&gt;
Nell'esempio precedente, ''statement1'' e ''statement2'' vengono eseguiti solo se la condizione è vera, &lt;br /&gt;
mentre ''statement3'' viene eseguito sempre.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Esempio:&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; a=3&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; b=1&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; if a &amp;gt; b:&lt;br /&gt;
  ...     print (&amp;quot;a è maggiore di b&amp;quot;)&lt;br /&gt;
  ... elif a == b:&lt;br /&gt;
  ...     print (&amp;quot;a è uguale a b&amp;quot;)&lt;br /&gt;
  ... else:&lt;br /&gt;
  ...     print (&amp;quot;a è minore di b&amp;quot;)&lt;br /&gt;
  ... &lt;br /&gt;
  a è maggiore di b&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; &lt;br /&gt;
&lt;br /&gt;
in questo programma definisco due valori, a e b.&lt;br /&gt;
Chiedo al programma se a è maggiore di b di scrivere : a è maggiore di b, se a è uguale a b di scrivere che a è uguale a b e in tutte le altre condizioni (else) di scrivere che a è minore di b.&lt;br /&gt;
&lt;br /&gt;
	'''2.is, is not or, and,!='''&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; if a is 1:&lt;br /&gt;
  ...     print (“si”)&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; elif a is not 1:&lt;br /&gt;
  ...     print (“no”)&lt;br /&gt;
  no&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; if a is 1 and b is 3:&lt;br /&gt;
  ...     print (“si”)&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; if a is 3 or b is 3:&lt;br /&gt;
  ...     print (“okkei”)&lt;br /&gt;
  okkei&lt;br /&gt;
&lt;br /&gt;
'''!= è il diverso.'''&lt;br /&gt;
&lt;br /&gt;
Oltre ai classici test a volte siamo interessati a vedere se un particolare elemento è presente in una tupla, lista o dizionario&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miodizionario = { 'primo': 1, 'secondo': &amp;quot;golem&amp;quot;, 'terzo': [1,2,3] }&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; if &amp;quot;primo&amp;quot; in miodizionario: &lt;br /&gt;
  ...     print 'yeah'&lt;br /&gt;
  ... &lt;br /&gt;
  yeah&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Vediamo come l'operatore ''in'' cerca nelle chiavi del dizionario&lt;br /&gt;
Analogamente possiamo farlo nelle liste&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; mialista = [1,2,3]&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; if 4 not in mialista:&lt;br /&gt;
  ...     print &amp;quot;non c'è&amp;quot;&lt;br /&gt;
  ... &lt;br /&gt;
  non c'è&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
L'esempio precedente mostra anche che l'operazione può essere negata usando ''not''&lt;br /&gt;
&lt;br /&gt;
== '''append, insert''' ==&lt;br /&gt;
&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a il 4.&lt;br /&gt;
Se faccio print (“a”)&lt;br /&gt;
mi da la lista degli oggetti più il 4.&lt;br /&gt;
&lt;br /&gt;
con '''insert''' devo inserire anche la posizione&lt;br /&gt;
    ''a.insert(2,34)''&lt;br /&gt;
mette il 34 in posizione 2&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''for''' ==&lt;br /&gt;
&lt;br /&gt;
specifica un ciclo, fa le cose tante volte fino ad una condizione.&lt;br /&gt;
For variabile in una sequenza di qualche tipo.&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miatupla = ( 1, 2,  &amp;quot;a&amp;quot; ,(1,2,3))&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; for variabile in miatupla:&lt;br /&gt;
  ...     print &amp;quot;nella tupla: &amp;quot;,&lt;br /&gt;
  ...     print variabile&lt;br /&gt;
  ... &lt;br /&gt;
  nella tupla:  1&lt;br /&gt;
  nella tupla:  2&lt;br /&gt;
  nella tupla:  a&lt;br /&gt;
  nella tupla:  (1, 2, 3)&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
In caso volessi, nel ciclo, sapere &amp;quot;a che punto&amp;quot; della tupla (o della sequenza, in generale a che punto dell' '''iterable''') sono:&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; for indice, variabile in enumerate(miatupla):&lt;br /&gt;
  ...     print &amp;quot;elemento&amp;quot;,&lt;br /&gt;
  ...     print indice&lt;br /&gt;
  ...     print variabile&lt;br /&gt;
  ... &lt;br /&gt;
  elemento 0&lt;br /&gt;
  1&lt;br /&gt;
  elemento 1&lt;br /&gt;
  2&lt;br /&gt;
  elemento 2&lt;br /&gt;
  a&lt;br /&gt;
  elemento 3&lt;br /&gt;
  (1, 2, 3)&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; &lt;br /&gt;
&lt;br /&gt;
Iterando su un dizionario, che è un iterable, vengono resistuite le chiave, non i valori.&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miodizionario = { 'primo': 1, 'secondo': &amp;quot;golem&amp;quot;, 'terzo': [1,2,3] }&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; for chiave in miodizionario:&lt;br /&gt;
  ...     print chiave,&lt;br /&gt;
  ...     print &amp;quot;:&amp;quot;,&lt;br /&gt;
  ...     print miodizionario[chiave]&lt;br /&gt;
  ... &lt;br /&gt;
  terzo : [1, 2, 3]&lt;br /&gt;
  primo : 1&lt;br /&gt;
  secondo : golem&lt;br /&gt;
&lt;br /&gt;
Vediamo come gli elementi del dizionario non ci vengono resistuiti in un particolare ordine, anzi, non ci soono garanzie a riguardo&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; dir (miodizionario)&lt;br /&gt;
  ['__class__', '__cmp__', '__contains__', '__delattr__', '__delitem__', '__doc__', '__eq__', '__ge__',&lt;br /&gt;
   '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', &lt;br /&gt;
   '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', &lt;br /&gt;
   '__str__', 'clear', 'copy', 'fromkeys', 'get', 'has_key', 'items', 'iteritems', 'iterkeys', &lt;br /&gt;
   'itervalues', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']&lt;br /&gt;
&lt;br /&gt;
se vogliamo iterare su i valori e non sulle chiavi dobbiamo usare il metodo '''itervalues''' degli oggetti dizionario:&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; for valore in  miodizionario.itervalues():&lt;br /&gt;
  ...     print valore&lt;br /&gt;
  ... &lt;br /&gt;
  [1, 2, 3]&lt;br /&gt;
  1&lt;br /&gt;
  golem&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== '''xrange''' ==&lt;br /&gt;
&lt;br /&gt;
xrange è un iterable di dieci elementi con il primo valore uguale a 0 .E' una lista ma non ha le proprietà di una lista.&lt;br /&gt;
se io voglio fare un for da uno a dieci (cioè la somma da uno a 10)&lt;br /&gt;
&lt;br /&gt;
es:     ''for I xrange(10)&lt;br /&gt;
               print I''&lt;br /&gt;
lui stampa&lt;br /&gt;
''1&lt;br /&gt;
2&lt;br /&gt;
3&lt;br /&gt;
4&lt;br /&gt;
5&lt;br /&gt;
6&lt;br /&gt;
7&lt;br /&gt;
8&lt;br /&gt;
9&lt;br /&gt;
10''&lt;br /&gt;
&lt;br /&gt;
== '''range''' ==&lt;br /&gt;
&lt;br /&gt;
ha la stessa funzione di xrange, ovvero servire da iterable su N numeri, però ritorna non un oggetto di tipo xrange ma una lista.&lt;br /&gt;
E' più lento di xrange&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; print range(10)&lt;br /&gt;
  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== '''len''' ==&lt;br /&gt;
&lt;br /&gt;
    ''len (a)''&lt;br /&gt;
da la lunghezza della stringa&lt;br /&gt;
&lt;br /&gt;
== '''enumerate''' ==&lt;br /&gt;
&lt;br /&gt;
se io ho una lista di tre elmenti&lt;br /&gt;
''a=[“ciao”,”bel”, “mondo”]''&lt;br /&gt;
&lt;br /&gt;
''for I, elem in enumerate(a):&lt;br /&gt;
     print str(I) + “:” + elem&lt;br /&gt;
''&lt;br /&gt;
da la posizione corrente di ogni elemento.&lt;br /&gt;
''0:ciao&lt;br /&gt;
1:bel&lt;br /&gt;
2:mondo''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''raw_input''' ==&lt;br /&gt;
&lt;br /&gt;
dai il valore.&lt;br /&gt;
''Base= raw_input (“inserisce la base:”)&lt;br /&gt;
esponente=raw_input (“inserisci l'/ esponente”)''&lt;br /&gt;
&lt;br /&gt;
ti chiede il valore di base ed esponente.&lt;br /&gt;
&lt;br /&gt;
== '''Int''' ==&lt;br /&gt;
&lt;br /&gt;
forza il fatto che quel valore sia un intero.&lt;br /&gt;
''&lt;br /&gt;
Es:base=int(base)&lt;br /&gt;
  result=int(result)''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''UPPER,LOWER,CAPITALIZE''' ==&lt;br /&gt;
&lt;br /&gt;
'''capitalize''' è un comando che sulla la stringa su cui viene applicato ,prende la prima lettera dopo gli spazi e ci mette la maiuscola&lt;br /&gt;
&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.capitalize()''&lt;br /&gt;
    ''Ciao mondo''&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.title()&lt;br /&gt;
    Ciao Mondo''&lt;br /&gt;
&lt;br /&gt;
'''LOWER:''' prende la striga e emette tutto minuscolo&lt;br /&gt;
'''UPPER:''' il contrario di lower&lt;br /&gt;
&lt;br /&gt;
== '''ESEMPIO DELLA SERATA:''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Calcolo di una potenza.&lt;br /&gt;
&lt;br /&gt;
    ''&lt;br /&gt;
    base= raw_input (“inserisce la base:”)&lt;br /&gt;
    esponente=raw_input ('inserisci l\' esponente')&lt;br /&gt;
&lt;br /&gt;
    base=int(base)&lt;br /&gt;
    result=int(result)&lt;br /&gt;
&lt;br /&gt;
    result=1&lt;br /&gt;
    for i in xrange(esponente):&lt;br /&gt;
         result = result * base&lt;br /&gt;
    print result''&lt;br /&gt;
&lt;br /&gt;
il [http://docs.python.org/lib/built-in-funcs.html built-in] int() è necessario, dato che tutto quello che proviene dalla tastiera viene acquisito da raw_input() come stringa. Dato che dobbiamo usarli come interi, occorre effettuare un cast, ovvero&lt;br /&gt;
una trasformazione di tipo, da stringa a intero.&lt;br /&gt;
E' interessante notare che int() non cerca di fare i miracoli: provate a vedere cosa succede se cercate di convertire &amp;quot;awlerorj&amp;quot; in int!&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3743</id>
		<title>Python Lezione 4 Giugno 2008</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3743"/>
		<updated>2008-06-10T12:15:32Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: /* '''If elif else''' */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Python ==&lt;br /&gt;
[http://www.python.it/ Python] è un linguaggio di programmazione [http://it.wikipedia.org/wiki/Interprete_(informatica) interpretato].&lt;br /&gt;
Il linuaggio interpretato è simile agli altri linguaggi in circolazione ma, invece di essere trasformato direttamente in codice binario dal meccanismo automatico, viene interpretato da questo e poi mandato all'hardware.&lt;br /&gt;
Un linguaggio interpretato non ha bisogno di essere ricompilato: il codice scritto viene interpretato da un interprete a run-time (tempo di esecuzione) e tradotto al volo nel linguaggio macchina.&lt;br /&gt;
Quindi i programmi python possono girare su qualsiasi hardware e sistema operativo su cui è stato portato l'interprete. Ovviamente, questa cosa si paga sul tempo di esecuzione pure: l'approccio ha si i suoi vantaggi, ma rispetto a un linguaggio compilato direttamente in linguaggio macchina per creare un eseguibile, python e gli altri liguaggi interpretati risultano essere più lenti.&lt;br /&gt;
&lt;br /&gt;
Esistono vari interpreti: [http://www.python.org Cpython], o classic python, è l'interprete &amp;quot;ufficiale&amp;quot;, scritto in C e disponibile per linux, mac e windows.&lt;br /&gt;
[http://www.jython.org/Project/ Jython] è un interprete scritto al 100% in Java, e si interfaccia strettamente ai programmi e alla libreria Java, &lt;br /&gt;
[http://www.codeplex.com/Wiki/View.aspx?ProjectName=IronPython IronPython] è un interprete python che gira sulla piattaforma .NET mentre &lt;br /&gt;
[http://codespeak.net/pypy/dist/pypy/doc/home.html PyPy] è (anche) un interprete python scritto in.. python&lt;br /&gt;
&lt;br /&gt;
La prima riga di ogni script python deve iniziare con #!/usr/bin/env python&lt;br /&gt;
&lt;br /&gt;
il #! del file fa capire al sistema operativo (solo su sistemi posix, quindi unix/linux) che quello non è un file di testo ma un eseguibile da eseguire con l'inteprete python.&lt;br /&gt;
&lt;br /&gt;
== COMMENTI ==&lt;br /&gt;
&lt;br /&gt;
: sono righe che l'interprete salta e non legge &lt;br /&gt;
es: &lt;br /&gt;
    ''# stampa:”hello word”''&lt;br /&gt;
&lt;br /&gt;
== PRINT ==&lt;br /&gt;
Lo statement [http://docs.python.org/ref/print.html print] valuta tutte le espressioni presenti e quindi le stampa a video.&lt;br /&gt;
L'espressione da valutare può essere anche un semplice numero o una semplice stringa&lt;br /&gt;
&lt;br /&gt;
    ''print 3''&lt;br /&gt;
stampa 3, e anche se scrivo&lt;br /&gt;
    '' print “3”''&lt;br /&gt;
stampa lo stesso anche se abbiamo passato prima un intero, poi una stringa.&lt;br /&gt;
Questo è normale, perchè il numero &amp;quot;tre&amp;quot; viene rappresentato dal simbolo 3 nel sistema decimale.&lt;br /&gt;
&lt;br /&gt;
Invece, se scrivo&lt;br /&gt;
    ''print 3+2''&lt;br /&gt;
otteniamo a video 5: l'inteprete ha valutato l'espressione, ha eseguito la somma e stampato il situlato.&lt;br /&gt;
Mentre se scriviamo&lt;br /&gt;
    ''print “3+2”''&lt;br /&gt;
il risolutato è &lt;br /&gt;
    ''3+2''&lt;br /&gt;
in quanto abbiamo passato la stringa composta dal carattere 3, dal simbolo + e dal carattere 2.&lt;br /&gt;
&lt;br /&gt;
Le variabili in python non devono essere dichiarate: esistono dalla prima volta in cui gli viene assegnato un valore&lt;br /&gt;
    ''messaggio=”hello world”''&lt;br /&gt;
    ''print messaggio''&lt;br /&gt;
se questo programma viene eseguito il risultatato sarà:&lt;br /&gt;
''hello world''&lt;br /&gt;
l'interprete valuta l'espressione ''messaggio'' e stampa il suo contenuto&lt;br /&gt;
&lt;br /&gt;
== Errori e Eccezioni ==&lt;br /&gt;
&lt;br /&gt;
Commentando l'assegnamento di messaggio, vediamo che l'interprete genera un errore:&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
  jdoe@waste-bin ~ $ python&lt;br /&gt;
  Python 2.5.2 (r252:60911, May 24 2008, 15:28:31) &lt;br /&gt;
  [GCC 4.2.4 (Gentoo 4.2.4 p1.0)] on linux2&lt;br /&gt;
  Type &amp;quot;help&amp;quot;, &amp;quot;copyright&amp;quot;, &amp;quot;credits&amp;quot; or &amp;quot;license&amp;quot; for more information.&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; print messaggio&lt;br /&gt;
  Traceback (most recent call last):&lt;br /&gt;
    File &amp;quot;&amp;lt;stdin&amp;gt;&amp;quot;, line 1, in &amp;lt;module&amp;gt;&lt;br /&gt;
  NameError: name 'messaggio' is not defined&lt;br /&gt;
&lt;br /&gt;
NameError è una eccezione. Vedremo più avanti come queste situazioni di errore possono essere ''catturate'' e ''gestite'' appositamente, sia&lt;br /&gt;
per tentare di risolvere il problema che per migliorare il feedback che il nostro programma da all'utente. Vedremo anche come&lt;br /&gt;
la gestione delle eccezioni è parte della programmazione normale di un programma, ovvero non è sempre legata a una situazione di errore.&lt;br /&gt;
&lt;br /&gt;
Un altro esempio, tendando di sommare mele e pere:&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; print 1 + &amp;quot;a&amp;quot;&lt;br /&gt;
  Traceback (most recent call last):&lt;br /&gt;
    File &amp;quot;&amp;lt;stdin&amp;gt;&amp;quot;, line 1, in &amp;lt;module&amp;gt;&lt;br /&gt;
  TypeError: unsupported operand type(s) for +: 'int' and 'str'&lt;br /&gt;
&lt;br /&gt;
Vediamo che a questo giro l'eccezione lanciata è ValueError.&lt;br /&gt;
&lt;br /&gt;
== LE STRINGHE ==&lt;br /&gt;
Gli oggetti di tipo stringa supportano svariati metodi e proprietà. E' da notare che le stringhe sono immutabili.&lt;br /&gt;
Se una stringa viene dichiarata la seconda volta, quella precedente viene buttata, non viene modificata per fare spazio alla nuova.&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
    messaggio=”ciao mondo”&lt;br /&gt;
    print messaggio''&lt;br /&gt;
stampa&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
In Python non si possono sommare cose diverse, o meglio, lo posso fare solo se è definita una conversione tra i due tipo.&lt;br /&gt;
Le stringhe supportano anche alcuni operatori base:&lt;br /&gt;
    ''print messaggio*2'' &lt;br /&gt;
l'esecuzione darà&lt;br /&gt;
    ''messaggio messaggio&lt;br /&gt;
''&lt;br /&gt;
esempio:&lt;br /&gt;
     ''Print “ciao”+” mondo”''&lt;br /&gt;
lo eseguo e mi darà:&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
== '''Funzione DIR''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
    dir(messaggio)''&lt;br /&gt;
a questo punto il programma da una serie di caratteri incomprensibili.&lt;br /&gt;
Praticamente dà i '''metodi''' che suporta la stringa messaggio.&lt;br /&gt;
&lt;br /&gt;
== I '''metodi''' ==&lt;br /&gt;
sono operazioni che i vari oggetti supportano.&lt;br /&gt;
alcuni metodi, vedendo con la funzione dir(), iniziano e terminano con __ . Tali metodi, chiamati metodi speciali, non dovrebbero essere chiamati direttamente,&lt;br /&gt;
senza che ci sia una ragione specifica per farlo (ovvero: sapete quello che state facendo). In generale possono essere pensati come privati o riservati, anche se non &lt;br /&gt;
essendoci controlli di accesso come in altri linguaggi (public private del java o del c++ ad esempio) nessuno vieta di chiamarli.&lt;br /&gt;
&lt;br /&gt;
Ad esempio, il metodo __add__ delle stringhe è chiamato quando si fa la somma di due stringhe.&lt;br /&gt;
 ''&amp;quot;ciao&amp;quot; + &amp;quot; mondo&amp;quot;'' &lt;br /&gt;
chiama in realtà &lt;br /&gt;
 ''&amp;quot;ciao&amp;quot;.__add__(&amp;quot; mondo&amp;quot;)''&lt;br /&gt;
&lt;br /&gt;
''__ doc__'' ce l'hanno tutti gli oggetti (stringhe, interi...), e contiene una stringa di documentazione dell'oggetto. &lt;br /&gt;
&lt;br /&gt;
i metodi che iniziano per is servono per controllare se una certa proprietà della stringa in esame è vera:&lt;br /&gt;
es: &lt;br /&gt;
    ''messaggio.isalpha()''&lt;br /&gt;
mi dice se messaggio è o meno alfanumerico (composto solo da numeri e cifre, senza spazi, tab, ritorno carrello ecc ecc).&lt;br /&gt;
isalpha è un oggetto quindi ha le proprietà doc .&lt;br /&gt;
se io scrivo&lt;br /&gt;
    ''messaggio.isalpha.__doc__''&lt;br /&gt;
mi dice che fa.&lt;br /&gt;
&lt;br /&gt;
es:&lt;br /&gt;
    '' messaggio=”gigio”&lt;br /&gt;
    messaggio2= messaggio.upper()''&lt;br /&gt;
&lt;br /&gt;
es:&lt;br /&gt;
''TYPE(3)''&lt;br /&gt;
mi dice che variabile  è. se è intero o stringa oppure un complesso, un float o un tipo definito dall'utente.&lt;br /&gt;
Se io scrivo ''DIR(3)''&lt;br /&gt;
mi da tutta la lista dei metodi e delle proprietà degli int (dato che 3 è in intero)&lt;br /&gt;
'''&lt;br /&gt;
&lt;br /&gt;
Esistono stringhe, interi, float (numeri con virgola)booleano (che ha due valori, vero o falso, True e False)e i vari contenitori:&lt;br /&gt;
&lt;br /&gt;
== '''LE LISTE''' ==&lt;br /&gt;
&lt;br /&gt;
es. lo scaffale ha I pc, I pc sono oggetti (pc1,pc2...).Se voglio uno scaffale di pc senza dare I nomi a tutti gli oggetti, definisco lo scaffale.&lt;br /&gt;
Lo scaffale si chiama''' Lista'''  .si usano le parentesi quadre con oggetti separati da virgola&lt;br /&gt;
es.    '' a = [ “pc1” , “schermo rotto” , 2]&lt;br /&gt;
dir (scaffale)''&lt;br /&gt;
da la lista dei metodi, da qui si capisce che la lista è un oggetto.&lt;br /&gt;
Ad esempio:&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a la stringa &amp;quot;4&amp;quot;.&lt;br /&gt;
La lista, a differenza delle stringhe, è un oggetto mutabile, quindi la funzione append di fatto manipola la lista esistente per far spazio al nuovo oggetto da inserir&lt;br /&gt;
&lt;br /&gt;
Se faccio     ''print (“a”)''&lt;br /&gt;
mi da la lista degli oggetti più &amp;quot;4&amp;quot;&lt;br /&gt;
&lt;br /&gt;
Da notare che&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; mialista = []&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; mialista&lt;br /&gt;
  []&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; dir(a)&lt;br /&gt;
  ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__ge__', &lt;br /&gt;
   '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', &lt;br /&gt;
   '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__',&lt;br /&gt;
   '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__str__', 'append', 'count', 'extend', 'index', 'insert', &lt;br /&gt;
   'pop', 'remove', 'reverse', 'sort']&lt;br /&gt;
&lt;br /&gt;
Da qui vediamo che il risultato della funziona dir su una lista ritorna .. una lista.&lt;br /&gt;
&lt;br /&gt;
Vediamo come una lista può contenere qualsiasi oggetto, anche una lista o una tupla (vedi sotto)&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; mialista = [ (1,1,1), [2,2,2], 3, ([4,4,4],(4,4,4))]&lt;br /&gt;
&lt;br /&gt;
Questa è una lista di 4 oggetti, uno dei quali è una tupla, il secondo è una lista, il terzo un intero, il quarto una tupla contenente a sua volta una lista e una tupla.&lt;br /&gt;
&lt;br /&gt;
== '''TUPLE''' ==&lt;br /&gt;
&lt;br /&gt;
simile a una lista, è un contenitore di elementi. La tupla non è mutabile, per cui se definita con 4 oggetti non potrà mai contenerne 5 come non si può cambiare il&lt;br /&gt;
valore a uno degli oggetti&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miatupla = ( 1, 2,  &amp;quot;a&amp;quot; ,(1,2,3))&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miatupla&lt;br /&gt;
  (1, 2, 'a', (1, 2, 3))&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; len(miatupla)&lt;br /&gt;
  4&lt;br /&gt;
  &lt;br /&gt;
Dall'esempio vediamo come una tupla possa contenere al suo interno oggetti di vario tipo (tra cui una tupla stessa): a tal proposito&lt;br /&gt;
si vede che la lunghezza della tupla è 4 , infatti la tupla in essa contenuta - e che a sua volta contiene 3 oggetti - viene considerata&lt;br /&gt;
un unico oggetto (perchè difatto lo è.)&lt;br /&gt;
&lt;br /&gt;
Vediamo come si può accedere posizionalmente agli elementi della tupla (l'indice parte da zero)&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miatupla[0] # primo elemento&lt;br /&gt;
  1&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miatupla[2] # terzo elemento&lt;br /&gt;
  'a'&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; primo, secondo, terzo, quarto = miatupla  # scompatta la tupla in 4 variabili&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; terzo&lt;br /&gt;
  'a'&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; quarto&lt;br /&gt;
  (1, 2, 3)&lt;br /&gt;
&lt;br /&gt;
Inoltre, tentare di assegnare un nuovo valore a un elemento della tupla genera una eccezione&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miatupla[0] = 3&lt;br /&gt;
  Traceback (most recent call last):&lt;br /&gt;
    File &amp;quot;&amp;lt;stdin&amp;gt;&amp;quot;, line 1, in &amp;lt;module&amp;gt;&lt;br /&gt;
  TypeError: 'tuple' object does not support item assignment&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== '''DIZIONARI''' ==&lt;br /&gt;
&lt;br /&gt;
il dizionario si definisce con le parentesi graffe {chiave:valore, chiave:valore}&lt;br /&gt;
a[chiave]&lt;br /&gt;
da il valore associato alla chiave.&lt;br /&gt;
&lt;br /&gt;
Dizionari liste e tuple sono dele sequenze e sono iterable e si possono quindi scorrere.&lt;br /&gt;
&lt;br /&gt;
== '''If elif else''' ==&lt;br /&gt;
&lt;br /&gt;
  if condizione :&lt;br /&gt;
      ''statement1''&lt;br /&gt;
      ''statement2''&lt;br /&gt;
  ''statement3''&lt;br /&gt;
&lt;br /&gt;
Python supporta o tab o spazio, si decide quanti tab o spazi alla prima indentazione.&lt;br /&gt;
Di solito si usa 4 spazi.&lt;br /&gt;
Non c'è la graffa in pyton o I begin o gli end, si chiude e si apre un blocco indentando&lt;br /&gt;
Nell'esempio precedente, ''statement1'' e ''statement2'' vengono eseguiti solo se la condizione è vera, &lt;br /&gt;
mentre ''statement3'' viene eseguito sempre.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Esempio:&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; a=3&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; b=1&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; if a &amp;gt; b:&lt;br /&gt;
  ...     print (&amp;quot;a è maggiore di b&amp;quot;)&lt;br /&gt;
  ... elif a == b:&lt;br /&gt;
  ...     print (&amp;quot;a è uguale a b&amp;quot;)&lt;br /&gt;
  ... else:&lt;br /&gt;
  ...     print (&amp;quot;a è minore di b&amp;quot;)&lt;br /&gt;
  ... &lt;br /&gt;
  a è maggiore di b&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; &lt;br /&gt;
&lt;br /&gt;
in questo programma definisco due valori, a e b.&lt;br /&gt;
Chiedo al programma se a è maggiore di b di scrivere : a è maggiore di b, se a è uguale a b di scrivere che a è uguale a b e in tutte le altre condizioni (else) di scrivere che a è minore di b.&lt;br /&gt;
&lt;br /&gt;
	'''2.is, is not or, and,!='''&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; if a is 1:&lt;br /&gt;
  ...     print (“si”)&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; elif a is not 1:&lt;br /&gt;
  ...     print (“no”)&lt;br /&gt;
  no&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; if a is 1 and b is 3:&lt;br /&gt;
  ...     print (“si”)&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; if a is 3 or b is 3:&lt;br /&gt;
  ...     print (“okkei”)&lt;br /&gt;
  okkei&lt;br /&gt;
&lt;br /&gt;
'''!= è il diverso.'''&lt;br /&gt;
&lt;br /&gt;
Oltre ai classici test a volte siamo interessati a vedere se un particolare elemento è presente in una tupla, lista o dizionario&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miodizionario = { 'primo': 1, 'secondo': &amp;quot;golem&amp;quot;, 'terzo': [1,2,3] }&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; if &amp;quot;primo&amp;quot; in miodizionario: &lt;br /&gt;
  ...     print 'yeah'&lt;br /&gt;
  ... &lt;br /&gt;
  yeah&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Vediamo come l'operatore ''in'' cerca nelle chiavi del dizionario&lt;br /&gt;
Analogamente possiamo farlo nelle liste&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; mialista = [1,2,3]&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; if 4 not in mialista:&lt;br /&gt;
  ...     print &amp;quot;non c'è&amp;quot;&lt;br /&gt;
  ... &lt;br /&gt;
  non c'è&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
L'esempio precedente mostra anche che l'operazione può essere negata usando ''not''&lt;br /&gt;
&lt;br /&gt;
== '''append, insert''' ==&lt;br /&gt;
&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a il 4.&lt;br /&gt;
Se faccio print (“a”)&lt;br /&gt;
mi da la lista degli oggetti più il 4.&lt;br /&gt;
&lt;br /&gt;
con '''insert''' devo inserire anche la posizione&lt;br /&gt;
    ''a.insert(2,34)''&lt;br /&gt;
mette il 34 in posizione 2&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''for''' ==&lt;br /&gt;
&lt;br /&gt;
specifica un ciclo, fa le cose tante volte fino ad una condizione.&lt;br /&gt;
For variabile in una sequenza di qualche tipo.&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miatupla = ( 1, 2,  &amp;quot;a&amp;quot; ,(1,2,3))&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; for variabile in miatupla:&lt;br /&gt;
  ...     print &amp;quot;nella tupla: &amp;quot;,&lt;br /&gt;
  ...     print variabile&lt;br /&gt;
  ... &lt;br /&gt;
  nella tupla:  1&lt;br /&gt;
  nella tupla:  2&lt;br /&gt;
  nella tupla:  a&lt;br /&gt;
  nella tupla:  (1, 2, 3)&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
In caso volessi, nel ciclo, sapere &amp;quot;a che punto&amp;quot; della tupla (o della sequenza, in generale a che punto dell' '''iterable''') sono:&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; for indice, variabile in enumerate(miatupla):&lt;br /&gt;
  ...     print &amp;quot;elemento&amp;quot;,&lt;br /&gt;
  ...     print indice&lt;br /&gt;
  ...     print variabile&lt;br /&gt;
  ... &lt;br /&gt;
  elemento 0&lt;br /&gt;
  1&lt;br /&gt;
  elemento 1&lt;br /&gt;
  2&lt;br /&gt;
  elemento 2&lt;br /&gt;
  a&lt;br /&gt;
  elemento 3&lt;br /&gt;
  (1, 2, 3)&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; &lt;br /&gt;
&lt;br /&gt;
Iterando su un dizionario, che è un iterable, vengono resistuite le chiave, non i valori.&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miodizionario = { 'primo': 1, 'secondo': &amp;quot;golem&amp;quot;, 'terzo': [1,2,3] }&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; for chiave in miodizionario:&lt;br /&gt;
  ...     print chiave,&lt;br /&gt;
  ...     print &amp;quot;:&amp;quot;,&lt;br /&gt;
  ...     print miodizionario[chiave]&lt;br /&gt;
  ... &lt;br /&gt;
  terzo : [1, 2, 3]&lt;br /&gt;
  primo : 1&lt;br /&gt;
  secondo : golem&lt;br /&gt;
&lt;br /&gt;
Vediamo come gli elementi del dizionario non ci vengono resistuiti in un particolare ordine, anzi, non ci soono garanzie a riguardo&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; dir (miodizionario)&lt;br /&gt;
  ['__class__', '__cmp__', '__contains__', '__delattr__', '__delitem__', '__doc__', '__eq__', '__ge__',&lt;br /&gt;
   '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', &lt;br /&gt;
   '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', &lt;br /&gt;
   '__str__', 'clear', 'copy', 'fromkeys', 'get', 'has_key', 'items', 'iteritems', 'iterkeys', &lt;br /&gt;
   'itervalues', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']&lt;br /&gt;
&lt;br /&gt;
se vogliamo iterare su i valori e non sulle chiavi dobbiamo usare il metodo '''itervalues''' degli oggetti dizionario:&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; for valore in  miodizionario.itervalues():&lt;br /&gt;
  ...     print valore&lt;br /&gt;
  ... &lt;br /&gt;
  [1, 2, 3]&lt;br /&gt;
  1&lt;br /&gt;
  golem&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== '''xrange''' ==&lt;br /&gt;
&lt;br /&gt;
xrange è un iterable di dieci elementi con il primo valore uguale a 0 .E' una lista ma non ha le proprietà di una lista.&lt;br /&gt;
se io voglio fare un for da uno a dieci (cioè la somma da uno a 10)&lt;br /&gt;
&lt;br /&gt;
es:     ''for I xrange(10)&lt;br /&gt;
               print I''&lt;br /&gt;
lui stampa&lt;br /&gt;
''1&lt;br /&gt;
2&lt;br /&gt;
3&lt;br /&gt;
4&lt;br /&gt;
5&lt;br /&gt;
6&lt;br /&gt;
7&lt;br /&gt;
8&lt;br /&gt;
9&lt;br /&gt;
10''&lt;br /&gt;
&lt;br /&gt;
== '''range''' ==&lt;br /&gt;
&lt;br /&gt;
ha la stessa funzione di xrange, ovvero servire da iterable su N numeri, però ritorna non un oggetto di tipo xrange ma una lista.&lt;br /&gt;
E' più lento di xrange&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; print range(10)&lt;br /&gt;
  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== '''len''' ==&lt;br /&gt;
&lt;br /&gt;
    ''len (a)''&lt;br /&gt;
da la lunghezza della stringa&lt;br /&gt;
&lt;br /&gt;
== '''enumerate''' ==&lt;br /&gt;
&lt;br /&gt;
se io ho una lista di tre elmenti&lt;br /&gt;
''a=[“ciao”,”bel”, “mondo”]''&lt;br /&gt;
&lt;br /&gt;
''for I, elem in enumerate(a):&lt;br /&gt;
     print str(I) + “:” + elem&lt;br /&gt;
''&lt;br /&gt;
da la posizione corrente di ogni elemento.&lt;br /&gt;
''0:ciao&lt;br /&gt;
1:bel&lt;br /&gt;
2:mondo''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''raw_input''' ==&lt;br /&gt;
&lt;br /&gt;
dai il valore.&lt;br /&gt;
''Base= raw_input (“inserisce la base:”)&lt;br /&gt;
esponente=raw_input (“inserisci l'/ esponente”)''&lt;br /&gt;
&lt;br /&gt;
ti chiede il valore di base ed esponente.&lt;br /&gt;
&lt;br /&gt;
== '''Int''' ==&lt;br /&gt;
&lt;br /&gt;
forza il fatto che quel valore sia un intero.&lt;br /&gt;
''&lt;br /&gt;
Es:base=int(base)&lt;br /&gt;
  result=int(result)''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''UPPER,LOWER,CAPITALIZE''' ==&lt;br /&gt;
&lt;br /&gt;
'''capitalize''' è un comando che sulla la stringa su cui viene applicato ,prende la prima lettera dopo gli spazi e ci mette la maiuscola&lt;br /&gt;
&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.capitalize()''&lt;br /&gt;
    ''Ciao mondo''&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.title()&lt;br /&gt;
    Ciao Mondo''&lt;br /&gt;
&lt;br /&gt;
'''LOWER:''' prende la striga e emette tutto minuscolo&lt;br /&gt;
'''UPPER:''' il contrario di lower&lt;br /&gt;
&lt;br /&gt;
== '''ESEMPIO DELLA SERATA:''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Calcolo di una potenza.&lt;br /&gt;
&lt;br /&gt;
    ''&lt;br /&gt;
    base= raw_input (“inserisce la base:”)&lt;br /&gt;
    esponente=raw_input ('inserisci l\' esponente')&lt;br /&gt;
&lt;br /&gt;
    base=int(base)&lt;br /&gt;
    result=int(result)&lt;br /&gt;
&lt;br /&gt;
    result=1&lt;br /&gt;
    for i in xrange(esponente):&lt;br /&gt;
         result = result * base&lt;br /&gt;
    print result''&lt;br /&gt;
&lt;br /&gt;
il [http://docs.python.org/lib/built-in-funcs.html built-in] int() è necessario, dato che tutto quello che proviene dalla tastiera viene acquisito da raw_input() come stringa. Dato che dobbiamo usarli come interi, occorre effettuare un cast, ovvero&lt;br /&gt;
una trasformazione di tipo, da stringa a intero.&lt;br /&gt;
E' interessante notare che int() non cerca di fare i miracoli: provate a vedere cosa succede se cercate di convertire &amp;quot;awlerorj&amp;quot; in int!&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3742</id>
		<title>Python Lezione 4 Giugno 2008</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3742"/>
		<updated>2008-06-10T12:04:44Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: /* '''DIZIONARI''' */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Python ==&lt;br /&gt;
[http://www.python.it/ Python] è un linguaggio di programmazione [http://it.wikipedia.org/wiki/Interprete_(informatica) interpretato].&lt;br /&gt;
Il linuaggio interpretato è simile agli altri linguaggi in circolazione ma, invece di essere trasformato direttamente in codice binario dal meccanismo automatico, viene interpretato da questo e poi mandato all'hardware.&lt;br /&gt;
Un linguaggio interpretato non ha bisogno di essere ricompilato: il codice scritto viene interpretato da un interprete a run-time (tempo di esecuzione) e tradotto al volo nel linguaggio macchina.&lt;br /&gt;
Quindi i programmi python possono girare su qualsiasi hardware e sistema operativo su cui è stato portato l'interprete. Ovviamente, questa cosa si paga sul tempo di esecuzione pure: l'approccio ha si i suoi vantaggi, ma rispetto a un linguaggio compilato direttamente in linguaggio macchina per creare un eseguibile, python e gli altri liguaggi interpretati risultano essere più lenti.&lt;br /&gt;
&lt;br /&gt;
Esistono vari interpreti: [http://www.python.org Cpython], o classic python, è l'interprete &amp;quot;ufficiale&amp;quot;, scritto in C e disponibile per linux, mac e windows.&lt;br /&gt;
[http://www.jython.org/Project/ Jython] è un interprete scritto al 100% in Java, e si interfaccia strettamente ai programmi e alla libreria Java, &lt;br /&gt;
[http://www.codeplex.com/Wiki/View.aspx?ProjectName=IronPython IronPython] è un interprete python che gira sulla piattaforma .NET mentre &lt;br /&gt;
[http://codespeak.net/pypy/dist/pypy/doc/home.html PyPy] è (anche) un interprete python scritto in.. python&lt;br /&gt;
&lt;br /&gt;
La prima riga di ogni script python deve iniziare con #!/usr/bin/env python&lt;br /&gt;
&lt;br /&gt;
il #! del file fa capire al sistema operativo (solo su sistemi posix, quindi unix/linux) che quello non è un file di testo ma un eseguibile da eseguire con l'inteprete python.&lt;br /&gt;
&lt;br /&gt;
== COMMENTI ==&lt;br /&gt;
&lt;br /&gt;
: sono righe che l'interprete salta e non legge &lt;br /&gt;
es: &lt;br /&gt;
    ''# stampa:”hello word”''&lt;br /&gt;
&lt;br /&gt;
== PRINT ==&lt;br /&gt;
Lo statement [http://docs.python.org/ref/print.html print] valuta tutte le espressioni presenti e quindi le stampa a video.&lt;br /&gt;
L'espressione da valutare può essere anche un semplice numero o una semplice stringa&lt;br /&gt;
&lt;br /&gt;
    ''print 3''&lt;br /&gt;
stampa 3, e anche se scrivo&lt;br /&gt;
    '' print “3”''&lt;br /&gt;
stampa lo stesso anche se abbiamo passato prima un intero, poi una stringa.&lt;br /&gt;
Questo è normale, perchè il numero &amp;quot;tre&amp;quot; viene rappresentato dal simbolo 3 nel sistema decimale.&lt;br /&gt;
&lt;br /&gt;
Invece, se scrivo&lt;br /&gt;
    ''print 3+2''&lt;br /&gt;
otteniamo a video 5: l'inteprete ha valutato l'espressione, ha eseguito la somma e stampato il situlato.&lt;br /&gt;
Mentre se scriviamo&lt;br /&gt;
    ''print “3+2”''&lt;br /&gt;
il risolutato è &lt;br /&gt;
    ''3+2''&lt;br /&gt;
in quanto abbiamo passato la stringa composta dal carattere 3, dal simbolo + e dal carattere 2.&lt;br /&gt;
&lt;br /&gt;
Le variabili in python non devono essere dichiarate: esistono dalla prima volta in cui gli viene assegnato un valore&lt;br /&gt;
    ''messaggio=”hello world”''&lt;br /&gt;
    ''print messaggio''&lt;br /&gt;
se questo programma viene eseguito il risultatato sarà:&lt;br /&gt;
''hello world''&lt;br /&gt;
l'interprete valuta l'espressione ''messaggio'' e stampa il suo contenuto&lt;br /&gt;
&lt;br /&gt;
== Errori e Eccezioni ==&lt;br /&gt;
&lt;br /&gt;
Commentando l'assegnamento di messaggio, vediamo che l'interprete genera un errore:&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
  jdoe@waste-bin ~ $ python&lt;br /&gt;
  Python 2.5.2 (r252:60911, May 24 2008, 15:28:31) &lt;br /&gt;
  [GCC 4.2.4 (Gentoo 4.2.4 p1.0)] on linux2&lt;br /&gt;
  Type &amp;quot;help&amp;quot;, &amp;quot;copyright&amp;quot;, &amp;quot;credits&amp;quot; or &amp;quot;license&amp;quot; for more information.&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; print messaggio&lt;br /&gt;
  Traceback (most recent call last):&lt;br /&gt;
    File &amp;quot;&amp;lt;stdin&amp;gt;&amp;quot;, line 1, in &amp;lt;module&amp;gt;&lt;br /&gt;
  NameError: name 'messaggio' is not defined&lt;br /&gt;
&lt;br /&gt;
NameError è una eccezione. Vedremo più avanti come queste situazioni di errore possono essere ''catturate'' e ''gestite'' appositamente, sia&lt;br /&gt;
per tentare di risolvere il problema che per migliorare il feedback che il nostro programma da all'utente. Vedremo anche come&lt;br /&gt;
la gestione delle eccezioni è parte della programmazione normale di un programma, ovvero non è sempre legata a una situazione di errore.&lt;br /&gt;
&lt;br /&gt;
Un altro esempio, tendando di sommare mele e pere:&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; print 1 + &amp;quot;a&amp;quot;&lt;br /&gt;
  Traceback (most recent call last):&lt;br /&gt;
    File &amp;quot;&amp;lt;stdin&amp;gt;&amp;quot;, line 1, in &amp;lt;module&amp;gt;&lt;br /&gt;
  TypeError: unsupported operand type(s) for +: 'int' and 'str'&lt;br /&gt;
&lt;br /&gt;
Vediamo che a questo giro l'eccezione lanciata è ValueError.&lt;br /&gt;
&lt;br /&gt;
== LE STRINGHE ==&lt;br /&gt;
Gli oggetti di tipo stringa supportano svariati metodi e proprietà. E' da notare che le stringhe sono immutabili.&lt;br /&gt;
Se una stringa viene dichiarata la seconda volta, quella precedente viene buttata, non viene modificata per fare spazio alla nuova.&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
    messaggio=”ciao mondo”&lt;br /&gt;
    print messaggio''&lt;br /&gt;
stampa&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
In Python non si possono sommare cose diverse, o meglio, lo posso fare solo se è definita una conversione tra i due tipo.&lt;br /&gt;
Le stringhe supportano anche alcuni operatori base:&lt;br /&gt;
    ''print messaggio*2'' &lt;br /&gt;
l'esecuzione darà&lt;br /&gt;
    ''messaggio messaggio&lt;br /&gt;
''&lt;br /&gt;
esempio:&lt;br /&gt;
     ''Print “ciao”+” mondo”''&lt;br /&gt;
lo eseguo e mi darà:&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
== '''Funzione DIR''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
    dir(messaggio)''&lt;br /&gt;
a questo punto il programma da una serie di caratteri incomprensibili.&lt;br /&gt;
Praticamente dà i '''metodi''' che suporta la stringa messaggio.&lt;br /&gt;
&lt;br /&gt;
== I '''metodi''' ==&lt;br /&gt;
sono operazioni che i vari oggetti supportano.&lt;br /&gt;
alcuni metodi, vedendo con la funzione dir(), iniziano e terminano con __ . Tali metodi, chiamati metodi speciali, non dovrebbero essere chiamati direttamente,&lt;br /&gt;
senza che ci sia una ragione specifica per farlo (ovvero: sapete quello che state facendo). In generale possono essere pensati come privati o riservati, anche se non &lt;br /&gt;
essendoci controlli di accesso come in altri linguaggi (public private del java o del c++ ad esempio) nessuno vieta di chiamarli.&lt;br /&gt;
&lt;br /&gt;
Ad esempio, il metodo __add__ delle stringhe è chiamato quando si fa la somma di due stringhe.&lt;br /&gt;
 ''&amp;quot;ciao&amp;quot; + &amp;quot; mondo&amp;quot;'' &lt;br /&gt;
chiama in realtà &lt;br /&gt;
 ''&amp;quot;ciao&amp;quot;.__add__(&amp;quot; mondo&amp;quot;)''&lt;br /&gt;
&lt;br /&gt;
''__ doc__'' ce l'hanno tutti gli oggetti (stringhe, interi...), e contiene una stringa di documentazione dell'oggetto. &lt;br /&gt;
&lt;br /&gt;
i metodi che iniziano per is servono per controllare se una certa proprietà della stringa in esame è vera:&lt;br /&gt;
es: &lt;br /&gt;
    ''messaggio.isalpha()''&lt;br /&gt;
mi dice se messaggio è o meno alfanumerico (composto solo da numeri e cifre, senza spazi, tab, ritorno carrello ecc ecc).&lt;br /&gt;
isalpha è un oggetto quindi ha le proprietà doc .&lt;br /&gt;
se io scrivo&lt;br /&gt;
    ''messaggio.isalpha.__doc__''&lt;br /&gt;
mi dice che fa.&lt;br /&gt;
&lt;br /&gt;
es:&lt;br /&gt;
    '' messaggio=”gigio”&lt;br /&gt;
    messaggio2= messaggio.upper()''&lt;br /&gt;
&lt;br /&gt;
es:&lt;br /&gt;
''TYPE(3)''&lt;br /&gt;
mi dice che variabile  è. se è intero o stringa oppure un complesso, un float o un tipo definito dall'utente.&lt;br /&gt;
Se io scrivo ''DIR(3)''&lt;br /&gt;
mi da tutta la lista dei metodi e delle proprietà degli int (dato che 3 è in intero)&lt;br /&gt;
'''&lt;br /&gt;
&lt;br /&gt;
Esistono stringhe, interi, float (numeri con virgola)booleano (che ha due valori, vero o falso, True e False)e i vari contenitori:&lt;br /&gt;
&lt;br /&gt;
== '''LE LISTE''' ==&lt;br /&gt;
&lt;br /&gt;
es. lo scaffale ha I pc, I pc sono oggetti (pc1,pc2...).Se voglio uno scaffale di pc senza dare I nomi a tutti gli oggetti, definisco lo scaffale.&lt;br /&gt;
Lo scaffale si chiama''' Lista'''  .si usano le parentesi quadre con oggetti separati da virgola&lt;br /&gt;
es.    '' a = [ “pc1” , “schermo rotto” , 2]&lt;br /&gt;
dir (scaffale)''&lt;br /&gt;
da la lista dei metodi, da qui si capisce che la lista è un oggetto.&lt;br /&gt;
Ad esempio:&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a la stringa &amp;quot;4&amp;quot;.&lt;br /&gt;
La lista, a differenza delle stringhe, è un oggetto mutabile, quindi la funzione append di fatto manipola la lista esistente per far spazio al nuovo oggetto da inserir&lt;br /&gt;
&lt;br /&gt;
Se faccio     ''print (“a”)''&lt;br /&gt;
mi da la lista degli oggetti più &amp;quot;4&amp;quot;&lt;br /&gt;
&lt;br /&gt;
Da notare che&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; mialista = []&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; mialista&lt;br /&gt;
  []&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; dir(a)&lt;br /&gt;
  ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__ge__', &lt;br /&gt;
   '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', &lt;br /&gt;
   '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__',&lt;br /&gt;
   '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__str__', 'append', 'count', 'extend', 'index', 'insert', &lt;br /&gt;
   'pop', 'remove', 'reverse', 'sort']&lt;br /&gt;
&lt;br /&gt;
Da qui vediamo che il risultato della funziona dir su una lista ritorna .. una lista.&lt;br /&gt;
&lt;br /&gt;
Vediamo come una lista può contenere qualsiasi oggetto, anche una lista o una tupla (vedi sotto)&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; mialista = [ (1,1,1), [2,2,2], 3, ([4,4,4],(4,4,4))]&lt;br /&gt;
&lt;br /&gt;
Questa è una lista di 4 oggetti, uno dei quali è una tupla, il secondo è una lista, il terzo un intero, il quarto una tupla contenente a sua volta una lista e una tupla.&lt;br /&gt;
&lt;br /&gt;
== '''TUPLE''' ==&lt;br /&gt;
&lt;br /&gt;
simile a una lista, è un contenitore di elementi. La tupla non è mutabile, per cui se definita con 4 oggetti non potrà mai contenerne 5 come non si può cambiare il&lt;br /&gt;
valore a uno degli oggetti&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miatupla = ( 1, 2,  &amp;quot;a&amp;quot; ,(1,2,3))&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miatupla&lt;br /&gt;
  (1, 2, 'a', (1, 2, 3))&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; len(miatupla)&lt;br /&gt;
  4&lt;br /&gt;
  &lt;br /&gt;
Dall'esempio vediamo come una tupla possa contenere al suo interno oggetti di vario tipo (tra cui una tupla stessa): a tal proposito&lt;br /&gt;
si vede che la lunghezza della tupla è 4 , infatti la tupla in essa contenuta - e che a sua volta contiene 3 oggetti - viene considerata&lt;br /&gt;
un unico oggetto (perchè difatto lo è.)&lt;br /&gt;
&lt;br /&gt;
Vediamo come si può accedere posizionalmente agli elementi della tupla (l'indice parte da zero)&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miatupla[0] # primo elemento&lt;br /&gt;
  1&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miatupla[2] # terzo elemento&lt;br /&gt;
  'a'&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; primo, secondo, terzo, quarto = miatupla  # scompatta la tupla in 4 variabili&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; terzo&lt;br /&gt;
  'a'&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; quarto&lt;br /&gt;
  (1, 2, 3)&lt;br /&gt;
&lt;br /&gt;
Inoltre, tentare di assegnare un nuovo valore a un elemento della tupla genera una eccezione&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miatupla[0] = 3&lt;br /&gt;
  Traceback (most recent call last):&lt;br /&gt;
    File &amp;quot;&amp;lt;stdin&amp;gt;&amp;quot;, line 1, in &amp;lt;module&amp;gt;&lt;br /&gt;
  TypeError: 'tuple' object does not support item assignment&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== '''DIZIONARI''' ==&lt;br /&gt;
&lt;br /&gt;
il dizionario si definisce con le parentesi graffe {chiave:valore, chiave:valore}&lt;br /&gt;
a[chiave]&lt;br /&gt;
da il valore associato alla chiave.&lt;br /&gt;
&lt;br /&gt;
Dizionari liste e tuple sono dele sequenze e sono iterable e si possono quindi scorrere.&lt;br /&gt;
&lt;br /&gt;
== '''If elif else''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
if condizione :&lt;br /&gt;
&lt;br /&gt;
indentato roba da fare se vero.&lt;br /&gt;
&lt;br /&gt;
Python supporta o tab o spazio, si decide quanti tab o spazi alla prima indentazione.&lt;br /&gt;
Meglio lo spazio perchè in futuro I tab verranno lasciati.&lt;br /&gt;
Di solito si usa 4 spazi.&lt;br /&gt;
Non c'è la graffa in pyton o I begin o gli end, si chiude e si apre la riga solo se si indenta.&lt;br /&gt;
&lt;br /&gt;
Esempio:&lt;br /&gt;
    ''a=3&lt;br /&gt;
    b=1''&lt;br /&gt;
&lt;br /&gt;
    ''if a &amp;gt;b:&lt;br /&gt;
      print (“ a è maggiore di b”)&lt;br /&gt;
    elif a==b:&lt;br /&gt;
      print (“ a è uguale a b”)&lt;br /&gt;
    else:&lt;br /&gt;
       print(“b è maggiore di a”)''&lt;br /&gt;
&lt;br /&gt;
in questo programma definisco due valori, a e b.&lt;br /&gt;
Chiedo al programma se aè maggiore di b di scrivere : a è maggiore di b, se a è uguale a b di scrivere che a è uguale a b e in tutte le altre condizioni (else) di scrivere che a è minore di b.&lt;br /&gt;
&lt;br /&gt;
	'''2.is, is not or, and,!='''&lt;br /&gt;
    ''if a is 1:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
    elif a is not 1:&lt;br /&gt;
      print (“no”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 and b is 3:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 or b is 3:&lt;br /&gt;
      print (“okkei”)&lt;br /&gt;
''&lt;br /&gt;
&lt;br /&gt;
'''!= è il diverso.'''&lt;br /&gt;
&lt;br /&gt;
== '''append, insert''' ==&lt;br /&gt;
&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a il 4.&lt;br /&gt;
Se faccio print (“a”)&lt;br /&gt;
mi da la lista degli oggetti più il 4.&lt;br /&gt;
&lt;br /&gt;
con '''insert''' devo inserire anche la posizione&lt;br /&gt;
    ''a.insert(2,34)''&lt;br /&gt;
mette il 34 in posizione 2&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''for''' ==&lt;br /&gt;
&lt;br /&gt;
specifica un ciclo, fa le cose tante volte fino ad una condizione.&lt;br /&gt;
For variabile in una sequenza di qualche tipo.&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miatupla = ( 1, 2,  &amp;quot;a&amp;quot; ,(1,2,3))&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; for variabile in miatupla:&lt;br /&gt;
  ...     print &amp;quot;nella tupla: &amp;quot;,&lt;br /&gt;
  ...     print variabile&lt;br /&gt;
  ... &lt;br /&gt;
  nella tupla:  1&lt;br /&gt;
  nella tupla:  2&lt;br /&gt;
  nella tupla:  a&lt;br /&gt;
  nella tupla:  (1, 2, 3)&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
In caso volessi, nel ciclo, sapere &amp;quot;a che punto&amp;quot; della tupla (o della sequenza, in generale a che punto dell' '''iterable''') sono:&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; for indice, variabile in enumerate(miatupla):&lt;br /&gt;
  ...     print &amp;quot;elemento&amp;quot;,&lt;br /&gt;
  ...     print indice&lt;br /&gt;
  ...     print variabile&lt;br /&gt;
  ... &lt;br /&gt;
  elemento 0&lt;br /&gt;
  1&lt;br /&gt;
  elemento 1&lt;br /&gt;
  2&lt;br /&gt;
  elemento 2&lt;br /&gt;
  a&lt;br /&gt;
  elemento 3&lt;br /&gt;
  (1, 2, 3)&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; &lt;br /&gt;
&lt;br /&gt;
Iterando su un dizionario, che è un iterable, vengono resistuite le chiave, non i valori.&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miodizionario = { 'primo': 1, 'secondo': &amp;quot;golem&amp;quot;, 'terzo': [1,2,3] }&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; for chiave in miodizionario:&lt;br /&gt;
  ...     print chiave,&lt;br /&gt;
  ...     print &amp;quot;:&amp;quot;,&lt;br /&gt;
  ...     print miodizionario[chiave]&lt;br /&gt;
  ... &lt;br /&gt;
  terzo : [1, 2, 3]&lt;br /&gt;
  primo : 1&lt;br /&gt;
  secondo : golem&lt;br /&gt;
&lt;br /&gt;
Vediamo come gli elementi del dizionario non ci vengono resistuiti in un particolare ordine, anzi, non ci soono garanzie a riguardo&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; dir (miodizionario)&lt;br /&gt;
  ['__class__', '__cmp__', '__contains__', '__delattr__', '__delitem__', '__doc__', '__eq__', '__ge__',&lt;br /&gt;
   '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', &lt;br /&gt;
   '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', &lt;br /&gt;
   '__str__', 'clear', 'copy', 'fromkeys', 'get', 'has_key', 'items', 'iteritems', 'iterkeys', &lt;br /&gt;
   'itervalues', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']&lt;br /&gt;
&lt;br /&gt;
se vogliamo iterare su i valori e non sulle chiavi dobbiamo usare il metodo '''itervalues''' degli oggetti dizionario:&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; for valore in  miodizionario.itervalues():&lt;br /&gt;
  ...     print valore&lt;br /&gt;
  ... &lt;br /&gt;
  [1, 2, 3]&lt;br /&gt;
  1&lt;br /&gt;
  golem&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== '''xrange''' ==&lt;br /&gt;
&lt;br /&gt;
xrange è un iterable di dieci elementi con il primo valore uguale a 0 .E' una lista ma non ha le proprietà di una lista.&lt;br /&gt;
se io voglio fare un for da uno a dieci (cioè la somma da uno a 10)&lt;br /&gt;
&lt;br /&gt;
es:     ''for I xrange(10)&lt;br /&gt;
               print I''&lt;br /&gt;
lui stampa&lt;br /&gt;
''1&lt;br /&gt;
2&lt;br /&gt;
3&lt;br /&gt;
4&lt;br /&gt;
5&lt;br /&gt;
6&lt;br /&gt;
7&lt;br /&gt;
8&lt;br /&gt;
9&lt;br /&gt;
10''&lt;br /&gt;
&lt;br /&gt;
== '''range''' ==&lt;br /&gt;
&lt;br /&gt;
ha la stessa funzione di xrange, ovvero servire da iterable su N numeri, però ritorna non un oggetto di tipo xrange ma una lista.&lt;br /&gt;
E' più lento di xrange&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; print range(10)&lt;br /&gt;
  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== '''len''' ==&lt;br /&gt;
&lt;br /&gt;
    ''len (a)''&lt;br /&gt;
da la lunghezza della stringa&lt;br /&gt;
&lt;br /&gt;
== '''enumerate''' ==&lt;br /&gt;
&lt;br /&gt;
se io ho una lista di tre elmenti&lt;br /&gt;
''a=[“ciao”,”bel”, “mondo”]''&lt;br /&gt;
&lt;br /&gt;
''for I, elem in enumerate(a):&lt;br /&gt;
     print str(I) + “:” + elem&lt;br /&gt;
''&lt;br /&gt;
da la posizione corrente di ogni elemento.&lt;br /&gt;
''0:ciao&lt;br /&gt;
1:bel&lt;br /&gt;
2:mondo''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''raw_input''' ==&lt;br /&gt;
&lt;br /&gt;
dai il valore.&lt;br /&gt;
''Base= raw_input (“inserisce la base:”)&lt;br /&gt;
esponente=raw_input (“inserisci l'/ esponente”)''&lt;br /&gt;
&lt;br /&gt;
ti chiede il valore di base ed esponente.&lt;br /&gt;
&lt;br /&gt;
== '''Int''' ==&lt;br /&gt;
&lt;br /&gt;
forza il fatto che quel valore sia un intero.&lt;br /&gt;
''&lt;br /&gt;
Es:base=int(base)&lt;br /&gt;
  result=int(result)''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''UPPER,LOWER,CAPITALIZE''' ==&lt;br /&gt;
&lt;br /&gt;
'''capitalize''' è un comando che sulla la stringa su cui viene applicato ,prende la prima lettera dopo gli spazi e ci mette la maiuscola&lt;br /&gt;
&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.capitalize()''&lt;br /&gt;
    ''Ciao mondo''&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.title()&lt;br /&gt;
    Ciao Mondo''&lt;br /&gt;
&lt;br /&gt;
'''LOWER:''' prende la striga e emette tutto minuscolo&lt;br /&gt;
'''UPPER:''' il contrario di lower&lt;br /&gt;
&lt;br /&gt;
== '''ESEMPIO DELLA SERATA:''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Calcolo di una potenza.&lt;br /&gt;
&lt;br /&gt;
    ''&lt;br /&gt;
    base= raw_input (“inserisce la base:”)&lt;br /&gt;
    esponente=raw_input ('inserisci l\' esponente')&lt;br /&gt;
&lt;br /&gt;
    base=int(base)&lt;br /&gt;
    result=int(result)&lt;br /&gt;
&lt;br /&gt;
    result=1&lt;br /&gt;
    for i in xrange(esponente):&lt;br /&gt;
         result = result * base&lt;br /&gt;
    print result''&lt;br /&gt;
&lt;br /&gt;
il [http://docs.python.org/lib/built-in-funcs.html built-in] int() è necessario, dato che tutto quello che proviene dalla tastiera viene acquisito da raw_input() come stringa. Dato che dobbiamo usarli come interi, occorre effettuare un cast, ovvero&lt;br /&gt;
una trasformazione di tipo, da stringa a intero.&lt;br /&gt;
E' interessante notare che int() non cerca di fare i miracoli: provate a vedere cosa succede se cercate di convertire &amp;quot;awlerorj&amp;quot; in int!&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3741</id>
		<title>Python Lezione 4 Giugno 2008</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3741"/>
		<updated>2008-06-10T12:04:05Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: /* '''for''' */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Python ==&lt;br /&gt;
[http://www.python.it/ Python] è un linguaggio di programmazione [http://it.wikipedia.org/wiki/Interprete_(informatica) interpretato].&lt;br /&gt;
Il linuaggio interpretato è simile agli altri linguaggi in circolazione ma, invece di essere trasformato direttamente in codice binario dal meccanismo automatico, viene interpretato da questo e poi mandato all'hardware.&lt;br /&gt;
Un linguaggio interpretato non ha bisogno di essere ricompilato: il codice scritto viene interpretato da un interprete a run-time (tempo di esecuzione) e tradotto al volo nel linguaggio macchina.&lt;br /&gt;
Quindi i programmi python possono girare su qualsiasi hardware e sistema operativo su cui è stato portato l'interprete. Ovviamente, questa cosa si paga sul tempo di esecuzione pure: l'approccio ha si i suoi vantaggi, ma rispetto a un linguaggio compilato direttamente in linguaggio macchina per creare un eseguibile, python e gli altri liguaggi interpretati risultano essere più lenti.&lt;br /&gt;
&lt;br /&gt;
Esistono vari interpreti: [http://www.python.org Cpython], o classic python, è l'interprete &amp;quot;ufficiale&amp;quot;, scritto in C e disponibile per linux, mac e windows.&lt;br /&gt;
[http://www.jython.org/Project/ Jython] è un interprete scritto al 100% in Java, e si interfaccia strettamente ai programmi e alla libreria Java, &lt;br /&gt;
[http://www.codeplex.com/Wiki/View.aspx?ProjectName=IronPython IronPython] è un interprete python che gira sulla piattaforma .NET mentre &lt;br /&gt;
[http://codespeak.net/pypy/dist/pypy/doc/home.html PyPy] è (anche) un interprete python scritto in.. python&lt;br /&gt;
&lt;br /&gt;
La prima riga di ogni script python deve iniziare con #!/usr/bin/env python&lt;br /&gt;
&lt;br /&gt;
il #! del file fa capire al sistema operativo (solo su sistemi posix, quindi unix/linux) che quello non è un file di testo ma un eseguibile da eseguire con l'inteprete python.&lt;br /&gt;
&lt;br /&gt;
== COMMENTI ==&lt;br /&gt;
&lt;br /&gt;
: sono righe che l'interprete salta e non legge &lt;br /&gt;
es: &lt;br /&gt;
    ''# stampa:”hello word”''&lt;br /&gt;
&lt;br /&gt;
== PRINT ==&lt;br /&gt;
Lo statement [http://docs.python.org/ref/print.html print] valuta tutte le espressioni presenti e quindi le stampa a video.&lt;br /&gt;
L'espressione da valutare può essere anche un semplice numero o una semplice stringa&lt;br /&gt;
&lt;br /&gt;
    ''print 3''&lt;br /&gt;
stampa 3, e anche se scrivo&lt;br /&gt;
    '' print “3”''&lt;br /&gt;
stampa lo stesso anche se abbiamo passato prima un intero, poi una stringa.&lt;br /&gt;
Questo è normale, perchè il numero &amp;quot;tre&amp;quot; viene rappresentato dal simbolo 3 nel sistema decimale.&lt;br /&gt;
&lt;br /&gt;
Invece, se scrivo&lt;br /&gt;
    ''print 3+2''&lt;br /&gt;
otteniamo a video 5: l'inteprete ha valutato l'espressione, ha eseguito la somma e stampato il situlato.&lt;br /&gt;
Mentre se scriviamo&lt;br /&gt;
    ''print “3+2”''&lt;br /&gt;
il risolutato è &lt;br /&gt;
    ''3+2''&lt;br /&gt;
in quanto abbiamo passato la stringa composta dal carattere 3, dal simbolo + e dal carattere 2.&lt;br /&gt;
&lt;br /&gt;
Le variabili in python non devono essere dichiarate: esistono dalla prima volta in cui gli viene assegnato un valore&lt;br /&gt;
    ''messaggio=”hello world”''&lt;br /&gt;
    ''print messaggio''&lt;br /&gt;
se questo programma viene eseguito il risultatato sarà:&lt;br /&gt;
''hello world''&lt;br /&gt;
l'interprete valuta l'espressione ''messaggio'' e stampa il suo contenuto&lt;br /&gt;
&lt;br /&gt;
== Errori e Eccezioni ==&lt;br /&gt;
&lt;br /&gt;
Commentando l'assegnamento di messaggio, vediamo che l'interprete genera un errore:&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
  jdoe@waste-bin ~ $ python&lt;br /&gt;
  Python 2.5.2 (r252:60911, May 24 2008, 15:28:31) &lt;br /&gt;
  [GCC 4.2.4 (Gentoo 4.2.4 p1.0)] on linux2&lt;br /&gt;
  Type &amp;quot;help&amp;quot;, &amp;quot;copyright&amp;quot;, &amp;quot;credits&amp;quot; or &amp;quot;license&amp;quot; for more information.&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; print messaggio&lt;br /&gt;
  Traceback (most recent call last):&lt;br /&gt;
    File &amp;quot;&amp;lt;stdin&amp;gt;&amp;quot;, line 1, in &amp;lt;module&amp;gt;&lt;br /&gt;
  NameError: name 'messaggio' is not defined&lt;br /&gt;
&lt;br /&gt;
NameError è una eccezione. Vedremo più avanti come queste situazioni di errore possono essere ''catturate'' e ''gestite'' appositamente, sia&lt;br /&gt;
per tentare di risolvere il problema che per migliorare il feedback che il nostro programma da all'utente. Vedremo anche come&lt;br /&gt;
la gestione delle eccezioni è parte della programmazione normale di un programma, ovvero non è sempre legata a una situazione di errore.&lt;br /&gt;
&lt;br /&gt;
Un altro esempio, tendando di sommare mele e pere:&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; print 1 + &amp;quot;a&amp;quot;&lt;br /&gt;
  Traceback (most recent call last):&lt;br /&gt;
    File &amp;quot;&amp;lt;stdin&amp;gt;&amp;quot;, line 1, in &amp;lt;module&amp;gt;&lt;br /&gt;
  TypeError: unsupported operand type(s) for +: 'int' and 'str'&lt;br /&gt;
&lt;br /&gt;
Vediamo che a questo giro l'eccezione lanciata è ValueError.&lt;br /&gt;
&lt;br /&gt;
== LE STRINGHE ==&lt;br /&gt;
Gli oggetti di tipo stringa supportano svariati metodi e proprietà. E' da notare che le stringhe sono immutabili.&lt;br /&gt;
Se una stringa viene dichiarata la seconda volta, quella precedente viene buttata, non viene modificata per fare spazio alla nuova.&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
    messaggio=”ciao mondo”&lt;br /&gt;
    print messaggio''&lt;br /&gt;
stampa&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
In Python non si possono sommare cose diverse, o meglio, lo posso fare solo se è definita una conversione tra i due tipo.&lt;br /&gt;
Le stringhe supportano anche alcuni operatori base:&lt;br /&gt;
    ''print messaggio*2'' &lt;br /&gt;
l'esecuzione darà&lt;br /&gt;
    ''messaggio messaggio&lt;br /&gt;
''&lt;br /&gt;
esempio:&lt;br /&gt;
     ''Print “ciao”+” mondo”''&lt;br /&gt;
lo eseguo e mi darà:&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
== '''Funzione DIR''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
    dir(messaggio)''&lt;br /&gt;
a questo punto il programma da una serie di caratteri incomprensibili.&lt;br /&gt;
Praticamente dà i '''metodi''' che suporta la stringa messaggio.&lt;br /&gt;
&lt;br /&gt;
== I '''metodi''' ==&lt;br /&gt;
sono operazioni che i vari oggetti supportano.&lt;br /&gt;
alcuni metodi, vedendo con la funzione dir(), iniziano e terminano con __ . Tali metodi, chiamati metodi speciali, non dovrebbero essere chiamati direttamente,&lt;br /&gt;
senza che ci sia una ragione specifica per farlo (ovvero: sapete quello che state facendo). In generale possono essere pensati come privati o riservati, anche se non &lt;br /&gt;
essendoci controlli di accesso come in altri linguaggi (public private del java o del c++ ad esempio) nessuno vieta di chiamarli.&lt;br /&gt;
&lt;br /&gt;
Ad esempio, il metodo __add__ delle stringhe è chiamato quando si fa la somma di due stringhe.&lt;br /&gt;
 ''&amp;quot;ciao&amp;quot; + &amp;quot; mondo&amp;quot;'' &lt;br /&gt;
chiama in realtà &lt;br /&gt;
 ''&amp;quot;ciao&amp;quot;.__add__(&amp;quot; mondo&amp;quot;)''&lt;br /&gt;
&lt;br /&gt;
''__ doc__'' ce l'hanno tutti gli oggetti (stringhe, interi...), e contiene una stringa di documentazione dell'oggetto. &lt;br /&gt;
&lt;br /&gt;
i metodi che iniziano per is servono per controllare se una certa proprietà della stringa in esame è vera:&lt;br /&gt;
es: &lt;br /&gt;
    ''messaggio.isalpha()''&lt;br /&gt;
mi dice se messaggio è o meno alfanumerico (composto solo da numeri e cifre, senza spazi, tab, ritorno carrello ecc ecc).&lt;br /&gt;
isalpha è un oggetto quindi ha le proprietà doc .&lt;br /&gt;
se io scrivo&lt;br /&gt;
    ''messaggio.isalpha.__doc__''&lt;br /&gt;
mi dice che fa.&lt;br /&gt;
&lt;br /&gt;
es:&lt;br /&gt;
    '' messaggio=”gigio”&lt;br /&gt;
    messaggio2= messaggio.upper()''&lt;br /&gt;
&lt;br /&gt;
es:&lt;br /&gt;
''TYPE(3)''&lt;br /&gt;
mi dice che variabile  è. se è intero o stringa oppure un complesso, un float o un tipo definito dall'utente.&lt;br /&gt;
Se io scrivo ''DIR(3)''&lt;br /&gt;
mi da tutta la lista dei metodi e delle proprietà degli int (dato che 3 è in intero)&lt;br /&gt;
'''&lt;br /&gt;
&lt;br /&gt;
Esistono stringhe, interi, float (numeri con virgola)booleano (che ha due valori, vero o falso, True e False)e i vari contenitori:&lt;br /&gt;
&lt;br /&gt;
== '''LE LISTE''' ==&lt;br /&gt;
&lt;br /&gt;
es. lo scaffale ha I pc, I pc sono oggetti (pc1,pc2...).Se voglio uno scaffale di pc senza dare I nomi a tutti gli oggetti, definisco lo scaffale.&lt;br /&gt;
Lo scaffale si chiama''' Lista'''  .si usano le parentesi quadre con oggetti separati da virgola&lt;br /&gt;
es.    '' a = [ “pc1” , “schermo rotto” , 2]&lt;br /&gt;
dir (scaffale)''&lt;br /&gt;
da la lista dei metodi, da qui si capisce che la lista è un oggetto.&lt;br /&gt;
Ad esempio:&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a la stringa &amp;quot;4&amp;quot;.&lt;br /&gt;
La lista, a differenza delle stringhe, è un oggetto mutabile, quindi la funzione append di fatto manipola la lista esistente per far spazio al nuovo oggetto da inserir&lt;br /&gt;
&lt;br /&gt;
Se faccio     ''print (“a”)''&lt;br /&gt;
mi da la lista degli oggetti più &amp;quot;4&amp;quot;&lt;br /&gt;
&lt;br /&gt;
Da notare che&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; mialista = []&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; mialista&lt;br /&gt;
  []&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; dir(a)&lt;br /&gt;
  ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__ge__', &lt;br /&gt;
   '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', &lt;br /&gt;
   '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__',&lt;br /&gt;
   '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__str__', 'append', 'count', 'extend', 'index', 'insert', &lt;br /&gt;
   'pop', 'remove', 'reverse', 'sort']&lt;br /&gt;
&lt;br /&gt;
Da qui vediamo che il risultato della funziona dir su una lista ritorna .. una lista.&lt;br /&gt;
&lt;br /&gt;
Vediamo come una lista può contenere qualsiasi oggetto, anche una lista o una tupla (vedi sotto)&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; mialista = [ (1,1,1), [2,2,2], 3, ([4,4,4],(4,4,4))]&lt;br /&gt;
&lt;br /&gt;
Questa è una lista di 4 oggetti, uno dei quali è una tupla, il secondo è una lista, il terzo un intero, il quarto una tupla contenente a sua volta una lista e una tupla.&lt;br /&gt;
&lt;br /&gt;
== '''TUPLE''' ==&lt;br /&gt;
&lt;br /&gt;
simile a una lista, è un contenitore di elementi. La tupla non è mutabile, per cui se definita con 4 oggetti non potrà mai contenerne 5 come non si può cambiare il&lt;br /&gt;
valore a uno degli oggetti&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miatupla = ( 1, 2,  &amp;quot;a&amp;quot; ,(1,2,3))&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miatupla&lt;br /&gt;
  (1, 2, 'a', (1, 2, 3))&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; len(miatupla)&lt;br /&gt;
  4&lt;br /&gt;
  &lt;br /&gt;
Dall'esempio vediamo come una tupla possa contenere al suo interno oggetti di vario tipo (tra cui una tupla stessa): a tal proposito&lt;br /&gt;
si vede che la lunghezza della tupla è 4 , infatti la tupla in essa contenuta - e che a sua volta contiene 3 oggetti - viene considerata&lt;br /&gt;
un unico oggetto (perchè difatto lo è.)&lt;br /&gt;
&lt;br /&gt;
Vediamo come si può accedere posizionalmente agli elementi della tupla (l'indice parte da zero)&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miatupla[0] # primo elemento&lt;br /&gt;
  1&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miatupla[2] # terzo elemento&lt;br /&gt;
  'a'&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; primo, secondo, terzo, quarto = miatupla  # scompatta la tupla in 4 variabili&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; terzo&lt;br /&gt;
  'a'&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; quarto&lt;br /&gt;
  (1, 2, 3)&lt;br /&gt;
&lt;br /&gt;
Inoltre, tentare di assegnare un nuovo valore a un elemento della tupla genera una eccezione&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miatupla[0] = 3&lt;br /&gt;
  Traceback (most recent call last):&lt;br /&gt;
    File &amp;quot;&amp;lt;stdin&amp;gt;&amp;quot;, line 1, in &amp;lt;module&amp;gt;&lt;br /&gt;
  TypeError: 'tuple' object does not support item assignment&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== '''DIZIONARI''' ==&lt;br /&gt;
&lt;br /&gt;
il dizionario si definisce con le parentesi graffe {chiave:valore, chiave:valore}&lt;br /&gt;
a{chiave}&lt;br /&gt;
da il valore associato alla chiave.&lt;br /&gt;
&lt;br /&gt;
Dizionari liste e tuple sono dele sequenze e sono iterable e si possono scorrere.&lt;br /&gt;
&lt;br /&gt;
== '''If elif else''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
if condizione :&lt;br /&gt;
&lt;br /&gt;
indentato roba da fare se vero.&lt;br /&gt;
&lt;br /&gt;
Python supporta o tab o spazio, si decide quanti tab o spazi alla prima indentazione.&lt;br /&gt;
Meglio lo spazio perchè in futuro I tab verranno lasciati.&lt;br /&gt;
Di solito si usa 4 spazi.&lt;br /&gt;
Non c'è la graffa in pyton o I begin o gli end, si chiude e si apre la riga solo se si indenta.&lt;br /&gt;
&lt;br /&gt;
Esempio:&lt;br /&gt;
    ''a=3&lt;br /&gt;
    b=1''&lt;br /&gt;
&lt;br /&gt;
    ''if a &amp;gt;b:&lt;br /&gt;
      print (“ a è maggiore di b”)&lt;br /&gt;
    elif a==b:&lt;br /&gt;
      print (“ a è uguale a b”)&lt;br /&gt;
    else:&lt;br /&gt;
       print(“b è maggiore di a”)''&lt;br /&gt;
&lt;br /&gt;
in questo programma definisco due valori, a e b.&lt;br /&gt;
Chiedo al programma se aè maggiore di b di scrivere : a è maggiore di b, se a è uguale a b di scrivere che a è uguale a b e in tutte le altre condizioni (else) di scrivere che a è minore di b.&lt;br /&gt;
&lt;br /&gt;
	'''2.is, is not or, and,!='''&lt;br /&gt;
    ''if a is 1:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
    elif a is not 1:&lt;br /&gt;
      print (“no”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 and b is 3:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 or b is 3:&lt;br /&gt;
      print (“okkei”)&lt;br /&gt;
''&lt;br /&gt;
&lt;br /&gt;
'''!= è il diverso.'''&lt;br /&gt;
&lt;br /&gt;
== '''append, insert''' ==&lt;br /&gt;
&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a il 4.&lt;br /&gt;
Se faccio print (“a”)&lt;br /&gt;
mi da la lista degli oggetti più il 4.&lt;br /&gt;
&lt;br /&gt;
con '''insert''' devo inserire anche la posizione&lt;br /&gt;
    ''a.insert(2,34)''&lt;br /&gt;
mette il 34 in posizione 2&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''for''' ==&lt;br /&gt;
&lt;br /&gt;
specifica un ciclo, fa le cose tante volte fino ad una condizione.&lt;br /&gt;
For variabile in una sequenza di qualche tipo.&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miatupla = ( 1, 2,  &amp;quot;a&amp;quot; ,(1,2,3))&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; for variabile in miatupla:&lt;br /&gt;
  ...     print &amp;quot;nella tupla: &amp;quot;,&lt;br /&gt;
  ...     print variabile&lt;br /&gt;
  ... &lt;br /&gt;
  nella tupla:  1&lt;br /&gt;
  nella tupla:  2&lt;br /&gt;
  nella tupla:  a&lt;br /&gt;
  nella tupla:  (1, 2, 3)&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
In caso volessi, nel ciclo, sapere &amp;quot;a che punto&amp;quot; della tupla (o della sequenza, in generale a che punto dell' '''iterable''') sono:&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; for indice, variabile in enumerate(miatupla):&lt;br /&gt;
  ...     print &amp;quot;elemento&amp;quot;,&lt;br /&gt;
  ...     print indice&lt;br /&gt;
  ...     print variabile&lt;br /&gt;
  ... &lt;br /&gt;
  elemento 0&lt;br /&gt;
  1&lt;br /&gt;
  elemento 1&lt;br /&gt;
  2&lt;br /&gt;
  elemento 2&lt;br /&gt;
  a&lt;br /&gt;
  elemento 3&lt;br /&gt;
  (1, 2, 3)&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; &lt;br /&gt;
&lt;br /&gt;
Iterando su un dizionario, che è un iterable, vengono resistuite le chiave, non i valori.&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miodizionario = { 'primo': 1, 'secondo': &amp;quot;golem&amp;quot;, 'terzo': [1,2,3] }&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; for chiave in miodizionario:&lt;br /&gt;
  ...     print chiave,&lt;br /&gt;
  ...     print &amp;quot;:&amp;quot;,&lt;br /&gt;
  ...     print miodizionario[chiave]&lt;br /&gt;
  ... &lt;br /&gt;
  terzo : [1, 2, 3]&lt;br /&gt;
  primo : 1&lt;br /&gt;
  secondo : golem&lt;br /&gt;
&lt;br /&gt;
Vediamo come gli elementi del dizionario non ci vengono resistuiti in un particolare ordine, anzi, non ci soono garanzie a riguardo&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; dir (miodizionario)&lt;br /&gt;
  ['__class__', '__cmp__', '__contains__', '__delattr__', '__delitem__', '__doc__', '__eq__', '__ge__',&lt;br /&gt;
   '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', &lt;br /&gt;
   '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', &lt;br /&gt;
   '__str__', 'clear', 'copy', 'fromkeys', 'get', 'has_key', 'items', 'iteritems', 'iterkeys', &lt;br /&gt;
   'itervalues', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']&lt;br /&gt;
&lt;br /&gt;
se vogliamo iterare su i valori e non sulle chiavi dobbiamo usare il metodo '''itervalues''' degli oggetti dizionario:&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; for valore in  miodizionario.itervalues():&lt;br /&gt;
  ...     print valore&lt;br /&gt;
  ... &lt;br /&gt;
  [1, 2, 3]&lt;br /&gt;
  1&lt;br /&gt;
  golem&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== '''xrange''' ==&lt;br /&gt;
&lt;br /&gt;
xrange è un iterable di dieci elementi con il primo valore uguale a 0 .E' una lista ma non ha le proprietà di una lista.&lt;br /&gt;
se io voglio fare un for da uno a dieci (cioè la somma da uno a 10)&lt;br /&gt;
&lt;br /&gt;
es:     ''for I xrange(10)&lt;br /&gt;
               print I''&lt;br /&gt;
lui stampa&lt;br /&gt;
''1&lt;br /&gt;
2&lt;br /&gt;
3&lt;br /&gt;
4&lt;br /&gt;
5&lt;br /&gt;
6&lt;br /&gt;
7&lt;br /&gt;
8&lt;br /&gt;
9&lt;br /&gt;
10''&lt;br /&gt;
&lt;br /&gt;
== '''range''' ==&lt;br /&gt;
&lt;br /&gt;
ha la stessa funzione di xrange, ovvero servire da iterable su N numeri, però ritorna non un oggetto di tipo xrange ma una lista.&lt;br /&gt;
E' più lento di xrange&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; print range(10)&lt;br /&gt;
  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== '''len''' ==&lt;br /&gt;
&lt;br /&gt;
    ''len (a)''&lt;br /&gt;
da la lunghezza della stringa&lt;br /&gt;
&lt;br /&gt;
== '''enumerate''' ==&lt;br /&gt;
&lt;br /&gt;
se io ho una lista di tre elmenti&lt;br /&gt;
''a=[“ciao”,”bel”, “mondo”]''&lt;br /&gt;
&lt;br /&gt;
''for I, elem in enumerate(a):&lt;br /&gt;
     print str(I) + “:” + elem&lt;br /&gt;
''&lt;br /&gt;
da la posizione corrente di ogni elemento.&lt;br /&gt;
''0:ciao&lt;br /&gt;
1:bel&lt;br /&gt;
2:mondo''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''raw_input''' ==&lt;br /&gt;
&lt;br /&gt;
dai il valore.&lt;br /&gt;
''Base= raw_input (“inserisce la base:”)&lt;br /&gt;
esponente=raw_input (“inserisci l'/ esponente”)''&lt;br /&gt;
&lt;br /&gt;
ti chiede il valore di base ed esponente.&lt;br /&gt;
&lt;br /&gt;
== '''Int''' ==&lt;br /&gt;
&lt;br /&gt;
forza il fatto che quel valore sia un intero.&lt;br /&gt;
''&lt;br /&gt;
Es:base=int(base)&lt;br /&gt;
  result=int(result)''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''UPPER,LOWER,CAPITALIZE''' ==&lt;br /&gt;
&lt;br /&gt;
'''capitalize''' è un comando che sulla la stringa su cui viene applicato ,prende la prima lettera dopo gli spazi e ci mette la maiuscola&lt;br /&gt;
&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.capitalize()''&lt;br /&gt;
    ''Ciao mondo''&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.title()&lt;br /&gt;
    Ciao Mondo''&lt;br /&gt;
&lt;br /&gt;
'''LOWER:''' prende la striga e emette tutto minuscolo&lt;br /&gt;
'''UPPER:''' il contrario di lower&lt;br /&gt;
&lt;br /&gt;
== '''ESEMPIO DELLA SERATA:''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Calcolo di una potenza.&lt;br /&gt;
&lt;br /&gt;
    ''&lt;br /&gt;
    base= raw_input (“inserisce la base:”)&lt;br /&gt;
    esponente=raw_input ('inserisci l\' esponente')&lt;br /&gt;
&lt;br /&gt;
    base=int(base)&lt;br /&gt;
    result=int(result)&lt;br /&gt;
&lt;br /&gt;
    result=1&lt;br /&gt;
    for i in xrange(esponente):&lt;br /&gt;
         result = result * base&lt;br /&gt;
    print result''&lt;br /&gt;
&lt;br /&gt;
il [http://docs.python.org/lib/built-in-funcs.html built-in] int() è necessario, dato che tutto quello che proviene dalla tastiera viene acquisito da raw_input() come stringa. Dato che dobbiamo usarli come interi, occorre effettuare un cast, ovvero&lt;br /&gt;
una trasformazione di tipo, da stringa a intero.&lt;br /&gt;
E' interessante notare che int() non cerca di fare i miracoli: provate a vedere cosa succede se cercate di convertire &amp;quot;awlerorj&amp;quot; in int!&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3740</id>
		<title>Python Lezione 4 Giugno 2008</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3740"/>
		<updated>2008-06-10T11:29:28Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: /* '''LE LISTE''' */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Python ==&lt;br /&gt;
[http://www.python.it/ Python] è un linguaggio di programmazione [http://it.wikipedia.org/wiki/Interprete_(informatica) interpretato].&lt;br /&gt;
Il linuaggio interpretato è simile agli altri linguaggi in circolazione ma, invece di essere trasformato direttamente in codice binario dal meccanismo automatico, viene interpretato da questo e poi mandato all'hardware.&lt;br /&gt;
Un linguaggio interpretato non ha bisogno di essere ricompilato: il codice scritto viene interpretato da un interprete a run-time (tempo di esecuzione) e tradotto al volo nel linguaggio macchina.&lt;br /&gt;
Quindi i programmi python possono girare su qualsiasi hardware e sistema operativo su cui è stato portato l'interprete. Ovviamente, questa cosa si paga sul tempo di esecuzione pure: l'approccio ha si i suoi vantaggi, ma rispetto a un linguaggio compilato direttamente in linguaggio macchina per creare un eseguibile, python e gli altri liguaggi interpretati risultano essere più lenti.&lt;br /&gt;
&lt;br /&gt;
Esistono vari interpreti: [http://www.python.org Cpython], o classic python, è l'interprete &amp;quot;ufficiale&amp;quot;, scritto in C e disponibile per linux, mac e windows.&lt;br /&gt;
[http://www.jython.org/Project/ Jython] è un interprete scritto al 100% in Java, e si interfaccia strettamente ai programmi e alla libreria Java, &lt;br /&gt;
[http://www.codeplex.com/Wiki/View.aspx?ProjectName=IronPython IronPython] è un interprete python che gira sulla piattaforma .NET mentre &lt;br /&gt;
[http://codespeak.net/pypy/dist/pypy/doc/home.html PyPy] è (anche) un interprete python scritto in.. python&lt;br /&gt;
&lt;br /&gt;
La prima riga di ogni script python deve iniziare con #!/usr/bin/env python&lt;br /&gt;
&lt;br /&gt;
il #! del file fa capire al sistema operativo (solo su sistemi posix, quindi unix/linux) che quello non è un file di testo ma un eseguibile da eseguire con l'inteprete python.&lt;br /&gt;
&lt;br /&gt;
== COMMENTI ==&lt;br /&gt;
&lt;br /&gt;
: sono righe che l'interprete salta e non legge &lt;br /&gt;
es: &lt;br /&gt;
    ''# stampa:”hello word”''&lt;br /&gt;
&lt;br /&gt;
== PRINT ==&lt;br /&gt;
Lo statement [http://docs.python.org/ref/print.html print] valuta tutte le espressioni presenti e quindi le stampa a video.&lt;br /&gt;
L'espressione da valutare può essere anche un semplice numero o una semplice stringa&lt;br /&gt;
&lt;br /&gt;
    ''print 3''&lt;br /&gt;
stampa 3, e anche se scrivo&lt;br /&gt;
    '' print “3”''&lt;br /&gt;
stampa lo stesso anche se abbiamo passato prima un intero, poi una stringa.&lt;br /&gt;
Questo è normale, perchè il numero &amp;quot;tre&amp;quot; viene rappresentato dal simbolo 3 nel sistema decimale.&lt;br /&gt;
&lt;br /&gt;
Invece, se scrivo&lt;br /&gt;
    ''print 3+2''&lt;br /&gt;
otteniamo a video 5: l'inteprete ha valutato l'espressione, ha eseguito la somma e stampato il situlato.&lt;br /&gt;
Mentre se scriviamo&lt;br /&gt;
    ''print “3+2”''&lt;br /&gt;
il risolutato è &lt;br /&gt;
    ''3+2''&lt;br /&gt;
in quanto abbiamo passato la stringa composta dal carattere 3, dal simbolo + e dal carattere 2.&lt;br /&gt;
&lt;br /&gt;
Le variabili in python non devono essere dichiarate: esistono dalla prima volta in cui gli viene assegnato un valore&lt;br /&gt;
    ''messaggio=”hello world”''&lt;br /&gt;
    ''print messaggio''&lt;br /&gt;
se questo programma viene eseguito il risultatato sarà:&lt;br /&gt;
''hello world''&lt;br /&gt;
l'interprete valuta l'espressione ''messaggio'' e stampa il suo contenuto&lt;br /&gt;
&lt;br /&gt;
== Errori e Eccezioni ==&lt;br /&gt;
&lt;br /&gt;
Commentando l'assegnamento di messaggio, vediamo che l'interprete genera un errore:&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
  jdoe@waste-bin ~ $ python&lt;br /&gt;
  Python 2.5.2 (r252:60911, May 24 2008, 15:28:31) &lt;br /&gt;
  [GCC 4.2.4 (Gentoo 4.2.4 p1.0)] on linux2&lt;br /&gt;
  Type &amp;quot;help&amp;quot;, &amp;quot;copyright&amp;quot;, &amp;quot;credits&amp;quot; or &amp;quot;license&amp;quot; for more information.&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; print messaggio&lt;br /&gt;
  Traceback (most recent call last):&lt;br /&gt;
    File &amp;quot;&amp;lt;stdin&amp;gt;&amp;quot;, line 1, in &amp;lt;module&amp;gt;&lt;br /&gt;
  NameError: name 'messaggio' is not defined&lt;br /&gt;
&lt;br /&gt;
NameError è una eccezione. Vedremo più avanti come queste situazioni di errore possono essere ''catturate'' e ''gestite'' appositamente, sia&lt;br /&gt;
per tentare di risolvere il problema che per migliorare il feedback che il nostro programma da all'utente. Vedremo anche come&lt;br /&gt;
la gestione delle eccezioni è parte della programmazione normale di un programma, ovvero non è sempre legata a una situazione di errore.&lt;br /&gt;
&lt;br /&gt;
Un altro esempio, tendando di sommare mele e pere:&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; print 1 + &amp;quot;a&amp;quot;&lt;br /&gt;
  Traceback (most recent call last):&lt;br /&gt;
    File &amp;quot;&amp;lt;stdin&amp;gt;&amp;quot;, line 1, in &amp;lt;module&amp;gt;&lt;br /&gt;
  TypeError: unsupported operand type(s) for +: 'int' and 'str'&lt;br /&gt;
&lt;br /&gt;
Vediamo che a questo giro l'eccezione lanciata è ValueError.&lt;br /&gt;
&lt;br /&gt;
== LE STRINGHE ==&lt;br /&gt;
Gli oggetti di tipo stringa supportano svariati metodi e proprietà. E' da notare che le stringhe sono immutabili.&lt;br /&gt;
Se una stringa viene dichiarata la seconda volta, quella precedente viene buttata, non viene modificata per fare spazio alla nuova.&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
    messaggio=”ciao mondo”&lt;br /&gt;
    print messaggio''&lt;br /&gt;
stampa&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
In Python non si possono sommare cose diverse, o meglio, lo posso fare solo se è definita una conversione tra i due tipo.&lt;br /&gt;
Le stringhe supportano anche alcuni operatori base:&lt;br /&gt;
    ''print messaggio*2'' &lt;br /&gt;
l'esecuzione darà&lt;br /&gt;
    ''messaggio messaggio&lt;br /&gt;
''&lt;br /&gt;
esempio:&lt;br /&gt;
     ''Print “ciao”+” mondo”''&lt;br /&gt;
lo eseguo e mi darà:&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
== '''Funzione DIR''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
    dir(messaggio)''&lt;br /&gt;
a questo punto il programma da una serie di caratteri incomprensibili.&lt;br /&gt;
Praticamente dà i '''metodi''' che suporta la stringa messaggio.&lt;br /&gt;
&lt;br /&gt;
== I '''metodi''' ==&lt;br /&gt;
sono operazioni che i vari oggetti supportano.&lt;br /&gt;
alcuni metodi, vedendo con la funzione dir(), iniziano e terminano con __ . Tali metodi, chiamati metodi speciali, non dovrebbero essere chiamati direttamente,&lt;br /&gt;
senza che ci sia una ragione specifica per farlo (ovvero: sapete quello che state facendo). In generale possono essere pensati come privati o riservati, anche se non &lt;br /&gt;
essendoci controlli di accesso come in altri linguaggi (public private del java o del c++ ad esempio) nessuno vieta di chiamarli.&lt;br /&gt;
&lt;br /&gt;
Ad esempio, il metodo __add__ delle stringhe è chiamato quando si fa la somma di due stringhe.&lt;br /&gt;
 ''&amp;quot;ciao&amp;quot; + &amp;quot; mondo&amp;quot;'' &lt;br /&gt;
chiama in realtà &lt;br /&gt;
 ''&amp;quot;ciao&amp;quot;.__add__(&amp;quot; mondo&amp;quot;)''&lt;br /&gt;
&lt;br /&gt;
''__ doc__'' ce l'hanno tutti gli oggetti (stringhe, interi...), e contiene una stringa di documentazione dell'oggetto. &lt;br /&gt;
&lt;br /&gt;
i metodi che iniziano per is servono per controllare se una certa proprietà della stringa in esame è vera:&lt;br /&gt;
es: &lt;br /&gt;
    ''messaggio.isalpha()''&lt;br /&gt;
mi dice se messaggio è o meno alfanumerico (composto solo da numeri e cifre, senza spazi, tab, ritorno carrello ecc ecc).&lt;br /&gt;
isalpha è un oggetto quindi ha le proprietà doc .&lt;br /&gt;
se io scrivo&lt;br /&gt;
    ''messaggio.isalpha.__doc__''&lt;br /&gt;
mi dice che fa.&lt;br /&gt;
&lt;br /&gt;
es:&lt;br /&gt;
    '' messaggio=”gigio”&lt;br /&gt;
    messaggio2= messaggio.upper()''&lt;br /&gt;
&lt;br /&gt;
es:&lt;br /&gt;
''TYPE(3)''&lt;br /&gt;
mi dice che variabile  è. se è intero o stringa oppure un complesso, un float o un tipo definito dall'utente.&lt;br /&gt;
Se io scrivo ''DIR(3)''&lt;br /&gt;
mi da tutta la lista dei metodi e delle proprietà degli int (dato che 3 è in intero)&lt;br /&gt;
'''&lt;br /&gt;
&lt;br /&gt;
Esistono stringhe, interi, float (numeri con virgola)booleano (che ha due valori, vero o falso, True e False)e i vari contenitori:&lt;br /&gt;
&lt;br /&gt;
== '''LE LISTE''' ==&lt;br /&gt;
&lt;br /&gt;
es. lo scaffale ha I pc, I pc sono oggetti (pc1,pc2...).Se voglio uno scaffale di pc senza dare I nomi a tutti gli oggetti, definisco lo scaffale.&lt;br /&gt;
Lo scaffale si chiama''' Lista'''  .si usano le parentesi quadre con oggetti separati da virgola&lt;br /&gt;
es.    '' a = [ “pc1” , “schermo rotto” , 2]&lt;br /&gt;
dir (scaffale)''&lt;br /&gt;
da la lista dei metodi, da qui si capisce che la lista è un oggetto.&lt;br /&gt;
Ad esempio:&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a la stringa &amp;quot;4&amp;quot;.&lt;br /&gt;
La lista, a differenza delle stringhe, è un oggetto mutabile, quindi la funzione append di fatto manipola la lista esistente per far spazio al nuovo oggetto da inserir&lt;br /&gt;
&lt;br /&gt;
Se faccio     ''print (“a”)''&lt;br /&gt;
mi da la lista degli oggetti più &amp;quot;4&amp;quot;&lt;br /&gt;
&lt;br /&gt;
Da notare che&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; mialista = []&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; mialista&lt;br /&gt;
  []&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; dir(a)&lt;br /&gt;
  ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__ge__', &lt;br /&gt;
   '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', &lt;br /&gt;
   '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__',&lt;br /&gt;
   '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__str__', 'append', 'count', 'extend', 'index', 'insert', &lt;br /&gt;
   'pop', 'remove', 'reverse', 'sort']&lt;br /&gt;
&lt;br /&gt;
Da qui vediamo che il risultato della funziona dir su una lista ritorna .. una lista.&lt;br /&gt;
&lt;br /&gt;
Vediamo come una lista può contenere qualsiasi oggetto, anche una lista o una tupla (vedi sotto)&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; mialista = [ (1,1,1), [2,2,2], 3, ([4,4,4],(4,4,4))]&lt;br /&gt;
&lt;br /&gt;
Questa è una lista di 4 oggetti, uno dei quali è una tupla, il secondo è una lista, il terzo un intero, il quarto una tupla contenente a sua volta una lista e una tupla.&lt;br /&gt;
&lt;br /&gt;
== '''TUPLE''' ==&lt;br /&gt;
&lt;br /&gt;
simile a una lista, è un contenitore di elementi. La tupla non è mutabile, per cui se definita con 4 oggetti non potrà mai contenerne 5 come non si può cambiare il&lt;br /&gt;
valore a uno degli oggetti&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miatupla = ( 1, 2,  &amp;quot;a&amp;quot; ,(1,2,3))&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miatupla&lt;br /&gt;
  (1, 2, 'a', (1, 2, 3))&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; len(miatupla)&lt;br /&gt;
  4&lt;br /&gt;
  &lt;br /&gt;
Dall'esempio vediamo come una tupla possa contenere al suo interno oggetti di vario tipo (tra cui una tupla stessa): a tal proposito&lt;br /&gt;
si vede che la lunghezza della tupla è 4 , infatti la tupla in essa contenuta - e che a sua volta contiene 3 oggetti - viene considerata&lt;br /&gt;
un unico oggetto (perchè difatto lo è.)&lt;br /&gt;
&lt;br /&gt;
Vediamo come si può accedere posizionalmente agli elementi della tupla (l'indice parte da zero)&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miatupla[0] # primo elemento&lt;br /&gt;
  1&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miatupla[2] # terzo elemento&lt;br /&gt;
  'a'&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; primo, secondo, terzo, quarto = miatupla  # scompatta la tupla in 4 variabili&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; terzo&lt;br /&gt;
  'a'&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; quarto&lt;br /&gt;
  (1, 2, 3)&lt;br /&gt;
&lt;br /&gt;
Inoltre, tentare di assegnare un nuovo valore a un elemento della tupla genera una eccezione&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miatupla[0] = 3&lt;br /&gt;
  Traceback (most recent call last):&lt;br /&gt;
    File &amp;quot;&amp;lt;stdin&amp;gt;&amp;quot;, line 1, in &amp;lt;module&amp;gt;&lt;br /&gt;
  TypeError: 'tuple' object does not support item assignment&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== '''DIZIONARI''' ==&lt;br /&gt;
&lt;br /&gt;
il dizionario si definisce con le parentesi graffe {chiave:valore, chiave:valore}&lt;br /&gt;
a{chiave}&lt;br /&gt;
da il valore associato alla chiave.&lt;br /&gt;
&lt;br /&gt;
Dizionari liste e tuple sono dele sequenze e sono iterable e si possono scorrere.&lt;br /&gt;
&lt;br /&gt;
== '''If elif else''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
if condizione :&lt;br /&gt;
&lt;br /&gt;
indentato roba da fare se vero.&lt;br /&gt;
&lt;br /&gt;
Python supporta o tab o spazio, si decide quanti tab o spazi alla prima indentazione.&lt;br /&gt;
Meglio lo spazio perchè in futuro I tab verranno lasciati.&lt;br /&gt;
Di solito si usa 4 spazi.&lt;br /&gt;
Non c'è la graffa in pyton o I begin o gli end, si chiude e si apre la riga solo se si indenta.&lt;br /&gt;
&lt;br /&gt;
Esempio:&lt;br /&gt;
    ''a=3&lt;br /&gt;
    b=1''&lt;br /&gt;
&lt;br /&gt;
    ''if a &amp;gt;b:&lt;br /&gt;
      print (“ a è maggiore di b”)&lt;br /&gt;
    elif a==b:&lt;br /&gt;
      print (“ a è uguale a b”)&lt;br /&gt;
    else:&lt;br /&gt;
       print(“b è maggiore di a”)''&lt;br /&gt;
&lt;br /&gt;
in questo programma definisco due valori, a e b.&lt;br /&gt;
Chiedo al programma se aè maggiore di b di scrivere : a è maggiore di b, se a è uguale a b di scrivere che a è uguale a b e in tutte le altre condizioni (else) di scrivere che a è minore di b.&lt;br /&gt;
&lt;br /&gt;
	'''2.is, is not or, and,!='''&lt;br /&gt;
    ''if a is 1:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
    elif a is not 1:&lt;br /&gt;
      print (“no”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 and b is 3:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 or b is 3:&lt;br /&gt;
      print (“okkei”)&lt;br /&gt;
''&lt;br /&gt;
&lt;br /&gt;
'''!= è il diverso.'''&lt;br /&gt;
&lt;br /&gt;
== '''append, insert''' ==&lt;br /&gt;
&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a il 4.&lt;br /&gt;
Se faccio print (“a”)&lt;br /&gt;
mi da la lista degli oggetti più il 4.&lt;br /&gt;
&lt;br /&gt;
con '''insert''' devo inserire anche la posizione&lt;br /&gt;
    ''a.insert(2,34)''&lt;br /&gt;
mette il 34 in posizione 2&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''for''' ==&lt;br /&gt;
&lt;br /&gt;
specifica un ciclo, fa le cose tante volte fino ad una condizione.&lt;br /&gt;
For variabile in una sequenza di qualche tipo.&lt;br /&gt;
Es:     ''for elemento in a:&lt;br /&gt;
               print elemento''&lt;br /&gt;
&lt;br /&gt;
es b è una tupla.&lt;br /&gt;
Allora posso scrivere:&lt;br /&gt;
    ''for elem in b&lt;br /&gt;
         print “altro elemento”&lt;br /&gt;
         “print elem”''&lt;br /&gt;
&lt;br /&gt;
elem o qualsiasi altro nome gli dia è ogni elemento dentro la tupla o lista o dizionario.&lt;br /&gt;
&lt;br /&gt;
Se io voglio sia la chiave sia il valore in un dizionario (se metto elem mi mette solo la chiave) posso fare:&lt;br /&gt;
for chiave in a:&lt;br /&gt;
	    ''print “chiave: “ + chiave&lt;br /&gt;
	    print “valore: “ + a[chiave]''&lt;br /&gt;
&lt;br /&gt;
'''DOPO I DUE PUNTI METTO SEMPRE IL TAB.'''&lt;br /&gt;
&lt;br /&gt;
== '''xrange''' ==&lt;br /&gt;
&lt;br /&gt;
xrange è un iterable di dieci elementi con il primo valore uguale a 0 .E' una lista ma non ha le proprietà di una lista.&lt;br /&gt;
se io voglio fare un for da uno a dieci (cioè la somma da uno a 10)&lt;br /&gt;
&lt;br /&gt;
es:     ''for I xrange(10)&lt;br /&gt;
               print I''&lt;br /&gt;
lui stampa&lt;br /&gt;
''1&lt;br /&gt;
2&lt;br /&gt;
3&lt;br /&gt;
4&lt;br /&gt;
5&lt;br /&gt;
6&lt;br /&gt;
7&lt;br /&gt;
8&lt;br /&gt;
9&lt;br /&gt;
10''&lt;br /&gt;
&lt;br /&gt;
== '''range''' ==&lt;br /&gt;
&lt;br /&gt;
ha la stessa funzione di xrange, ovvero servire da iterable su N numeri, però ritorna non un oggetto di tipo xrange ma una lista.&lt;br /&gt;
E' più lento di xrange&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; print range(10)&lt;br /&gt;
  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== '''len''' ==&lt;br /&gt;
&lt;br /&gt;
    ''len (a)''&lt;br /&gt;
da la lunghezza della stringa&lt;br /&gt;
&lt;br /&gt;
== '''enumerate''' ==&lt;br /&gt;
&lt;br /&gt;
se io ho una lista di tre elmenti&lt;br /&gt;
''a=[“ciao”,”bel”, “mondo”]''&lt;br /&gt;
&lt;br /&gt;
''for I, elem in enumerate(a):&lt;br /&gt;
     print str(I) + “:” + elem&lt;br /&gt;
''&lt;br /&gt;
da la posizione corrente di ogni elemento.&lt;br /&gt;
''0:ciao&lt;br /&gt;
1:bel&lt;br /&gt;
2:mondo''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''raw_input''' ==&lt;br /&gt;
&lt;br /&gt;
dai il valore.&lt;br /&gt;
''Base= raw_input (“inserisce la base:”)&lt;br /&gt;
esponente=raw_input (“inserisci l'/ esponente”)''&lt;br /&gt;
&lt;br /&gt;
ti chiede il valore di base ed esponente.&lt;br /&gt;
&lt;br /&gt;
== '''Int''' ==&lt;br /&gt;
&lt;br /&gt;
forza il fatto che quel valore sia un intero.&lt;br /&gt;
''&lt;br /&gt;
Es:base=int(base)&lt;br /&gt;
  result=int(result)''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''UPPER,LOWER,CAPITALIZE''' ==&lt;br /&gt;
&lt;br /&gt;
'''capitalize''' è un comando che sulla la stringa su cui viene applicato ,prende la prima lettera dopo gli spazi e ci mette la maiuscola&lt;br /&gt;
&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.capitalize()''&lt;br /&gt;
    ''Ciao mondo''&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.title()&lt;br /&gt;
    Ciao Mondo''&lt;br /&gt;
&lt;br /&gt;
'''LOWER:''' prende la striga e emette tutto minuscolo&lt;br /&gt;
'''UPPER:''' il contrario di lower&lt;br /&gt;
&lt;br /&gt;
== '''ESEMPIO DELLA SERATA:''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Calcolo di una potenza.&lt;br /&gt;
&lt;br /&gt;
    ''&lt;br /&gt;
    base= raw_input (“inserisce la base:”)&lt;br /&gt;
    esponente=raw_input ('inserisci l\' esponente')&lt;br /&gt;
&lt;br /&gt;
    base=int(base)&lt;br /&gt;
    result=int(result)&lt;br /&gt;
&lt;br /&gt;
    result=1&lt;br /&gt;
    for i in xrange(esponente):&lt;br /&gt;
         result = result * base&lt;br /&gt;
    print result''&lt;br /&gt;
&lt;br /&gt;
il [http://docs.python.org/lib/built-in-funcs.html built-in] int() è necessario, dato che tutto quello che proviene dalla tastiera viene acquisito da raw_input() come stringa. Dato che dobbiamo usarli come interi, occorre effettuare un cast, ovvero&lt;br /&gt;
una trasformazione di tipo, da stringa a intero.&lt;br /&gt;
E' interessante notare che int() non cerca di fare i miracoli: provate a vedere cosa succede se cercate di convertire &amp;quot;awlerorj&amp;quot; in int!&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3739</id>
		<title>Python Lezione 4 Giugno 2008</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3739"/>
		<updated>2008-06-10T11:24:22Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: /* '''TUPLE''' */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Python ==&lt;br /&gt;
[http://www.python.it/ Python] è un linguaggio di programmazione [http://it.wikipedia.org/wiki/Interprete_(informatica) interpretato].&lt;br /&gt;
Il linuaggio interpretato è simile agli altri linguaggi in circolazione ma, invece di essere trasformato direttamente in codice binario dal meccanismo automatico, viene interpretato da questo e poi mandato all'hardware.&lt;br /&gt;
Un linguaggio interpretato non ha bisogno di essere ricompilato: il codice scritto viene interpretato da un interprete a run-time (tempo di esecuzione) e tradotto al volo nel linguaggio macchina.&lt;br /&gt;
Quindi i programmi python possono girare su qualsiasi hardware e sistema operativo su cui è stato portato l'interprete. Ovviamente, questa cosa si paga sul tempo di esecuzione pure: l'approccio ha si i suoi vantaggi, ma rispetto a un linguaggio compilato direttamente in linguaggio macchina per creare un eseguibile, python e gli altri liguaggi interpretati risultano essere più lenti.&lt;br /&gt;
&lt;br /&gt;
Esistono vari interpreti: [http://www.python.org Cpython], o classic python, è l'interprete &amp;quot;ufficiale&amp;quot;, scritto in C e disponibile per linux, mac e windows.&lt;br /&gt;
[http://www.jython.org/Project/ Jython] è un interprete scritto al 100% in Java, e si interfaccia strettamente ai programmi e alla libreria Java, &lt;br /&gt;
[http://www.codeplex.com/Wiki/View.aspx?ProjectName=IronPython IronPython] è un interprete python che gira sulla piattaforma .NET mentre &lt;br /&gt;
[http://codespeak.net/pypy/dist/pypy/doc/home.html PyPy] è (anche) un interprete python scritto in.. python&lt;br /&gt;
&lt;br /&gt;
La prima riga di ogni script python deve iniziare con #!/usr/bin/env python&lt;br /&gt;
&lt;br /&gt;
il #! del file fa capire al sistema operativo (solo su sistemi posix, quindi unix/linux) che quello non è un file di testo ma un eseguibile da eseguire con l'inteprete python.&lt;br /&gt;
&lt;br /&gt;
== COMMENTI ==&lt;br /&gt;
&lt;br /&gt;
: sono righe che l'interprete salta e non legge &lt;br /&gt;
es: &lt;br /&gt;
    ''# stampa:”hello word”''&lt;br /&gt;
&lt;br /&gt;
== PRINT ==&lt;br /&gt;
Lo statement [http://docs.python.org/ref/print.html print] valuta tutte le espressioni presenti e quindi le stampa a video.&lt;br /&gt;
L'espressione da valutare può essere anche un semplice numero o una semplice stringa&lt;br /&gt;
&lt;br /&gt;
    ''print 3''&lt;br /&gt;
stampa 3, e anche se scrivo&lt;br /&gt;
    '' print “3”''&lt;br /&gt;
stampa lo stesso anche se abbiamo passato prima un intero, poi una stringa.&lt;br /&gt;
Questo è normale, perchè il numero &amp;quot;tre&amp;quot; viene rappresentato dal simbolo 3 nel sistema decimale.&lt;br /&gt;
&lt;br /&gt;
Invece, se scrivo&lt;br /&gt;
    ''print 3+2''&lt;br /&gt;
otteniamo a video 5: l'inteprete ha valutato l'espressione, ha eseguito la somma e stampato il situlato.&lt;br /&gt;
Mentre se scriviamo&lt;br /&gt;
    ''print “3+2”''&lt;br /&gt;
il risolutato è &lt;br /&gt;
    ''3+2''&lt;br /&gt;
in quanto abbiamo passato la stringa composta dal carattere 3, dal simbolo + e dal carattere 2.&lt;br /&gt;
&lt;br /&gt;
Le variabili in python non devono essere dichiarate: esistono dalla prima volta in cui gli viene assegnato un valore&lt;br /&gt;
    ''messaggio=”hello world”''&lt;br /&gt;
    ''print messaggio''&lt;br /&gt;
se questo programma viene eseguito il risultatato sarà:&lt;br /&gt;
''hello world''&lt;br /&gt;
l'interprete valuta l'espressione ''messaggio'' e stampa il suo contenuto&lt;br /&gt;
&lt;br /&gt;
== Errori e Eccezioni ==&lt;br /&gt;
&lt;br /&gt;
Commentando l'assegnamento di messaggio, vediamo che l'interprete genera un errore:&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
  jdoe@waste-bin ~ $ python&lt;br /&gt;
  Python 2.5.2 (r252:60911, May 24 2008, 15:28:31) &lt;br /&gt;
  [GCC 4.2.4 (Gentoo 4.2.4 p1.0)] on linux2&lt;br /&gt;
  Type &amp;quot;help&amp;quot;, &amp;quot;copyright&amp;quot;, &amp;quot;credits&amp;quot; or &amp;quot;license&amp;quot; for more information.&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; print messaggio&lt;br /&gt;
  Traceback (most recent call last):&lt;br /&gt;
    File &amp;quot;&amp;lt;stdin&amp;gt;&amp;quot;, line 1, in &amp;lt;module&amp;gt;&lt;br /&gt;
  NameError: name 'messaggio' is not defined&lt;br /&gt;
&lt;br /&gt;
NameError è una eccezione. Vedremo più avanti come queste situazioni di errore possono essere ''catturate'' e ''gestite'' appositamente, sia&lt;br /&gt;
per tentare di risolvere il problema che per migliorare il feedback che il nostro programma da all'utente. Vedremo anche come&lt;br /&gt;
la gestione delle eccezioni è parte della programmazione normale di un programma, ovvero non è sempre legata a una situazione di errore.&lt;br /&gt;
&lt;br /&gt;
Un altro esempio, tendando di sommare mele e pere:&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; print 1 + &amp;quot;a&amp;quot;&lt;br /&gt;
  Traceback (most recent call last):&lt;br /&gt;
    File &amp;quot;&amp;lt;stdin&amp;gt;&amp;quot;, line 1, in &amp;lt;module&amp;gt;&lt;br /&gt;
  TypeError: unsupported operand type(s) for +: 'int' and 'str'&lt;br /&gt;
&lt;br /&gt;
Vediamo che a questo giro l'eccezione lanciata è ValueError.&lt;br /&gt;
&lt;br /&gt;
== LE STRINGHE ==&lt;br /&gt;
Gli oggetti di tipo stringa supportano svariati metodi e proprietà. E' da notare che le stringhe sono immutabili.&lt;br /&gt;
Se una stringa viene dichiarata la seconda volta, quella precedente viene buttata, non viene modificata per fare spazio alla nuova.&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
    messaggio=”ciao mondo”&lt;br /&gt;
    print messaggio''&lt;br /&gt;
stampa&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
In Python non si possono sommare cose diverse, o meglio, lo posso fare solo se è definita una conversione tra i due tipo.&lt;br /&gt;
Le stringhe supportano anche alcuni operatori base:&lt;br /&gt;
    ''print messaggio*2'' &lt;br /&gt;
l'esecuzione darà&lt;br /&gt;
    ''messaggio messaggio&lt;br /&gt;
''&lt;br /&gt;
esempio:&lt;br /&gt;
     ''Print “ciao”+” mondo”''&lt;br /&gt;
lo eseguo e mi darà:&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
== '''Funzione DIR''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
    dir(messaggio)''&lt;br /&gt;
a questo punto il programma da una serie di caratteri incomprensibili.&lt;br /&gt;
Praticamente dà i '''metodi''' che suporta la stringa messaggio.&lt;br /&gt;
&lt;br /&gt;
== I '''metodi''' ==&lt;br /&gt;
sono operazioni che i vari oggetti supportano.&lt;br /&gt;
alcuni metodi, vedendo con la funzione dir(), iniziano e terminano con __ . Tali metodi, chiamati metodi speciali, non dovrebbero essere chiamati direttamente,&lt;br /&gt;
senza che ci sia una ragione specifica per farlo (ovvero: sapete quello che state facendo). In generale possono essere pensati come privati o riservati, anche se non &lt;br /&gt;
essendoci controlli di accesso come in altri linguaggi (public private del java o del c++ ad esempio) nessuno vieta di chiamarli.&lt;br /&gt;
&lt;br /&gt;
Ad esempio, il metodo __add__ delle stringhe è chiamato quando si fa la somma di due stringhe.&lt;br /&gt;
 ''&amp;quot;ciao&amp;quot; + &amp;quot; mondo&amp;quot;'' &lt;br /&gt;
chiama in realtà &lt;br /&gt;
 ''&amp;quot;ciao&amp;quot;.__add__(&amp;quot; mondo&amp;quot;)''&lt;br /&gt;
&lt;br /&gt;
''__ doc__'' ce l'hanno tutti gli oggetti (stringhe, interi...), e contiene una stringa di documentazione dell'oggetto. &lt;br /&gt;
&lt;br /&gt;
i metodi che iniziano per is servono per controllare se una certa proprietà della stringa in esame è vera:&lt;br /&gt;
es: &lt;br /&gt;
    ''messaggio.isalpha()''&lt;br /&gt;
mi dice se messaggio è o meno alfanumerico (composto solo da numeri e cifre, senza spazi, tab, ritorno carrello ecc ecc).&lt;br /&gt;
isalpha è un oggetto quindi ha le proprietà doc .&lt;br /&gt;
se io scrivo&lt;br /&gt;
    ''messaggio.isalpha.__doc__''&lt;br /&gt;
mi dice che fa.&lt;br /&gt;
&lt;br /&gt;
es:&lt;br /&gt;
    '' messaggio=”gigio”&lt;br /&gt;
    messaggio2= messaggio.upper()''&lt;br /&gt;
&lt;br /&gt;
es:&lt;br /&gt;
''TYPE(3)''&lt;br /&gt;
mi dice che variabile  è. se è intero o stringa oppure un complesso, un float o un tipo definito dall'utente.&lt;br /&gt;
Se io scrivo ''DIR(3)''&lt;br /&gt;
mi da tutta la lista dei metodi e delle proprietà degli int (dato che 3 è in intero)&lt;br /&gt;
'''&lt;br /&gt;
&lt;br /&gt;
Esistono stringhe, interi, float (numeri con virgola)booleano (che ha due valori, vero o falso, True e False)e i vari contenitori:&lt;br /&gt;
&lt;br /&gt;
== '''LE LISTE''' ==&lt;br /&gt;
&lt;br /&gt;
es. lo scaffale ha I pc, I pc sono oggetti (pc1,pc2...).Se voglio uno scaffale di pc senza dare I nomi a tutti gli oggetti, definisco lo scaffale.&lt;br /&gt;
Lo scaffale si chiama''' Lista'''  .si usano le parentesi quadre con oggetti separati da virgola&lt;br /&gt;
es.    '' a = [ “pc1” , “schermo rotto” , 2]&lt;br /&gt;
dir (scaffale)''&lt;br /&gt;
da la lista dei metodi, da qui si capisce che la lista è un oggetto.&lt;br /&gt;
Ad esempio:&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a la stringa &amp;quot;4&amp;quot;.&lt;br /&gt;
La lista, a differenza delle stringhe, è un oggetto mutabile, quindi la funzione append di fatto manipola la lista esistente per far spazio al nuovo oggetto da inserir&lt;br /&gt;
&lt;br /&gt;
Se faccio     ''print (“a”)''&lt;br /&gt;
mi da la lista degli oggetti più &amp;quot;4&amp;quot;&lt;br /&gt;
&lt;br /&gt;
Da notare che&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; mialista = []&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; mialista&lt;br /&gt;
  []&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; dir(a)&lt;br /&gt;
  ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__ge__', &lt;br /&gt;
   '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', &lt;br /&gt;
   '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__',&lt;br /&gt;
   '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__str__', 'append', 'count', 'extend', 'index', 'insert', &lt;br /&gt;
   'pop', 'remove', 'reverse', 'sort']&lt;br /&gt;
&lt;br /&gt;
Da qui vediamo che il risultato della funziona dir su una lista ritorna .. una lista.&lt;br /&gt;
&lt;br /&gt;
== '''TUPLE''' ==&lt;br /&gt;
&lt;br /&gt;
simile a una lista, è un contenitore di elementi. La tupla non è mutabile, per cui se definita con 4 oggetti non potrà mai contenerne 5 come non si può cambiare il&lt;br /&gt;
valore a uno degli oggetti&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miatupla = ( 1, 2,  &amp;quot;a&amp;quot; ,(1,2,3))&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miatupla&lt;br /&gt;
  (1, 2, 'a', (1, 2, 3))&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; len(miatupla)&lt;br /&gt;
  4&lt;br /&gt;
  &lt;br /&gt;
Dall'esempio vediamo come una tupla possa contenere al suo interno oggetti di vario tipo (tra cui una tupla stessa): a tal proposito&lt;br /&gt;
si vede che la lunghezza della tupla è 4 , infatti la tupla in essa contenuta - e che a sua volta contiene 3 oggetti - viene considerata&lt;br /&gt;
un unico oggetto (perchè difatto lo è.)&lt;br /&gt;
&lt;br /&gt;
Vediamo come si può accedere posizionalmente agli elementi della tupla (l'indice parte da zero)&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miatupla[0] # primo elemento&lt;br /&gt;
  1&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miatupla[2] # terzo elemento&lt;br /&gt;
  'a'&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; primo, secondo, terzo, quarto = miatupla  # scompatta la tupla in 4 variabili&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; terzo&lt;br /&gt;
  'a'&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; quarto&lt;br /&gt;
  (1, 2, 3)&lt;br /&gt;
&lt;br /&gt;
Inoltre, tentare di assegnare un nuovo valore a un elemento della tupla genera una eccezione&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; miatupla[0] = 3&lt;br /&gt;
  Traceback (most recent call last):&lt;br /&gt;
    File &amp;quot;&amp;lt;stdin&amp;gt;&amp;quot;, line 1, in &amp;lt;module&amp;gt;&lt;br /&gt;
  TypeError: 'tuple' object does not support item assignment&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== '''DIZIONARI''' ==&lt;br /&gt;
&lt;br /&gt;
il dizionario si definisce con le parentesi graffe {chiave:valore, chiave:valore}&lt;br /&gt;
a{chiave}&lt;br /&gt;
da il valore associato alla chiave.&lt;br /&gt;
&lt;br /&gt;
Dizionari liste e tuple sono dele sequenze e sono iterable e si possono scorrere.&lt;br /&gt;
&lt;br /&gt;
== '''If elif else''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
if condizione :&lt;br /&gt;
&lt;br /&gt;
indentato roba da fare se vero.&lt;br /&gt;
&lt;br /&gt;
Python supporta o tab o spazio, si decide quanti tab o spazi alla prima indentazione.&lt;br /&gt;
Meglio lo spazio perchè in futuro I tab verranno lasciati.&lt;br /&gt;
Di solito si usa 4 spazi.&lt;br /&gt;
Non c'è la graffa in pyton o I begin o gli end, si chiude e si apre la riga solo se si indenta.&lt;br /&gt;
&lt;br /&gt;
Esempio:&lt;br /&gt;
    ''a=3&lt;br /&gt;
    b=1''&lt;br /&gt;
&lt;br /&gt;
    ''if a &amp;gt;b:&lt;br /&gt;
      print (“ a è maggiore di b”)&lt;br /&gt;
    elif a==b:&lt;br /&gt;
      print (“ a è uguale a b”)&lt;br /&gt;
    else:&lt;br /&gt;
       print(“b è maggiore di a”)''&lt;br /&gt;
&lt;br /&gt;
in questo programma definisco due valori, a e b.&lt;br /&gt;
Chiedo al programma se aè maggiore di b di scrivere : a è maggiore di b, se a è uguale a b di scrivere che a è uguale a b e in tutte le altre condizioni (else) di scrivere che a è minore di b.&lt;br /&gt;
&lt;br /&gt;
	'''2.is, is not or, and,!='''&lt;br /&gt;
    ''if a is 1:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
    elif a is not 1:&lt;br /&gt;
      print (“no”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 and b is 3:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 or b is 3:&lt;br /&gt;
      print (“okkei”)&lt;br /&gt;
''&lt;br /&gt;
&lt;br /&gt;
'''!= è il diverso.'''&lt;br /&gt;
&lt;br /&gt;
== '''append, insert''' ==&lt;br /&gt;
&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a il 4.&lt;br /&gt;
Se faccio print (“a”)&lt;br /&gt;
mi da la lista degli oggetti più il 4.&lt;br /&gt;
&lt;br /&gt;
con '''insert''' devo inserire anche la posizione&lt;br /&gt;
    ''a.insert(2,34)''&lt;br /&gt;
mette il 34 in posizione 2&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''for''' ==&lt;br /&gt;
&lt;br /&gt;
specifica un ciclo, fa le cose tante volte fino ad una condizione.&lt;br /&gt;
For variabile in una sequenza di qualche tipo.&lt;br /&gt;
Es:     ''for elemento in a:&lt;br /&gt;
               print elemento''&lt;br /&gt;
&lt;br /&gt;
es b è una tupla.&lt;br /&gt;
Allora posso scrivere:&lt;br /&gt;
    ''for elem in b&lt;br /&gt;
         print “altro elemento”&lt;br /&gt;
         “print elem”''&lt;br /&gt;
&lt;br /&gt;
elem o qualsiasi altro nome gli dia è ogni elemento dentro la tupla o lista o dizionario.&lt;br /&gt;
&lt;br /&gt;
Se io voglio sia la chiave sia il valore in un dizionario (se metto elem mi mette solo la chiave) posso fare:&lt;br /&gt;
for chiave in a:&lt;br /&gt;
	    ''print “chiave: “ + chiave&lt;br /&gt;
	    print “valore: “ + a[chiave]''&lt;br /&gt;
&lt;br /&gt;
'''DOPO I DUE PUNTI METTO SEMPRE IL TAB.'''&lt;br /&gt;
&lt;br /&gt;
== '''xrange''' ==&lt;br /&gt;
&lt;br /&gt;
xrange è un iterable di dieci elementi con il primo valore uguale a 0 .E' una lista ma non ha le proprietà di una lista.&lt;br /&gt;
se io voglio fare un for da uno a dieci (cioè la somma da uno a 10)&lt;br /&gt;
&lt;br /&gt;
es:     ''for I xrange(10)&lt;br /&gt;
               print I''&lt;br /&gt;
lui stampa&lt;br /&gt;
''1&lt;br /&gt;
2&lt;br /&gt;
3&lt;br /&gt;
4&lt;br /&gt;
5&lt;br /&gt;
6&lt;br /&gt;
7&lt;br /&gt;
8&lt;br /&gt;
9&lt;br /&gt;
10''&lt;br /&gt;
&lt;br /&gt;
== '''range''' ==&lt;br /&gt;
&lt;br /&gt;
ha la stessa funzione di xrange, ovvero servire da iterable su N numeri, però ritorna non un oggetto di tipo xrange ma una lista.&lt;br /&gt;
E' più lento di xrange&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; print range(10)&lt;br /&gt;
  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== '''len''' ==&lt;br /&gt;
&lt;br /&gt;
    ''len (a)''&lt;br /&gt;
da la lunghezza della stringa&lt;br /&gt;
&lt;br /&gt;
== '''enumerate''' ==&lt;br /&gt;
&lt;br /&gt;
se io ho una lista di tre elmenti&lt;br /&gt;
''a=[“ciao”,”bel”, “mondo”]''&lt;br /&gt;
&lt;br /&gt;
''for I, elem in enumerate(a):&lt;br /&gt;
     print str(I) + “:” + elem&lt;br /&gt;
''&lt;br /&gt;
da la posizione corrente di ogni elemento.&lt;br /&gt;
''0:ciao&lt;br /&gt;
1:bel&lt;br /&gt;
2:mondo''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''raw_input''' ==&lt;br /&gt;
&lt;br /&gt;
dai il valore.&lt;br /&gt;
''Base= raw_input (“inserisce la base:”)&lt;br /&gt;
esponente=raw_input (“inserisci l'/ esponente”)''&lt;br /&gt;
&lt;br /&gt;
ti chiede il valore di base ed esponente.&lt;br /&gt;
&lt;br /&gt;
== '''Int''' ==&lt;br /&gt;
&lt;br /&gt;
forza il fatto che quel valore sia un intero.&lt;br /&gt;
''&lt;br /&gt;
Es:base=int(base)&lt;br /&gt;
  result=int(result)''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''UPPER,LOWER,CAPITALIZE''' ==&lt;br /&gt;
&lt;br /&gt;
'''capitalize''' è un comando che sulla la stringa su cui viene applicato ,prende la prima lettera dopo gli spazi e ci mette la maiuscola&lt;br /&gt;
&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.capitalize()''&lt;br /&gt;
    ''Ciao mondo''&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.title()&lt;br /&gt;
    Ciao Mondo''&lt;br /&gt;
&lt;br /&gt;
'''LOWER:''' prende la striga e emette tutto minuscolo&lt;br /&gt;
'''UPPER:''' il contrario di lower&lt;br /&gt;
&lt;br /&gt;
== '''ESEMPIO DELLA SERATA:''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Calcolo di una potenza.&lt;br /&gt;
&lt;br /&gt;
    ''&lt;br /&gt;
    base= raw_input (“inserisce la base:”)&lt;br /&gt;
    esponente=raw_input ('inserisci l\' esponente')&lt;br /&gt;
&lt;br /&gt;
    base=int(base)&lt;br /&gt;
    result=int(result)&lt;br /&gt;
&lt;br /&gt;
    result=1&lt;br /&gt;
    for i in xrange(esponente):&lt;br /&gt;
         result = result * base&lt;br /&gt;
    print result''&lt;br /&gt;
&lt;br /&gt;
il [http://docs.python.org/lib/built-in-funcs.html built-in] int() è necessario, dato che tutto quello che proviene dalla tastiera viene acquisito da raw_input() come stringa. Dato che dobbiamo usarli come interi, occorre effettuare un cast, ovvero&lt;br /&gt;
una trasformazione di tipo, da stringa a intero.&lt;br /&gt;
E' interessante notare che int() non cerca di fare i miracoli: provate a vedere cosa succede se cercate di convertire &amp;quot;awlerorj&amp;quot; in int!&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3738</id>
		<title>Python Lezione 4 Giugno 2008</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3738"/>
		<updated>2008-06-10T11:16:58Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: /* '''LE LISTE''' */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Python ==&lt;br /&gt;
[http://www.python.it/ Python] è un linguaggio di programmazione [http://it.wikipedia.org/wiki/Interprete_(informatica) interpretato].&lt;br /&gt;
Il linuaggio interpretato è simile agli altri linguaggi in circolazione ma, invece di essere trasformato direttamente in codice binario dal meccanismo automatico, viene interpretato da questo e poi mandato all'hardware.&lt;br /&gt;
Un linguaggio interpretato non ha bisogno di essere ricompilato: il codice scritto viene interpretato da un interprete a run-time (tempo di esecuzione) e tradotto al volo nel linguaggio macchina.&lt;br /&gt;
Quindi i programmi python possono girare su qualsiasi hardware e sistema operativo su cui è stato portato l'interprete. Ovviamente, questa cosa si paga sul tempo di esecuzione pure: l'approccio ha si i suoi vantaggi, ma rispetto a un linguaggio compilato direttamente in linguaggio macchina per creare un eseguibile, python e gli altri liguaggi interpretati risultano essere più lenti.&lt;br /&gt;
&lt;br /&gt;
Esistono vari interpreti: [http://www.python.org Cpython], o classic python, è l'interprete &amp;quot;ufficiale&amp;quot;, scritto in C e disponibile per linux, mac e windows.&lt;br /&gt;
[http://www.jython.org/Project/ Jython] è un interprete scritto al 100% in Java, e si interfaccia strettamente ai programmi e alla libreria Java, &lt;br /&gt;
[http://www.codeplex.com/Wiki/View.aspx?ProjectName=IronPython IronPython] è un interprete python che gira sulla piattaforma .NET mentre &lt;br /&gt;
[http://codespeak.net/pypy/dist/pypy/doc/home.html PyPy] è (anche) un interprete python scritto in.. python&lt;br /&gt;
&lt;br /&gt;
La prima riga di ogni script python deve iniziare con #!/usr/bin/env python&lt;br /&gt;
&lt;br /&gt;
il #! del file fa capire al sistema operativo (solo su sistemi posix, quindi unix/linux) che quello non è un file di testo ma un eseguibile da eseguire con l'inteprete python.&lt;br /&gt;
&lt;br /&gt;
== COMMENTI ==&lt;br /&gt;
&lt;br /&gt;
: sono righe che l'interprete salta e non legge &lt;br /&gt;
es: &lt;br /&gt;
    ''# stampa:”hello word”''&lt;br /&gt;
&lt;br /&gt;
== PRINT ==&lt;br /&gt;
Lo statement [http://docs.python.org/ref/print.html print] valuta tutte le espressioni presenti e quindi le stampa a video.&lt;br /&gt;
L'espressione da valutare può essere anche un semplice numero o una semplice stringa&lt;br /&gt;
&lt;br /&gt;
    ''print 3''&lt;br /&gt;
stampa 3, e anche se scrivo&lt;br /&gt;
    '' print “3”''&lt;br /&gt;
stampa lo stesso anche se abbiamo passato prima un intero, poi una stringa.&lt;br /&gt;
Questo è normale, perchè il numero &amp;quot;tre&amp;quot; viene rappresentato dal simbolo 3 nel sistema decimale.&lt;br /&gt;
&lt;br /&gt;
Invece, se scrivo&lt;br /&gt;
    ''print 3+2''&lt;br /&gt;
otteniamo a video 5: l'inteprete ha valutato l'espressione, ha eseguito la somma e stampato il situlato.&lt;br /&gt;
Mentre se scriviamo&lt;br /&gt;
    ''print “3+2”''&lt;br /&gt;
il risolutato è &lt;br /&gt;
    ''3+2''&lt;br /&gt;
in quanto abbiamo passato la stringa composta dal carattere 3, dal simbolo + e dal carattere 2.&lt;br /&gt;
&lt;br /&gt;
Le variabili in python non devono essere dichiarate: esistono dalla prima volta in cui gli viene assegnato un valore&lt;br /&gt;
    ''messaggio=”hello world”''&lt;br /&gt;
    ''print messaggio''&lt;br /&gt;
se questo programma viene eseguito il risultatato sarà:&lt;br /&gt;
''hello world''&lt;br /&gt;
l'interprete valuta l'espressione ''messaggio'' e stampa il suo contenuto&lt;br /&gt;
&lt;br /&gt;
== Errori e Eccezioni ==&lt;br /&gt;
&lt;br /&gt;
Commentando l'assegnamento di messaggio, vediamo che l'interprete genera un errore:&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
  jdoe@waste-bin ~ $ python&lt;br /&gt;
  Python 2.5.2 (r252:60911, May 24 2008, 15:28:31) &lt;br /&gt;
  [GCC 4.2.4 (Gentoo 4.2.4 p1.0)] on linux2&lt;br /&gt;
  Type &amp;quot;help&amp;quot;, &amp;quot;copyright&amp;quot;, &amp;quot;credits&amp;quot; or &amp;quot;license&amp;quot; for more information.&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; print messaggio&lt;br /&gt;
  Traceback (most recent call last):&lt;br /&gt;
    File &amp;quot;&amp;lt;stdin&amp;gt;&amp;quot;, line 1, in &amp;lt;module&amp;gt;&lt;br /&gt;
  NameError: name 'messaggio' is not defined&lt;br /&gt;
&lt;br /&gt;
NameError è una eccezione. Vedremo più avanti come queste situazioni di errore possono essere ''catturate'' e ''gestite'' appositamente, sia&lt;br /&gt;
per tentare di risolvere il problema che per migliorare il feedback che il nostro programma da all'utente. Vedremo anche come&lt;br /&gt;
la gestione delle eccezioni è parte della programmazione normale di un programma, ovvero non è sempre legata a una situazione di errore.&lt;br /&gt;
&lt;br /&gt;
Un altro esempio, tendando di sommare mele e pere:&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; print 1 + &amp;quot;a&amp;quot;&lt;br /&gt;
  Traceback (most recent call last):&lt;br /&gt;
    File &amp;quot;&amp;lt;stdin&amp;gt;&amp;quot;, line 1, in &amp;lt;module&amp;gt;&lt;br /&gt;
  TypeError: unsupported operand type(s) for +: 'int' and 'str'&lt;br /&gt;
&lt;br /&gt;
Vediamo che a questo giro l'eccezione lanciata è ValueError.&lt;br /&gt;
&lt;br /&gt;
== LE STRINGHE ==&lt;br /&gt;
Gli oggetti di tipo stringa supportano svariati metodi e proprietà. E' da notare che le stringhe sono immutabili.&lt;br /&gt;
Se una stringa viene dichiarata la seconda volta, quella precedente viene buttata, non viene modificata per fare spazio alla nuova.&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
    messaggio=”ciao mondo”&lt;br /&gt;
    print messaggio''&lt;br /&gt;
stampa&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
In Python non si possono sommare cose diverse, o meglio, lo posso fare solo se è definita una conversione tra i due tipo.&lt;br /&gt;
Le stringhe supportano anche alcuni operatori base:&lt;br /&gt;
    ''print messaggio*2'' &lt;br /&gt;
l'esecuzione darà&lt;br /&gt;
    ''messaggio messaggio&lt;br /&gt;
''&lt;br /&gt;
esempio:&lt;br /&gt;
     ''Print “ciao”+” mondo”''&lt;br /&gt;
lo eseguo e mi darà:&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
== '''Funzione DIR''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
    dir(messaggio)''&lt;br /&gt;
a questo punto il programma da una serie di caratteri incomprensibili.&lt;br /&gt;
Praticamente dà i '''metodi''' che suporta la stringa messaggio.&lt;br /&gt;
&lt;br /&gt;
== I '''metodi''' ==&lt;br /&gt;
sono operazioni che i vari oggetti supportano.&lt;br /&gt;
alcuni metodi, vedendo con la funzione dir(), iniziano e terminano con __ . Tali metodi, chiamati metodi speciali, non dovrebbero essere chiamati direttamente,&lt;br /&gt;
senza che ci sia una ragione specifica per farlo (ovvero: sapete quello che state facendo). In generale possono essere pensati come privati o riservati, anche se non &lt;br /&gt;
essendoci controlli di accesso come in altri linguaggi (public private del java o del c++ ad esempio) nessuno vieta di chiamarli.&lt;br /&gt;
&lt;br /&gt;
Ad esempio, il metodo __add__ delle stringhe è chiamato quando si fa la somma di due stringhe.&lt;br /&gt;
 ''&amp;quot;ciao&amp;quot; + &amp;quot; mondo&amp;quot;'' &lt;br /&gt;
chiama in realtà &lt;br /&gt;
 ''&amp;quot;ciao&amp;quot;.__add__(&amp;quot; mondo&amp;quot;)''&lt;br /&gt;
&lt;br /&gt;
''__ doc__'' ce l'hanno tutti gli oggetti (stringhe, interi...), e contiene una stringa di documentazione dell'oggetto. &lt;br /&gt;
&lt;br /&gt;
i metodi che iniziano per is servono per controllare se una certa proprietà della stringa in esame è vera:&lt;br /&gt;
es: &lt;br /&gt;
    ''messaggio.isalpha()''&lt;br /&gt;
mi dice se messaggio è o meno alfanumerico (composto solo da numeri e cifre, senza spazi, tab, ritorno carrello ecc ecc).&lt;br /&gt;
isalpha è un oggetto quindi ha le proprietà doc .&lt;br /&gt;
se io scrivo&lt;br /&gt;
    ''messaggio.isalpha.__doc__''&lt;br /&gt;
mi dice che fa.&lt;br /&gt;
&lt;br /&gt;
es:&lt;br /&gt;
    '' messaggio=”gigio”&lt;br /&gt;
    messaggio2= messaggio.upper()''&lt;br /&gt;
&lt;br /&gt;
es:&lt;br /&gt;
''TYPE(3)''&lt;br /&gt;
mi dice che variabile  è. se è intero o stringa oppure un complesso, un float o un tipo definito dall'utente.&lt;br /&gt;
Se io scrivo ''DIR(3)''&lt;br /&gt;
mi da tutta la lista dei metodi e delle proprietà degli int (dato che 3 è in intero)&lt;br /&gt;
'''&lt;br /&gt;
&lt;br /&gt;
Esistono stringhe, interi, float (numeri con virgola)booleano (che ha due valori, vero o falso, True e False)e i vari contenitori:&lt;br /&gt;
&lt;br /&gt;
== '''LE LISTE''' ==&lt;br /&gt;
&lt;br /&gt;
es. lo scaffale ha I pc, I pc sono oggetti (pc1,pc2...).Se voglio uno scaffale di pc senza dare I nomi a tutti gli oggetti, definisco lo scaffale.&lt;br /&gt;
Lo scaffale si chiama''' Lista'''  .si usano le parentesi quadre con oggetti separati da virgola&lt;br /&gt;
es.    '' a = [ “pc1” , “schermo rotto” , 2]&lt;br /&gt;
dir (scaffale)''&lt;br /&gt;
da la lista dei metodi, da qui si capisce che la lista è un oggetto.&lt;br /&gt;
Ad esempio:&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a la stringa &amp;quot;4&amp;quot;.&lt;br /&gt;
La lista, a differenza delle stringhe, è un oggetto mutabile, quindi la funzione append di fatto manipola la lista esistente per far spazio al nuovo oggetto da inserir&lt;br /&gt;
&lt;br /&gt;
Se faccio     ''print (“a”)''&lt;br /&gt;
mi da la lista degli oggetti più &amp;quot;4&amp;quot;&lt;br /&gt;
&lt;br /&gt;
Da notare che&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; mialista = []&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; mialista&lt;br /&gt;
  []&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; dir(a)&lt;br /&gt;
  ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__ge__', &lt;br /&gt;
   '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', &lt;br /&gt;
   '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__',&lt;br /&gt;
   '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__str__', 'append', 'count', 'extend', 'index', 'insert', &lt;br /&gt;
   'pop', 'remove', 'reverse', 'sort']&lt;br /&gt;
&lt;br /&gt;
Da qui vediamo che il risultato della funziona dir su una lista ritorna .. una lista.&lt;br /&gt;
&lt;br /&gt;
== '''TUPLE''' ==&lt;br /&gt;
&lt;br /&gt;
è una lista non mutabile.&lt;br /&gt;
La tupla è molto piu veloce rispetto alla lista.&lt;br /&gt;
Con tuple si usano le parentesi tonde.&lt;br /&gt;
&lt;br /&gt;
== '''DIZIONARI''' ==&lt;br /&gt;
&lt;br /&gt;
il dizionario si definisce con le parentesi graffe {chiave:valore, chiave:valore}&lt;br /&gt;
a{chiave}&lt;br /&gt;
da il valore associato alla chiave.&lt;br /&gt;
&lt;br /&gt;
Dizionari liste e tuple sono dele sequenze e sono iterable e si possono scorrere.&lt;br /&gt;
&lt;br /&gt;
== '''If elif else''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
if condizione :&lt;br /&gt;
&lt;br /&gt;
indentato roba da fare se vero.&lt;br /&gt;
&lt;br /&gt;
Python supporta o tab o spazio, si decide quanti tab o spazi alla prima indentazione.&lt;br /&gt;
Meglio lo spazio perchè in futuro I tab verranno lasciati.&lt;br /&gt;
Di solito si usa 4 spazi.&lt;br /&gt;
Non c'è la graffa in pyton o I begin o gli end, si chiude e si apre la riga solo se si indenta.&lt;br /&gt;
&lt;br /&gt;
Esempio:&lt;br /&gt;
    ''a=3&lt;br /&gt;
    b=1''&lt;br /&gt;
&lt;br /&gt;
    ''if a &amp;gt;b:&lt;br /&gt;
      print (“ a è maggiore di b”)&lt;br /&gt;
    elif a==b:&lt;br /&gt;
      print (“ a è uguale a b”)&lt;br /&gt;
    else:&lt;br /&gt;
       print(“b è maggiore di a”)''&lt;br /&gt;
&lt;br /&gt;
in questo programma definisco due valori, a e b.&lt;br /&gt;
Chiedo al programma se aè maggiore di b di scrivere : a è maggiore di b, se a è uguale a b di scrivere che a è uguale a b e in tutte le altre condizioni (else) di scrivere che a è minore di b.&lt;br /&gt;
&lt;br /&gt;
	'''2.is, is not or, and,!='''&lt;br /&gt;
    ''if a is 1:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
    elif a is not 1:&lt;br /&gt;
      print (“no”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 and b is 3:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 or b is 3:&lt;br /&gt;
      print (“okkei”)&lt;br /&gt;
''&lt;br /&gt;
&lt;br /&gt;
'''!= è il diverso.'''&lt;br /&gt;
&lt;br /&gt;
== '''append, insert''' ==&lt;br /&gt;
&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a il 4.&lt;br /&gt;
Se faccio print (“a”)&lt;br /&gt;
mi da la lista degli oggetti più il 4.&lt;br /&gt;
&lt;br /&gt;
con '''insert''' devo inserire anche la posizione&lt;br /&gt;
    ''a.insert(2,34)''&lt;br /&gt;
mette il 34 in posizione 2&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''for''' ==&lt;br /&gt;
&lt;br /&gt;
specifica un ciclo, fa le cose tante volte fino ad una condizione.&lt;br /&gt;
For variabile in una sequenza di qualche tipo.&lt;br /&gt;
Es:     ''for elemento in a:&lt;br /&gt;
               print elemento''&lt;br /&gt;
&lt;br /&gt;
es b è una tupla.&lt;br /&gt;
Allora posso scrivere:&lt;br /&gt;
    ''for elem in b&lt;br /&gt;
         print “altro elemento”&lt;br /&gt;
         “print elem”''&lt;br /&gt;
&lt;br /&gt;
elem o qualsiasi altro nome gli dia è ogni elemento dentro la tupla o lista o dizionario.&lt;br /&gt;
&lt;br /&gt;
Se io voglio sia la chiave sia il valore in un dizionario (se metto elem mi mette solo la chiave) posso fare:&lt;br /&gt;
for chiave in a:&lt;br /&gt;
	    ''print “chiave: “ + chiave&lt;br /&gt;
	    print “valore: “ + a[chiave]''&lt;br /&gt;
&lt;br /&gt;
'''DOPO I DUE PUNTI METTO SEMPRE IL TAB.'''&lt;br /&gt;
&lt;br /&gt;
== '''xrange''' ==&lt;br /&gt;
&lt;br /&gt;
xrange è un iterable di dieci elementi con il primo valore uguale a 0 .E' una lista ma non ha le proprietà di una lista.&lt;br /&gt;
se io voglio fare un for da uno a dieci (cioè la somma da uno a 10)&lt;br /&gt;
&lt;br /&gt;
es:     ''for I xrange(10)&lt;br /&gt;
               print I''&lt;br /&gt;
lui stampa&lt;br /&gt;
''1&lt;br /&gt;
2&lt;br /&gt;
3&lt;br /&gt;
4&lt;br /&gt;
5&lt;br /&gt;
6&lt;br /&gt;
7&lt;br /&gt;
8&lt;br /&gt;
9&lt;br /&gt;
10''&lt;br /&gt;
&lt;br /&gt;
== '''range''' ==&lt;br /&gt;
&lt;br /&gt;
ha la stessa funzione di xrange, ovvero servire da iterable su N numeri, però ritorna non un oggetto di tipo xrange ma una lista.&lt;br /&gt;
E' più lento di xrange&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; print range(10)&lt;br /&gt;
  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== '''len''' ==&lt;br /&gt;
&lt;br /&gt;
    ''len (a)''&lt;br /&gt;
da la lunghezza della stringa&lt;br /&gt;
&lt;br /&gt;
== '''enumerate''' ==&lt;br /&gt;
&lt;br /&gt;
se io ho una lista di tre elmenti&lt;br /&gt;
''a=[“ciao”,”bel”, “mondo”]''&lt;br /&gt;
&lt;br /&gt;
''for I, elem in enumerate(a):&lt;br /&gt;
     print str(I) + “:” + elem&lt;br /&gt;
''&lt;br /&gt;
da la posizione corrente di ogni elemento.&lt;br /&gt;
''0:ciao&lt;br /&gt;
1:bel&lt;br /&gt;
2:mondo''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''raw_input''' ==&lt;br /&gt;
&lt;br /&gt;
dai il valore.&lt;br /&gt;
''Base= raw_input (“inserisce la base:”)&lt;br /&gt;
esponente=raw_input (“inserisci l'/ esponente”)''&lt;br /&gt;
&lt;br /&gt;
ti chiede il valore di base ed esponente.&lt;br /&gt;
&lt;br /&gt;
== '''Int''' ==&lt;br /&gt;
&lt;br /&gt;
forza il fatto che quel valore sia un intero.&lt;br /&gt;
''&lt;br /&gt;
Es:base=int(base)&lt;br /&gt;
  result=int(result)''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''UPPER,LOWER,CAPITALIZE''' ==&lt;br /&gt;
&lt;br /&gt;
'''capitalize''' è un comando che sulla la stringa su cui viene applicato ,prende la prima lettera dopo gli spazi e ci mette la maiuscola&lt;br /&gt;
&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.capitalize()''&lt;br /&gt;
    ''Ciao mondo''&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.title()&lt;br /&gt;
    Ciao Mondo''&lt;br /&gt;
&lt;br /&gt;
'''LOWER:''' prende la striga e emette tutto minuscolo&lt;br /&gt;
'''UPPER:''' il contrario di lower&lt;br /&gt;
&lt;br /&gt;
== '''ESEMPIO DELLA SERATA:''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Calcolo di una potenza.&lt;br /&gt;
&lt;br /&gt;
    ''&lt;br /&gt;
    base= raw_input (“inserisce la base:”)&lt;br /&gt;
    esponente=raw_input ('inserisci l\' esponente')&lt;br /&gt;
&lt;br /&gt;
    base=int(base)&lt;br /&gt;
    result=int(result)&lt;br /&gt;
&lt;br /&gt;
    result=1&lt;br /&gt;
    for i in xrange(esponente):&lt;br /&gt;
         result = result * base&lt;br /&gt;
    print result''&lt;br /&gt;
&lt;br /&gt;
il [http://docs.python.org/lib/built-in-funcs.html built-in] int() è necessario, dato che tutto quello che proviene dalla tastiera viene acquisito da raw_input() come stringa. Dato che dobbiamo usarli come interi, occorre effettuare un cast, ovvero&lt;br /&gt;
una trasformazione di tipo, da stringa a intero.&lt;br /&gt;
E' interessante notare che int() non cerca di fare i miracoli: provate a vedere cosa succede se cercate di convertire &amp;quot;awlerorj&amp;quot; in int!&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3737</id>
		<title>Python Lezione 4 Giugno 2008</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3737"/>
		<updated>2008-06-10T11:16:09Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: /* '''range''' */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Python ==&lt;br /&gt;
[http://www.python.it/ Python] è un linguaggio di programmazione [http://it.wikipedia.org/wiki/Interprete_(informatica) interpretato].&lt;br /&gt;
Il linuaggio interpretato è simile agli altri linguaggi in circolazione ma, invece di essere trasformato direttamente in codice binario dal meccanismo automatico, viene interpretato da questo e poi mandato all'hardware.&lt;br /&gt;
Un linguaggio interpretato non ha bisogno di essere ricompilato: il codice scritto viene interpretato da un interprete a run-time (tempo di esecuzione) e tradotto al volo nel linguaggio macchina.&lt;br /&gt;
Quindi i programmi python possono girare su qualsiasi hardware e sistema operativo su cui è stato portato l'interprete. Ovviamente, questa cosa si paga sul tempo di esecuzione pure: l'approccio ha si i suoi vantaggi, ma rispetto a un linguaggio compilato direttamente in linguaggio macchina per creare un eseguibile, python e gli altri liguaggi interpretati risultano essere più lenti.&lt;br /&gt;
&lt;br /&gt;
Esistono vari interpreti: [http://www.python.org Cpython], o classic python, è l'interprete &amp;quot;ufficiale&amp;quot;, scritto in C e disponibile per linux, mac e windows.&lt;br /&gt;
[http://www.jython.org/Project/ Jython] è un interprete scritto al 100% in Java, e si interfaccia strettamente ai programmi e alla libreria Java, &lt;br /&gt;
[http://www.codeplex.com/Wiki/View.aspx?ProjectName=IronPython IronPython] è un interprete python che gira sulla piattaforma .NET mentre &lt;br /&gt;
[http://codespeak.net/pypy/dist/pypy/doc/home.html PyPy] è (anche) un interprete python scritto in.. python&lt;br /&gt;
&lt;br /&gt;
La prima riga di ogni script python deve iniziare con #!/usr/bin/env python&lt;br /&gt;
&lt;br /&gt;
il #! del file fa capire al sistema operativo (solo su sistemi posix, quindi unix/linux) che quello non è un file di testo ma un eseguibile da eseguire con l'inteprete python.&lt;br /&gt;
&lt;br /&gt;
== COMMENTI ==&lt;br /&gt;
&lt;br /&gt;
: sono righe che l'interprete salta e non legge &lt;br /&gt;
es: &lt;br /&gt;
    ''# stampa:”hello word”''&lt;br /&gt;
&lt;br /&gt;
== PRINT ==&lt;br /&gt;
Lo statement [http://docs.python.org/ref/print.html print] valuta tutte le espressioni presenti e quindi le stampa a video.&lt;br /&gt;
L'espressione da valutare può essere anche un semplice numero o una semplice stringa&lt;br /&gt;
&lt;br /&gt;
    ''print 3''&lt;br /&gt;
stampa 3, e anche se scrivo&lt;br /&gt;
    '' print “3”''&lt;br /&gt;
stampa lo stesso anche se abbiamo passato prima un intero, poi una stringa.&lt;br /&gt;
Questo è normale, perchè il numero &amp;quot;tre&amp;quot; viene rappresentato dal simbolo 3 nel sistema decimale.&lt;br /&gt;
&lt;br /&gt;
Invece, se scrivo&lt;br /&gt;
    ''print 3+2''&lt;br /&gt;
otteniamo a video 5: l'inteprete ha valutato l'espressione, ha eseguito la somma e stampato il situlato.&lt;br /&gt;
Mentre se scriviamo&lt;br /&gt;
    ''print “3+2”''&lt;br /&gt;
il risolutato è &lt;br /&gt;
    ''3+2''&lt;br /&gt;
in quanto abbiamo passato la stringa composta dal carattere 3, dal simbolo + e dal carattere 2.&lt;br /&gt;
&lt;br /&gt;
Le variabili in python non devono essere dichiarate: esistono dalla prima volta in cui gli viene assegnato un valore&lt;br /&gt;
    ''messaggio=”hello world”''&lt;br /&gt;
    ''print messaggio''&lt;br /&gt;
se questo programma viene eseguito il risultatato sarà:&lt;br /&gt;
''hello world''&lt;br /&gt;
l'interprete valuta l'espressione ''messaggio'' e stampa il suo contenuto&lt;br /&gt;
&lt;br /&gt;
== Errori e Eccezioni ==&lt;br /&gt;
&lt;br /&gt;
Commentando l'assegnamento di messaggio, vediamo che l'interprete genera un errore:&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
  jdoe@waste-bin ~ $ python&lt;br /&gt;
  Python 2.5.2 (r252:60911, May 24 2008, 15:28:31) &lt;br /&gt;
  [GCC 4.2.4 (Gentoo 4.2.4 p1.0)] on linux2&lt;br /&gt;
  Type &amp;quot;help&amp;quot;, &amp;quot;copyright&amp;quot;, &amp;quot;credits&amp;quot; or &amp;quot;license&amp;quot; for more information.&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; print messaggio&lt;br /&gt;
  Traceback (most recent call last):&lt;br /&gt;
    File &amp;quot;&amp;lt;stdin&amp;gt;&amp;quot;, line 1, in &amp;lt;module&amp;gt;&lt;br /&gt;
  NameError: name 'messaggio' is not defined&lt;br /&gt;
&lt;br /&gt;
NameError è una eccezione. Vedremo più avanti come queste situazioni di errore possono essere ''catturate'' e ''gestite'' appositamente, sia&lt;br /&gt;
per tentare di risolvere il problema che per migliorare il feedback che il nostro programma da all'utente. Vedremo anche come&lt;br /&gt;
la gestione delle eccezioni è parte della programmazione normale di un programma, ovvero non è sempre legata a una situazione di errore.&lt;br /&gt;
&lt;br /&gt;
Un altro esempio, tendando di sommare mele e pere:&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; print 1 + &amp;quot;a&amp;quot;&lt;br /&gt;
  Traceback (most recent call last):&lt;br /&gt;
    File &amp;quot;&amp;lt;stdin&amp;gt;&amp;quot;, line 1, in &amp;lt;module&amp;gt;&lt;br /&gt;
  TypeError: unsupported operand type(s) for +: 'int' and 'str'&lt;br /&gt;
&lt;br /&gt;
Vediamo che a questo giro l'eccezione lanciata è ValueError.&lt;br /&gt;
&lt;br /&gt;
== LE STRINGHE ==&lt;br /&gt;
Gli oggetti di tipo stringa supportano svariati metodi e proprietà. E' da notare che le stringhe sono immutabili.&lt;br /&gt;
Se una stringa viene dichiarata la seconda volta, quella precedente viene buttata, non viene modificata per fare spazio alla nuova.&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
    messaggio=”ciao mondo”&lt;br /&gt;
    print messaggio''&lt;br /&gt;
stampa&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
In Python non si possono sommare cose diverse, o meglio, lo posso fare solo se è definita una conversione tra i due tipo.&lt;br /&gt;
Le stringhe supportano anche alcuni operatori base:&lt;br /&gt;
    ''print messaggio*2'' &lt;br /&gt;
l'esecuzione darà&lt;br /&gt;
    ''messaggio messaggio&lt;br /&gt;
''&lt;br /&gt;
esempio:&lt;br /&gt;
     ''Print “ciao”+” mondo”''&lt;br /&gt;
lo eseguo e mi darà:&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
== '''Funzione DIR''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
    dir(messaggio)''&lt;br /&gt;
a questo punto il programma da una serie di caratteri incomprensibili.&lt;br /&gt;
Praticamente dà i '''metodi''' che suporta la stringa messaggio.&lt;br /&gt;
&lt;br /&gt;
== I '''metodi''' ==&lt;br /&gt;
sono operazioni che i vari oggetti supportano.&lt;br /&gt;
alcuni metodi, vedendo con la funzione dir(), iniziano e terminano con __ . Tali metodi, chiamati metodi speciali, non dovrebbero essere chiamati direttamente,&lt;br /&gt;
senza che ci sia una ragione specifica per farlo (ovvero: sapete quello che state facendo). In generale possono essere pensati come privati o riservati, anche se non &lt;br /&gt;
essendoci controlli di accesso come in altri linguaggi (public private del java o del c++ ad esempio) nessuno vieta di chiamarli.&lt;br /&gt;
&lt;br /&gt;
Ad esempio, il metodo __add__ delle stringhe è chiamato quando si fa la somma di due stringhe.&lt;br /&gt;
 ''&amp;quot;ciao&amp;quot; + &amp;quot; mondo&amp;quot;'' &lt;br /&gt;
chiama in realtà &lt;br /&gt;
 ''&amp;quot;ciao&amp;quot;.__add__(&amp;quot; mondo&amp;quot;)''&lt;br /&gt;
&lt;br /&gt;
''__ doc__'' ce l'hanno tutti gli oggetti (stringhe, interi...), e contiene una stringa di documentazione dell'oggetto. &lt;br /&gt;
&lt;br /&gt;
i metodi che iniziano per is servono per controllare se una certa proprietà della stringa in esame è vera:&lt;br /&gt;
es: &lt;br /&gt;
    ''messaggio.isalpha()''&lt;br /&gt;
mi dice se messaggio è o meno alfanumerico (composto solo da numeri e cifre, senza spazi, tab, ritorno carrello ecc ecc).&lt;br /&gt;
isalpha è un oggetto quindi ha le proprietà doc .&lt;br /&gt;
se io scrivo&lt;br /&gt;
    ''messaggio.isalpha.__doc__''&lt;br /&gt;
mi dice che fa.&lt;br /&gt;
&lt;br /&gt;
es:&lt;br /&gt;
    '' messaggio=”gigio”&lt;br /&gt;
    messaggio2= messaggio.upper()''&lt;br /&gt;
&lt;br /&gt;
es:&lt;br /&gt;
''TYPE(3)''&lt;br /&gt;
mi dice che variabile  è. se è intero o stringa oppure un complesso, un float o un tipo definito dall'utente.&lt;br /&gt;
Se io scrivo ''DIR(3)''&lt;br /&gt;
mi da tutta la lista dei metodi e delle proprietà degli int (dato che 3 è in intero)&lt;br /&gt;
'''&lt;br /&gt;
&lt;br /&gt;
Esistono stringhe, interi, float (numeri con virgola)booleano (che ha due valori, vero o falso, True e False)e i vari contenitori:&lt;br /&gt;
&lt;br /&gt;
== '''LE LISTE''' ==&lt;br /&gt;
&lt;br /&gt;
es. lo scaffale ha I pc, I pc sono oggetti (pc1,pc2...).Se voglio uno scaffale di pc senza dare I nomi a tutti gli oggetti, definisco lo scaffale.&lt;br /&gt;
Lo scaffale si chiama''' Lista'''  .si usano le parentesi quadre con oggetti separati da virgola&lt;br /&gt;
es.    '' a = [ “pc1” , “schermo rotto” , 2]&lt;br /&gt;
dir (scaffale)''&lt;br /&gt;
da la lista dei metodi, da qui si capisce che la lista è un oggetto.&lt;br /&gt;
Ad esempio:&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a la stringa &amp;quot;4&amp;quot;.&lt;br /&gt;
La lista, a differenza delle stringhe, è un oggetto mutabile, quindi la funzione append di fatto manipola la lista esistente per far spazio al nuovo oggetto da inserir&lt;br /&gt;
&lt;br /&gt;
Se faccio     ''print (“a”)''&lt;br /&gt;
mi da la lista degli oggetti più &amp;quot;4&amp;quot;&lt;br /&gt;
&lt;br /&gt;
Da notare che&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; mialista = []&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; mialista&lt;br /&gt;
  []&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; dir(a)&lt;br /&gt;
  ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__str__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']&lt;br /&gt;
&lt;br /&gt;
Da qui vediamo che il risultato della funziona dir su una lista ritorna .. una lista.&lt;br /&gt;
&lt;br /&gt;
== '''TUPLE''' ==&lt;br /&gt;
&lt;br /&gt;
è una lista non mutabile.&lt;br /&gt;
La tupla è molto piu veloce rispetto alla lista.&lt;br /&gt;
Con tuple si usano le parentesi tonde.&lt;br /&gt;
&lt;br /&gt;
== '''DIZIONARI''' ==&lt;br /&gt;
&lt;br /&gt;
il dizionario si definisce con le parentesi graffe {chiave:valore, chiave:valore}&lt;br /&gt;
a{chiave}&lt;br /&gt;
da il valore associato alla chiave.&lt;br /&gt;
&lt;br /&gt;
Dizionari liste e tuple sono dele sequenze e sono iterable e si possono scorrere.&lt;br /&gt;
&lt;br /&gt;
== '''If elif else''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
if condizione :&lt;br /&gt;
&lt;br /&gt;
indentato roba da fare se vero.&lt;br /&gt;
&lt;br /&gt;
Python supporta o tab o spazio, si decide quanti tab o spazi alla prima indentazione.&lt;br /&gt;
Meglio lo spazio perchè in futuro I tab verranno lasciati.&lt;br /&gt;
Di solito si usa 4 spazi.&lt;br /&gt;
Non c'è la graffa in pyton o I begin o gli end, si chiude e si apre la riga solo se si indenta.&lt;br /&gt;
&lt;br /&gt;
Esempio:&lt;br /&gt;
    ''a=3&lt;br /&gt;
    b=1''&lt;br /&gt;
&lt;br /&gt;
    ''if a &amp;gt;b:&lt;br /&gt;
      print (“ a è maggiore di b”)&lt;br /&gt;
    elif a==b:&lt;br /&gt;
      print (“ a è uguale a b”)&lt;br /&gt;
    else:&lt;br /&gt;
       print(“b è maggiore di a”)''&lt;br /&gt;
&lt;br /&gt;
in questo programma definisco due valori, a e b.&lt;br /&gt;
Chiedo al programma se aè maggiore di b di scrivere : a è maggiore di b, se a è uguale a b di scrivere che a è uguale a b e in tutte le altre condizioni (else) di scrivere che a è minore di b.&lt;br /&gt;
&lt;br /&gt;
	'''2.is, is not or, and,!='''&lt;br /&gt;
    ''if a is 1:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
    elif a is not 1:&lt;br /&gt;
      print (“no”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 and b is 3:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 or b is 3:&lt;br /&gt;
      print (“okkei”)&lt;br /&gt;
''&lt;br /&gt;
&lt;br /&gt;
'''!= è il diverso.'''&lt;br /&gt;
&lt;br /&gt;
== '''append, insert''' ==&lt;br /&gt;
&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a il 4.&lt;br /&gt;
Se faccio print (“a”)&lt;br /&gt;
mi da la lista degli oggetti più il 4.&lt;br /&gt;
&lt;br /&gt;
con '''insert''' devo inserire anche la posizione&lt;br /&gt;
    ''a.insert(2,34)''&lt;br /&gt;
mette il 34 in posizione 2&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''for''' ==&lt;br /&gt;
&lt;br /&gt;
specifica un ciclo, fa le cose tante volte fino ad una condizione.&lt;br /&gt;
For variabile in una sequenza di qualche tipo.&lt;br /&gt;
Es:     ''for elemento in a:&lt;br /&gt;
               print elemento''&lt;br /&gt;
&lt;br /&gt;
es b è una tupla.&lt;br /&gt;
Allora posso scrivere:&lt;br /&gt;
    ''for elem in b&lt;br /&gt;
         print “altro elemento”&lt;br /&gt;
         “print elem”''&lt;br /&gt;
&lt;br /&gt;
elem o qualsiasi altro nome gli dia è ogni elemento dentro la tupla o lista o dizionario.&lt;br /&gt;
&lt;br /&gt;
Se io voglio sia la chiave sia il valore in un dizionario (se metto elem mi mette solo la chiave) posso fare:&lt;br /&gt;
for chiave in a:&lt;br /&gt;
	    ''print “chiave: “ + chiave&lt;br /&gt;
	    print “valore: “ + a[chiave]''&lt;br /&gt;
&lt;br /&gt;
'''DOPO I DUE PUNTI METTO SEMPRE IL TAB.'''&lt;br /&gt;
&lt;br /&gt;
== '''xrange''' ==&lt;br /&gt;
&lt;br /&gt;
xrange è un iterable di dieci elementi con il primo valore uguale a 0 .E' una lista ma non ha le proprietà di una lista.&lt;br /&gt;
se io voglio fare un for da uno a dieci (cioè la somma da uno a 10)&lt;br /&gt;
&lt;br /&gt;
es:     ''for I xrange(10)&lt;br /&gt;
               print I''&lt;br /&gt;
lui stampa&lt;br /&gt;
''1&lt;br /&gt;
2&lt;br /&gt;
3&lt;br /&gt;
4&lt;br /&gt;
5&lt;br /&gt;
6&lt;br /&gt;
7&lt;br /&gt;
8&lt;br /&gt;
9&lt;br /&gt;
10''&lt;br /&gt;
&lt;br /&gt;
== '''range''' ==&lt;br /&gt;
&lt;br /&gt;
ha la stessa funzione di xrange, ovvero servire da iterable su N numeri, però ritorna non un oggetto di tipo xrange ma una lista.&lt;br /&gt;
E' più lento di xrange&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; print range(10)&lt;br /&gt;
  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== '''len''' ==&lt;br /&gt;
&lt;br /&gt;
    ''len (a)''&lt;br /&gt;
da la lunghezza della stringa&lt;br /&gt;
&lt;br /&gt;
== '''enumerate''' ==&lt;br /&gt;
&lt;br /&gt;
se io ho una lista di tre elmenti&lt;br /&gt;
''a=[“ciao”,”bel”, “mondo”]''&lt;br /&gt;
&lt;br /&gt;
''for I, elem in enumerate(a):&lt;br /&gt;
     print str(I) + “:” + elem&lt;br /&gt;
''&lt;br /&gt;
da la posizione corrente di ogni elemento.&lt;br /&gt;
''0:ciao&lt;br /&gt;
1:bel&lt;br /&gt;
2:mondo''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''raw_input''' ==&lt;br /&gt;
&lt;br /&gt;
dai il valore.&lt;br /&gt;
''Base= raw_input (“inserisce la base:”)&lt;br /&gt;
esponente=raw_input (“inserisci l'/ esponente”)''&lt;br /&gt;
&lt;br /&gt;
ti chiede il valore di base ed esponente.&lt;br /&gt;
&lt;br /&gt;
== '''Int''' ==&lt;br /&gt;
&lt;br /&gt;
forza il fatto che quel valore sia un intero.&lt;br /&gt;
''&lt;br /&gt;
Es:base=int(base)&lt;br /&gt;
  result=int(result)''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''UPPER,LOWER,CAPITALIZE''' ==&lt;br /&gt;
&lt;br /&gt;
'''capitalize''' è un comando che sulla la stringa su cui viene applicato ,prende la prima lettera dopo gli spazi e ci mette la maiuscola&lt;br /&gt;
&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.capitalize()''&lt;br /&gt;
    ''Ciao mondo''&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.title()&lt;br /&gt;
    Ciao Mondo''&lt;br /&gt;
&lt;br /&gt;
'''LOWER:''' prende la striga e emette tutto minuscolo&lt;br /&gt;
'''UPPER:''' il contrario di lower&lt;br /&gt;
&lt;br /&gt;
== '''ESEMPIO DELLA SERATA:''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Calcolo di una potenza.&lt;br /&gt;
&lt;br /&gt;
    ''&lt;br /&gt;
    base= raw_input (“inserisce la base:”)&lt;br /&gt;
    esponente=raw_input ('inserisci l\' esponente')&lt;br /&gt;
&lt;br /&gt;
    base=int(base)&lt;br /&gt;
    result=int(result)&lt;br /&gt;
&lt;br /&gt;
    result=1&lt;br /&gt;
    for i in xrange(esponente):&lt;br /&gt;
         result = result * base&lt;br /&gt;
    print result''&lt;br /&gt;
&lt;br /&gt;
il [http://docs.python.org/lib/built-in-funcs.html built-in] int() è necessario, dato che tutto quello che proviene dalla tastiera viene acquisito da raw_input() come stringa. Dato che dobbiamo usarli come interi, occorre effettuare un cast, ovvero&lt;br /&gt;
una trasformazione di tipo, da stringa a intero.&lt;br /&gt;
E' interessante notare che int() non cerca di fare i miracoli: provate a vedere cosa succede se cercate di convertire &amp;quot;awlerorj&amp;quot; in int!&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3736</id>
		<title>Python Lezione 4 Giugno 2008</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3736"/>
		<updated>2008-06-10T11:14:17Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: /* '''LE LISTE''' */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Python ==&lt;br /&gt;
[http://www.python.it/ Python] è un linguaggio di programmazione [http://it.wikipedia.org/wiki/Interprete_(informatica) interpretato].&lt;br /&gt;
Il linuaggio interpretato è simile agli altri linguaggi in circolazione ma, invece di essere trasformato direttamente in codice binario dal meccanismo automatico, viene interpretato da questo e poi mandato all'hardware.&lt;br /&gt;
Un linguaggio interpretato non ha bisogno di essere ricompilato: il codice scritto viene interpretato da un interprete a run-time (tempo di esecuzione) e tradotto al volo nel linguaggio macchina.&lt;br /&gt;
Quindi i programmi python possono girare su qualsiasi hardware e sistema operativo su cui è stato portato l'interprete. Ovviamente, questa cosa si paga sul tempo di esecuzione pure: l'approccio ha si i suoi vantaggi, ma rispetto a un linguaggio compilato direttamente in linguaggio macchina per creare un eseguibile, python e gli altri liguaggi interpretati risultano essere più lenti.&lt;br /&gt;
&lt;br /&gt;
Esistono vari interpreti: [http://www.python.org Cpython], o classic python, è l'interprete &amp;quot;ufficiale&amp;quot;, scritto in C e disponibile per linux, mac e windows.&lt;br /&gt;
[http://www.jython.org/Project/ Jython] è un interprete scritto al 100% in Java, e si interfaccia strettamente ai programmi e alla libreria Java, &lt;br /&gt;
[http://www.codeplex.com/Wiki/View.aspx?ProjectName=IronPython IronPython] è un interprete python che gira sulla piattaforma .NET mentre &lt;br /&gt;
[http://codespeak.net/pypy/dist/pypy/doc/home.html PyPy] è (anche) un interprete python scritto in.. python&lt;br /&gt;
&lt;br /&gt;
La prima riga di ogni script python deve iniziare con #!/usr/bin/env python&lt;br /&gt;
&lt;br /&gt;
il #! del file fa capire al sistema operativo (solo su sistemi posix, quindi unix/linux) che quello non è un file di testo ma un eseguibile da eseguire con l'inteprete python.&lt;br /&gt;
&lt;br /&gt;
== COMMENTI ==&lt;br /&gt;
&lt;br /&gt;
: sono righe che l'interprete salta e non legge &lt;br /&gt;
es: &lt;br /&gt;
    ''# stampa:”hello word”''&lt;br /&gt;
&lt;br /&gt;
== PRINT ==&lt;br /&gt;
Lo statement [http://docs.python.org/ref/print.html print] valuta tutte le espressioni presenti e quindi le stampa a video.&lt;br /&gt;
L'espressione da valutare può essere anche un semplice numero o una semplice stringa&lt;br /&gt;
&lt;br /&gt;
    ''print 3''&lt;br /&gt;
stampa 3, e anche se scrivo&lt;br /&gt;
    '' print “3”''&lt;br /&gt;
stampa lo stesso anche se abbiamo passato prima un intero, poi una stringa.&lt;br /&gt;
Questo è normale, perchè il numero &amp;quot;tre&amp;quot; viene rappresentato dal simbolo 3 nel sistema decimale.&lt;br /&gt;
&lt;br /&gt;
Invece, se scrivo&lt;br /&gt;
    ''print 3+2''&lt;br /&gt;
otteniamo a video 5: l'inteprete ha valutato l'espressione, ha eseguito la somma e stampato il situlato.&lt;br /&gt;
Mentre se scriviamo&lt;br /&gt;
    ''print “3+2”''&lt;br /&gt;
il risolutato è &lt;br /&gt;
    ''3+2''&lt;br /&gt;
in quanto abbiamo passato la stringa composta dal carattere 3, dal simbolo + e dal carattere 2.&lt;br /&gt;
&lt;br /&gt;
Le variabili in python non devono essere dichiarate: esistono dalla prima volta in cui gli viene assegnato un valore&lt;br /&gt;
    ''messaggio=”hello world”''&lt;br /&gt;
    ''print messaggio''&lt;br /&gt;
se questo programma viene eseguito il risultatato sarà:&lt;br /&gt;
''hello world''&lt;br /&gt;
l'interprete valuta l'espressione ''messaggio'' e stampa il suo contenuto&lt;br /&gt;
&lt;br /&gt;
== Errori e Eccezioni ==&lt;br /&gt;
&lt;br /&gt;
Commentando l'assegnamento di messaggio, vediamo che l'interprete genera un errore:&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
  jdoe@waste-bin ~ $ python&lt;br /&gt;
  Python 2.5.2 (r252:60911, May 24 2008, 15:28:31) &lt;br /&gt;
  [GCC 4.2.4 (Gentoo 4.2.4 p1.0)] on linux2&lt;br /&gt;
  Type &amp;quot;help&amp;quot;, &amp;quot;copyright&amp;quot;, &amp;quot;credits&amp;quot; or &amp;quot;license&amp;quot; for more information.&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; print messaggio&lt;br /&gt;
  Traceback (most recent call last):&lt;br /&gt;
    File &amp;quot;&amp;lt;stdin&amp;gt;&amp;quot;, line 1, in &amp;lt;module&amp;gt;&lt;br /&gt;
  NameError: name 'messaggio' is not defined&lt;br /&gt;
&lt;br /&gt;
NameError è una eccezione. Vedremo più avanti come queste situazioni di errore possono essere ''catturate'' e ''gestite'' appositamente, sia&lt;br /&gt;
per tentare di risolvere il problema che per migliorare il feedback che il nostro programma da all'utente. Vedremo anche come&lt;br /&gt;
la gestione delle eccezioni è parte della programmazione normale di un programma, ovvero non è sempre legata a una situazione di errore.&lt;br /&gt;
&lt;br /&gt;
Un altro esempio, tendando di sommare mele e pere:&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; print 1 + &amp;quot;a&amp;quot;&lt;br /&gt;
  Traceback (most recent call last):&lt;br /&gt;
    File &amp;quot;&amp;lt;stdin&amp;gt;&amp;quot;, line 1, in &amp;lt;module&amp;gt;&lt;br /&gt;
  TypeError: unsupported operand type(s) for +: 'int' and 'str'&lt;br /&gt;
&lt;br /&gt;
Vediamo che a questo giro l'eccezione lanciata è ValueError.&lt;br /&gt;
&lt;br /&gt;
== LE STRINGHE ==&lt;br /&gt;
Gli oggetti di tipo stringa supportano svariati metodi e proprietà. E' da notare che le stringhe sono immutabili.&lt;br /&gt;
Se una stringa viene dichiarata la seconda volta, quella precedente viene buttata, non viene modificata per fare spazio alla nuova.&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
    messaggio=”ciao mondo”&lt;br /&gt;
    print messaggio''&lt;br /&gt;
stampa&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
In Python non si possono sommare cose diverse, o meglio, lo posso fare solo se è definita una conversione tra i due tipo.&lt;br /&gt;
Le stringhe supportano anche alcuni operatori base:&lt;br /&gt;
    ''print messaggio*2'' &lt;br /&gt;
l'esecuzione darà&lt;br /&gt;
    ''messaggio messaggio&lt;br /&gt;
''&lt;br /&gt;
esempio:&lt;br /&gt;
     ''Print “ciao”+” mondo”''&lt;br /&gt;
lo eseguo e mi darà:&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
== '''Funzione DIR''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
    dir(messaggio)''&lt;br /&gt;
a questo punto il programma da una serie di caratteri incomprensibili.&lt;br /&gt;
Praticamente dà i '''metodi''' che suporta la stringa messaggio.&lt;br /&gt;
&lt;br /&gt;
== I '''metodi''' ==&lt;br /&gt;
sono operazioni che i vari oggetti supportano.&lt;br /&gt;
alcuni metodi, vedendo con la funzione dir(), iniziano e terminano con __ . Tali metodi, chiamati metodi speciali, non dovrebbero essere chiamati direttamente,&lt;br /&gt;
senza che ci sia una ragione specifica per farlo (ovvero: sapete quello che state facendo). In generale possono essere pensati come privati o riservati, anche se non &lt;br /&gt;
essendoci controlli di accesso come in altri linguaggi (public private del java o del c++ ad esempio) nessuno vieta di chiamarli.&lt;br /&gt;
&lt;br /&gt;
Ad esempio, il metodo __add__ delle stringhe è chiamato quando si fa la somma di due stringhe.&lt;br /&gt;
 ''&amp;quot;ciao&amp;quot; + &amp;quot; mondo&amp;quot;'' &lt;br /&gt;
chiama in realtà &lt;br /&gt;
 ''&amp;quot;ciao&amp;quot;.__add__(&amp;quot; mondo&amp;quot;)''&lt;br /&gt;
&lt;br /&gt;
''__ doc__'' ce l'hanno tutti gli oggetti (stringhe, interi...), e contiene una stringa di documentazione dell'oggetto. &lt;br /&gt;
&lt;br /&gt;
i metodi che iniziano per is servono per controllare se una certa proprietà della stringa in esame è vera:&lt;br /&gt;
es: &lt;br /&gt;
    ''messaggio.isalpha()''&lt;br /&gt;
mi dice se messaggio è o meno alfanumerico (composto solo da numeri e cifre, senza spazi, tab, ritorno carrello ecc ecc).&lt;br /&gt;
isalpha è un oggetto quindi ha le proprietà doc .&lt;br /&gt;
se io scrivo&lt;br /&gt;
    ''messaggio.isalpha.__doc__''&lt;br /&gt;
mi dice che fa.&lt;br /&gt;
&lt;br /&gt;
es:&lt;br /&gt;
    '' messaggio=”gigio”&lt;br /&gt;
    messaggio2= messaggio.upper()''&lt;br /&gt;
&lt;br /&gt;
es:&lt;br /&gt;
''TYPE(3)''&lt;br /&gt;
mi dice che variabile  è. se è intero o stringa oppure un complesso, un float o un tipo definito dall'utente.&lt;br /&gt;
Se io scrivo ''DIR(3)''&lt;br /&gt;
mi da tutta la lista dei metodi e delle proprietà degli int (dato che 3 è in intero)&lt;br /&gt;
'''&lt;br /&gt;
&lt;br /&gt;
Esistono stringhe, interi, float (numeri con virgola)booleano (che ha due valori, vero o falso, True e False)e i vari contenitori:&lt;br /&gt;
&lt;br /&gt;
== '''LE LISTE''' ==&lt;br /&gt;
&lt;br /&gt;
es. lo scaffale ha I pc, I pc sono oggetti (pc1,pc2...).Se voglio uno scaffale di pc senza dare I nomi a tutti gli oggetti, definisco lo scaffale.&lt;br /&gt;
Lo scaffale si chiama''' Lista'''  .si usano le parentesi quadre con oggetti separati da virgola&lt;br /&gt;
es.    '' a = [ “pc1” , “schermo rotto” , 2]&lt;br /&gt;
dir (scaffale)''&lt;br /&gt;
da la lista dei metodi, da qui si capisce che la lista è un oggetto.&lt;br /&gt;
Ad esempio:&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a la stringa &amp;quot;4&amp;quot;.&lt;br /&gt;
La lista, a differenza delle stringhe, è un oggetto mutabile, quindi la funzione append di fatto manipola la lista esistente per far spazio al nuovo oggetto da inserir&lt;br /&gt;
&lt;br /&gt;
Se faccio     ''print (“a”)''&lt;br /&gt;
mi da la lista degli oggetti più &amp;quot;4&amp;quot;&lt;br /&gt;
&lt;br /&gt;
Da notare che&lt;br /&gt;
&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; mialista = []&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; mialista&lt;br /&gt;
  []&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; dir(a)&lt;br /&gt;
  ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__str__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']&lt;br /&gt;
&lt;br /&gt;
Da qui vediamo che il risultato della funziona dir su una lista ritorna .. una lista.&lt;br /&gt;
&lt;br /&gt;
== '''TUPLE''' ==&lt;br /&gt;
&lt;br /&gt;
è una lista non mutabile.&lt;br /&gt;
La tupla è molto piu veloce rispetto alla lista.&lt;br /&gt;
Con tuple si usano le parentesi tonde.&lt;br /&gt;
&lt;br /&gt;
== '''DIZIONARI''' ==&lt;br /&gt;
&lt;br /&gt;
il dizionario si definisce con le parentesi graffe {chiave:valore, chiave:valore}&lt;br /&gt;
a{chiave}&lt;br /&gt;
da il valore associato alla chiave.&lt;br /&gt;
&lt;br /&gt;
Dizionari liste e tuple sono dele sequenze e sono iterable e si possono scorrere.&lt;br /&gt;
&lt;br /&gt;
== '''If elif else''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
if condizione :&lt;br /&gt;
&lt;br /&gt;
indentato roba da fare se vero.&lt;br /&gt;
&lt;br /&gt;
Python supporta o tab o spazio, si decide quanti tab o spazi alla prima indentazione.&lt;br /&gt;
Meglio lo spazio perchè in futuro I tab verranno lasciati.&lt;br /&gt;
Di solito si usa 4 spazi.&lt;br /&gt;
Non c'è la graffa in pyton o I begin o gli end, si chiude e si apre la riga solo se si indenta.&lt;br /&gt;
&lt;br /&gt;
Esempio:&lt;br /&gt;
    ''a=3&lt;br /&gt;
    b=1''&lt;br /&gt;
&lt;br /&gt;
    ''if a &amp;gt;b:&lt;br /&gt;
      print (“ a è maggiore di b”)&lt;br /&gt;
    elif a==b:&lt;br /&gt;
      print (“ a è uguale a b”)&lt;br /&gt;
    else:&lt;br /&gt;
       print(“b è maggiore di a”)''&lt;br /&gt;
&lt;br /&gt;
in questo programma definisco due valori, a e b.&lt;br /&gt;
Chiedo al programma se aè maggiore di b di scrivere : a è maggiore di b, se a è uguale a b di scrivere che a è uguale a b e in tutte le altre condizioni (else) di scrivere che a è minore di b.&lt;br /&gt;
&lt;br /&gt;
	'''2.is, is not or, and,!='''&lt;br /&gt;
    ''if a is 1:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
    elif a is not 1:&lt;br /&gt;
      print (“no”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 and b is 3:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 or b is 3:&lt;br /&gt;
      print (“okkei”)&lt;br /&gt;
''&lt;br /&gt;
&lt;br /&gt;
'''!= è il diverso.'''&lt;br /&gt;
&lt;br /&gt;
== '''append, insert''' ==&lt;br /&gt;
&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a il 4.&lt;br /&gt;
Se faccio print (“a”)&lt;br /&gt;
mi da la lista degli oggetti più il 4.&lt;br /&gt;
&lt;br /&gt;
con '''insert''' devo inserire anche la posizione&lt;br /&gt;
    ''a.insert(2,34)''&lt;br /&gt;
mette il 34 in posizione 2&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''for''' ==&lt;br /&gt;
&lt;br /&gt;
specifica un ciclo, fa le cose tante volte fino ad una condizione.&lt;br /&gt;
For variabile in una sequenza di qualche tipo.&lt;br /&gt;
Es:     ''for elemento in a:&lt;br /&gt;
               print elemento''&lt;br /&gt;
&lt;br /&gt;
es b è una tupla.&lt;br /&gt;
Allora posso scrivere:&lt;br /&gt;
    ''for elem in b&lt;br /&gt;
         print “altro elemento”&lt;br /&gt;
         “print elem”''&lt;br /&gt;
&lt;br /&gt;
elem o qualsiasi altro nome gli dia è ogni elemento dentro la tupla o lista o dizionario.&lt;br /&gt;
&lt;br /&gt;
Se io voglio sia la chiave sia il valore in un dizionario (se metto elem mi mette solo la chiave) posso fare:&lt;br /&gt;
for chiave in a:&lt;br /&gt;
	    ''print “chiave: “ + chiave&lt;br /&gt;
	    print “valore: “ + a[chiave]''&lt;br /&gt;
&lt;br /&gt;
'''DOPO I DUE PUNTI METTO SEMPRE IL TAB.'''&lt;br /&gt;
&lt;br /&gt;
== '''xrange''' ==&lt;br /&gt;
&lt;br /&gt;
xrange è un iterable di dieci elementi con il primo valore uguale a 0 .E' una lista ma non ha le proprietà di una lista.&lt;br /&gt;
se io voglio fare un for da uno a dieci (cioè la somma da uno a 10)&lt;br /&gt;
&lt;br /&gt;
es:     ''for I xrange(10)&lt;br /&gt;
               print I''&lt;br /&gt;
lui stampa&lt;br /&gt;
''1&lt;br /&gt;
2&lt;br /&gt;
3&lt;br /&gt;
4&lt;br /&gt;
5&lt;br /&gt;
6&lt;br /&gt;
7&lt;br /&gt;
8&lt;br /&gt;
9&lt;br /&gt;
10''&lt;br /&gt;
&lt;br /&gt;
== '''range''' ==&lt;br /&gt;
&lt;br /&gt;
è una lista.se io scrivo:&lt;br /&gt;
    ''print range(10)''&lt;br /&gt;
lui mi da     ''[0,1,2,3,4,5,6,7,8,9].''&lt;br /&gt;
è più lento di xrange e poi sta morendo&lt;br /&gt;
&lt;br /&gt;
== '''len''' ==&lt;br /&gt;
&lt;br /&gt;
    ''len (a)''&lt;br /&gt;
da la lunghezza della stringa&lt;br /&gt;
&lt;br /&gt;
== '''enumerate''' ==&lt;br /&gt;
&lt;br /&gt;
se io ho una lista di tre elmenti&lt;br /&gt;
''a=[“ciao”,”bel”, “mondo”]''&lt;br /&gt;
&lt;br /&gt;
''for I, elem in enumerate(a):&lt;br /&gt;
     print str(I) + “:” + elem&lt;br /&gt;
''&lt;br /&gt;
da la posizione corrente di ogni elemento.&lt;br /&gt;
''0:ciao&lt;br /&gt;
1:bel&lt;br /&gt;
2:mondo''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''raw_input''' ==&lt;br /&gt;
&lt;br /&gt;
dai il valore.&lt;br /&gt;
''Base= raw_input (“inserisce la base:”)&lt;br /&gt;
esponente=raw_input (“inserisci l'/ esponente”)''&lt;br /&gt;
&lt;br /&gt;
ti chiede il valore di base ed esponente.&lt;br /&gt;
&lt;br /&gt;
== '''Int''' ==&lt;br /&gt;
&lt;br /&gt;
forza il fatto che quel valore sia un intero.&lt;br /&gt;
''&lt;br /&gt;
Es:base=int(base)&lt;br /&gt;
  result=int(result)''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''UPPER,LOWER,CAPITALIZE''' ==&lt;br /&gt;
&lt;br /&gt;
'''capitalize''' è un comando che sulla la stringa su cui viene applicato ,prende la prima lettera dopo gli spazi e ci mette la maiuscola&lt;br /&gt;
&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.capitalize()''&lt;br /&gt;
    ''Ciao mondo''&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.title()&lt;br /&gt;
    Ciao Mondo''&lt;br /&gt;
&lt;br /&gt;
'''LOWER:''' prende la striga e emette tutto minuscolo&lt;br /&gt;
'''UPPER:''' il contrario di lower&lt;br /&gt;
&lt;br /&gt;
== '''ESEMPIO DELLA SERATA:''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Calcolo di una potenza.&lt;br /&gt;
&lt;br /&gt;
    ''&lt;br /&gt;
    base= raw_input (“inserisce la base:”)&lt;br /&gt;
    esponente=raw_input ('inserisci l\' esponente')&lt;br /&gt;
&lt;br /&gt;
    base=int(base)&lt;br /&gt;
    result=int(result)&lt;br /&gt;
&lt;br /&gt;
    result=1&lt;br /&gt;
    for i in xrange(esponente):&lt;br /&gt;
         result = result * base&lt;br /&gt;
    print result''&lt;br /&gt;
&lt;br /&gt;
il [http://docs.python.org/lib/built-in-funcs.html built-in] int() è necessario, dato che tutto quello che proviene dalla tastiera viene acquisito da raw_input() come stringa. Dato che dobbiamo usarli come interi, occorre effettuare un cast, ovvero&lt;br /&gt;
una trasformazione di tipo, da stringa a intero.&lt;br /&gt;
E' interessante notare che int() non cerca di fare i miracoli: provate a vedere cosa succede se cercate di convertire &amp;quot;awlerorj&amp;quot; in int!&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3735</id>
		<title>Python Lezione 4 Giugno 2008</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3735"/>
		<updated>2008-06-10T11:09:33Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: /* ECCEZIONE */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Python ==&lt;br /&gt;
[http://www.python.it/ Python] è un linguaggio di programmazione [http://it.wikipedia.org/wiki/Interprete_(informatica) interpretato].&lt;br /&gt;
Il linuaggio interpretato è simile agli altri linguaggi in circolazione ma, invece di essere trasformato direttamente in codice binario dal meccanismo automatico, viene interpretato da questo e poi mandato all'hardware.&lt;br /&gt;
Un linguaggio interpretato non ha bisogno di essere ricompilato: il codice scritto viene interpretato da un interprete a run-time (tempo di esecuzione) e tradotto al volo nel linguaggio macchina.&lt;br /&gt;
Quindi i programmi python possono girare su qualsiasi hardware e sistema operativo su cui è stato portato l'interprete. Ovviamente, questa cosa si paga sul tempo di esecuzione pure: l'approccio ha si i suoi vantaggi, ma rispetto a un linguaggio compilato direttamente in linguaggio macchina per creare un eseguibile, python e gli altri liguaggi interpretati risultano essere più lenti.&lt;br /&gt;
&lt;br /&gt;
Esistono vari interpreti: [http://www.python.org Cpython], o classic python, è l'interprete &amp;quot;ufficiale&amp;quot;, scritto in C e disponibile per linux, mac e windows.&lt;br /&gt;
[http://www.jython.org/Project/ Jython] è un interprete scritto al 100% in Java, e si interfaccia strettamente ai programmi e alla libreria Java, &lt;br /&gt;
[http://www.codeplex.com/Wiki/View.aspx?ProjectName=IronPython IronPython] è un interprete python che gira sulla piattaforma .NET mentre &lt;br /&gt;
[http://codespeak.net/pypy/dist/pypy/doc/home.html PyPy] è (anche) un interprete python scritto in.. python&lt;br /&gt;
&lt;br /&gt;
La prima riga di ogni script python deve iniziare con #!/usr/bin/env python&lt;br /&gt;
&lt;br /&gt;
il #! del file fa capire al sistema operativo (solo su sistemi posix, quindi unix/linux) che quello non è un file di testo ma un eseguibile da eseguire con l'inteprete python.&lt;br /&gt;
&lt;br /&gt;
== COMMENTI ==&lt;br /&gt;
&lt;br /&gt;
: sono righe che l'interprete salta e non legge &lt;br /&gt;
es: &lt;br /&gt;
    ''# stampa:”hello word”''&lt;br /&gt;
&lt;br /&gt;
== PRINT ==&lt;br /&gt;
Lo statement [http://docs.python.org/ref/print.html print] valuta tutte le espressioni presenti e quindi le stampa a video.&lt;br /&gt;
L'espressione da valutare può essere anche un semplice numero o una semplice stringa&lt;br /&gt;
&lt;br /&gt;
    ''print 3''&lt;br /&gt;
stampa 3, e anche se scrivo&lt;br /&gt;
    '' print “3”''&lt;br /&gt;
stampa lo stesso anche se abbiamo passato prima un intero, poi una stringa.&lt;br /&gt;
Questo è normale, perchè il numero &amp;quot;tre&amp;quot; viene rappresentato dal simbolo 3 nel sistema decimale.&lt;br /&gt;
&lt;br /&gt;
Invece, se scrivo&lt;br /&gt;
    ''print 3+2''&lt;br /&gt;
otteniamo a video 5: l'inteprete ha valutato l'espressione, ha eseguito la somma e stampato il situlato.&lt;br /&gt;
Mentre se scriviamo&lt;br /&gt;
    ''print “3+2”''&lt;br /&gt;
il risolutato è &lt;br /&gt;
    ''3+2''&lt;br /&gt;
in quanto abbiamo passato la stringa composta dal carattere 3, dal simbolo + e dal carattere 2.&lt;br /&gt;
&lt;br /&gt;
Le variabili in python non devono essere dichiarate: esistono dalla prima volta in cui gli viene assegnato un valore&lt;br /&gt;
    ''messaggio=”hello world”''&lt;br /&gt;
    ''print messaggio''&lt;br /&gt;
se questo programma viene eseguito il risultatato sarà:&lt;br /&gt;
''hello world''&lt;br /&gt;
l'interprete valuta l'espressione ''messaggio'' e stampa il suo contenuto&lt;br /&gt;
&lt;br /&gt;
== Errori e Eccezioni ==&lt;br /&gt;
&lt;br /&gt;
Commentando l'assegnamento di messaggio, vediamo che l'interprete genera un errore:&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
  jdoe@waste-bin ~ $ python&lt;br /&gt;
  Python 2.5.2 (r252:60911, May 24 2008, 15:28:31) &lt;br /&gt;
  [GCC 4.2.4 (Gentoo 4.2.4 p1.0)] on linux2&lt;br /&gt;
  Type &amp;quot;help&amp;quot;, &amp;quot;copyright&amp;quot;, &amp;quot;credits&amp;quot; or &amp;quot;license&amp;quot; for more information.&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; print messaggio&lt;br /&gt;
  Traceback (most recent call last):&lt;br /&gt;
    File &amp;quot;&amp;lt;stdin&amp;gt;&amp;quot;, line 1, in &amp;lt;module&amp;gt;&lt;br /&gt;
  NameError: name 'messaggio' is not defined&lt;br /&gt;
&lt;br /&gt;
NameError è una eccezione. Vedremo più avanti come queste situazioni di errore possono essere ''catturate'' e ''gestite'' appositamente, sia&lt;br /&gt;
per tentare di risolvere il problema che per migliorare il feedback che il nostro programma da all'utente. Vedremo anche come&lt;br /&gt;
la gestione delle eccezioni è parte della programmazione normale di un programma, ovvero non è sempre legata a una situazione di errore.&lt;br /&gt;
&lt;br /&gt;
Un altro esempio, tendando di sommare mele e pere:&lt;br /&gt;
  &amp;gt;&amp;gt;&amp;gt; print 1 + &amp;quot;a&amp;quot;&lt;br /&gt;
  Traceback (most recent call last):&lt;br /&gt;
    File &amp;quot;&amp;lt;stdin&amp;gt;&amp;quot;, line 1, in &amp;lt;module&amp;gt;&lt;br /&gt;
  TypeError: unsupported operand type(s) for +: 'int' and 'str'&lt;br /&gt;
&lt;br /&gt;
Vediamo che a questo giro l'eccezione lanciata è ValueError.&lt;br /&gt;
&lt;br /&gt;
== LE STRINGHE ==&lt;br /&gt;
Gli oggetti di tipo stringa supportano svariati metodi e proprietà. E' da notare che le stringhe sono immutabili.&lt;br /&gt;
Se una stringa viene dichiarata la seconda volta, quella precedente viene buttata, non viene modificata per fare spazio alla nuova.&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
    messaggio=”ciao mondo”&lt;br /&gt;
    print messaggio''&lt;br /&gt;
stampa&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
In Python non si possono sommare cose diverse, o meglio, lo posso fare solo se è definita una conversione tra i due tipo.&lt;br /&gt;
Le stringhe supportano anche alcuni operatori base:&lt;br /&gt;
    ''print messaggio*2'' &lt;br /&gt;
l'esecuzione darà&lt;br /&gt;
    ''messaggio messaggio&lt;br /&gt;
''&lt;br /&gt;
esempio:&lt;br /&gt;
     ''Print “ciao”+” mondo”''&lt;br /&gt;
lo eseguo e mi darà:&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
== '''Funzione DIR''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
    dir(messaggio)''&lt;br /&gt;
a questo punto il programma da una serie di caratteri incomprensibili.&lt;br /&gt;
Praticamente dà i '''metodi''' che suporta la stringa messaggio.&lt;br /&gt;
&lt;br /&gt;
== I '''metodi''' ==&lt;br /&gt;
sono operazioni che i vari oggetti supportano.&lt;br /&gt;
alcuni metodi, vedendo con la funzione dir(), iniziano e terminano con __ . Tali metodi, chiamati metodi speciali, non dovrebbero essere chiamati direttamente,&lt;br /&gt;
senza che ci sia una ragione specifica per farlo (ovvero: sapete quello che state facendo). In generale possono essere pensati come privati o riservati, anche se non &lt;br /&gt;
essendoci controlli di accesso come in altri linguaggi (public private del java o del c++ ad esempio) nessuno vieta di chiamarli.&lt;br /&gt;
&lt;br /&gt;
Ad esempio, il metodo __add__ delle stringhe è chiamato quando si fa la somma di due stringhe.&lt;br /&gt;
 ''&amp;quot;ciao&amp;quot; + &amp;quot; mondo&amp;quot;'' &lt;br /&gt;
chiama in realtà &lt;br /&gt;
 ''&amp;quot;ciao&amp;quot;.__add__(&amp;quot; mondo&amp;quot;)''&lt;br /&gt;
&lt;br /&gt;
''__ doc__'' ce l'hanno tutti gli oggetti (stringhe, interi...), e contiene una stringa di documentazione dell'oggetto. &lt;br /&gt;
&lt;br /&gt;
i metodi che iniziano per is servono per controllare se una certa proprietà della stringa in esame è vera:&lt;br /&gt;
es: &lt;br /&gt;
    ''messaggio.isalpha()''&lt;br /&gt;
mi dice se messaggio è o meno alfanumerico (composto solo da numeri e cifre, senza spazi, tab, ritorno carrello ecc ecc).&lt;br /&gt;
isalpha è un oggetto quindi ha le proprietà doc .&lt;br /&gt;
se io scrivo&lt;br /&gt;
    ''messaggio.isalpha.__doc__''&lt;br /&gt;
mi dice che fa.&lt;br /&gt;
&lt;br /&gt;
es:&lt;br /&gt;
    '' messaggio=”gigio”&lt;br /&gt;
    messaggio2= messaggio.upper()''&lt;br /&gt;
&lt;br /&gt;
es:&lt;br /&gt;
''TYPE(3)''&lt;br /&gt;
mi dice che variabile  è. se è intero o stringa oppure un complesso, un float o un tipo definito dall'utente.&lt;br /&gt;
Se io scrivo ''DIR(3)''&lt;br /&gt;
mi da tutta la lista dei metodi e delle proprietà degli int (dato che 3 è in intero)&lt;br /&gt;
'''&lt;br /&gt;
&lt;br /&gt;
Esistono stringhe, interi, float (numeri con virgola)booleano (che ha due valori, vero o falso, True e False)e i vari contenitori:&lt;br /&gt;
&lt;br /&gt;
== '''LE LISTE''' ==&lt;br /&gt;
&lt;br /&gt;
es. lo scaffale ha I pc, I pc sono oggetti (pc1,pc2...).Se voglio uno scaffale di pc senza dare I nomi a tutti gli oggetti, definisco lo scaffale.&lt;br /&gt;
Lo scaffale si chiama''' Lista'''  .si usano le parentesi quadre con oggetti separati da virgola&lt;br /&gt;
es.    '' a = [ “pc1” , “schermo rotto” , 2]&lt;br /&gt;
dir (scaffale)''&lt;br /&gt;
da la lista dei metodi, da qui si capisce che la lista è un oggetto.&lt;br /&gt;
Se io faccio&lt;br /&gt;
    ''b = dir (a)''&lt;br /&gt;
o&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a il 4.&lt;br /&gt;
'''la lista MUTA!'''&lt;br /&gt;
Se faccio     ''print (“a”)''&lt;br /&gt;
mi da la lista degli oggetti più il 4.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''TUPLE''' ==&lt;br /&gt;
&lt;br /&gt;
è una lista non mutabile.&lt;br /&gt;
La tupla è molto piu veloce rispetto alla lista.&lt;br /&gt;
Con tuple si usano le parentesi tonde.&lt;br /&gt;
&lt;br /&gt;
== '''DIZIONARI''' ==&lt;br /&gt;
&lt;br /&gt;
il dizionario si definisce con le parentesi graffe {chiave:valore, chiave:valore}&lt;br /&gt;
a{chiave}&lt;br /&gt;
da il valore associato alla chiave.&lt;br /&gt;
&lt;br /&gt;
Dizionari liste e tuple sono dele sequenze e sono iterable e si possono scorrere.&lt;br /&gt;
&lt;br /&gt;
== '''If elif else''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
if condizione :&lt;br /&gt;
&lt;br /&gt;
indentato roba da fare se vero.&lt;br /&gt;
&lt;br /&gt;
Python supporta o tab o spazio, si decide quanti tab o spazi alla prima indentazione.&lt;br /&gt;
Meglio lo spazio perchè in futuro I tab verranno lasciati.&lt;br /&gt;
Di solito si usa 4 spazi.&lt;br /&gt;
Non c'è la graffa in pyton o I begin o gli end, si chiude e si apre la riga solo se si indenta.&lt;br /&gt;
&lt;br /&gt;
Esempio:&lt;br /&gt;
    ''a=3&lt;br /&gt;
    b=1''&lt;br /&gt;
&lt;br /&gt;
    ''if a &amp;gt;b:&lt;br /&gt;
      print (“ a è maggiore di b”)&lt;br /&gt;
    elif a==b:&lt;br /&gt;
      print (“ a è uguale a b”)&lt;br /&gt;
    else:&lt;br /&gt;
       print(“b è maggiore di a”)''&lt;br /&gt;
&lt;br /&gt;
in questo programma definisco due valori, a e b.&lt;br /&gt;
Chiedo al programma se aè maggiore di b di scrivere : a è maggiore di b, se a è uguale a b di scrivere che a è uguale a b e in tutte le altre condizioni (else) di scrivere che a è minore di b.&lt;br /&gt;
&lt;br /&gt;
	'''2.is, is not or, and,!='''&lt;br /&gt;
    ''if a is 1:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
    elif a is not 1:&lt;br /&gt;
      print (“no”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 and b is 3:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 or b is 3:&lt;br /&gt;
      print (“okkei”)&lt;br /&gt;
''&lt;br /&gt;
&lt;br /&gt;
'''!= è il diverso.'''&lt;br /&gt;
&lt;br /&gt;
== '''append, insert''' ==&lt;br /&gt;
&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a il 4.&lt;br /&gt;
Se faccio print (“a”)&lt;br /&gt;
mi da la lista degli oggetti più il 4.&lt;br /&gt;
&lt;br /&gt;
con '''insert''' devo inserire anche la posizione&lt;br /&gt;
    ''a.insert(2,34)''&lt;br /&gt;
mette il 34 in posizione 2&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''for''' ==&lt;br /&gt;
&lt;br /&gt;
specifica un ciclo, fa le cose tante volte fino ad una condizione.&lt;br /&gt;
For variabile in una sequenza di qualche tipo.&lt;br /&gt;
Es:     ''for elemento in a:&lt;br /&gt;
               print elemento''&lt;br /&gt;
&lt;br /&gt;
es b è una tupla.&lt;br /&gt;
Allora posso scrivere:&lt;br /&gt;
    ''for elem in b&lt;br /&gt;
         print “altro elemento”&lt;br /&gt;
         “print elem”''&lt;br /&gt;
&lt;br /&gt;
elem o qualsiasi altro nome gli dia è ogni elemento dentro la tupla o lista o dizionario.&lt;br /&gt;
&lt;br /&gt;
Se io voglio sia la chiave sia il valore in un dizionario (se metto elem mi mette solo la chiave) posso fare:&lt;br /&gt;
for chiave in a:&lt;br /&gt;
	    ''print “chiave: “ + chiave&lt;br /&gt;
	    print “valore: “ + a[chiave]''&lt;br /&gt;
&lt;br /&gt;
'''DOPO I DUE PUNTI METTO SEMPRE IL TAB.'''&lt;br /&gt;
&lt;br /&gt;
== '''xrange''' ==&lt;br /&gt;
&lt;br /&gt;
xrange è un iterable di dieci elementi con il primo valore uguale a 0 .E' una lista ma non ha le proprietà di una lista.&lt;br /&gt;
se io voglio fare un for da uno a dieci (cioè la somma da uno a 10)&lt;br /&gt;
&lt;br /&gt;
es:     ''for I xrange(10)&lt;br /&gt;
               print I''&lt;br /&gt;
lui stampa&lt;br /&gt;
''1&lt;br /&gt;
2&lt;br /&gt;
3&lt;br /&gt;
4&lt;br /&gt;
5&lt;br /&gt;
6&lt;br /&gt;
7&lt;br /&gt;
8&lt;br /&gt;
9&lt;br /&gt;
10''&lt;br /&gt;
&lt;br /&gt;
== '''range''' ==&lt;br /&gt;
&lt;br /&gt;
è una lista.se io scrivo:&lt;br /&gt;
    ''print range(10)''&lt;br /&gt;
lui mi da     ''[0,1,2,3,4,5,6,7,8,9].''&lt;br /&gt;
è più lento di xrange e poi sta morendo&lt;br /&gt;
&lt;br /&gt;
== '''len''' ==&lt;br /&gt;
&lt;br /&gt;
    ''len (a)''&lt;br /&gt;
da la lunghezza della stringa&lt;br /&gt;
&lt;br /&gt;
== '''enumerate''' ==&lt;br /&gt;
&lt;br /&gt;
se io ho una lista di tre elmenti&lt;br /&gt;
''a=[“ciao”,”bel”, “mondo”]''&lt;br /&gt;
&lt;br /&gt;
''for I, elem in enumerate(a):&lt;br /&gt;
     print str(I) + “:” + elem&lt;br /&gt;
''&lt;br /&gt;
da la posizione corrente di ogni elemento.&lt;br /&gt;
''0:ciao&lt;br /&gt;
1:bel&lt;br /&gt;
2:mondo''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''raw_input''' ==&lt;br /&gt;
&lt;br /&gt;
dai il valore.&lt;br /&gt;
''Base= raw_input (“inserisce la base:”)&lt;br /&gt;
esponente=raw_input (“inserisci l'/ esponente”)''&lt;br /&gt;
&lt;br /&gt;
ti chiede il valore di base ed esponente.&lt;br /&gt;
&lt;br /&gt;
== '''Int''' ==&lt;br /&gt;
&lt;br /&gt;
forza il fatto che quel valore sia un intero.&lt;br /&gt;
''&lt;br /&gt;
Es:base=int(base)&lt;br /&gt;
  result=int(result)''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''UPPER,LOWER,CAPITALIZE''' ==&lt;br /&gt;
&lt;br /&gt;
'''capitalize''' è un comando che sulla la stringa su cui viene applicato ,prende la prima lettera dopo gli spazi e ci mette la maiuscola&lt;br /&gt;
&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.capitalize()''&lt;br /&gt;
    ''Ciao mondo''&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.title()&lt;br /&gt;
    Ciao Mondo''&lt;br /&gt;
&lt;br /&gt;
'''LOWER:''' prende la striga e emette tutto minuscolo&lt;br /&gt;
'''UPPER:''' il contrario di lower&lt;br /&gt;
&lt;br /&gt;
== '''ESEMPIO DELLA SERATA:''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Calcolo di una potenza.&lt;br /&gt;
&lt;br /&gt;
    ''&lt;br /&gt;
    base= raw_input (“inserisce la base:”)&lt;br /&gt;
    esponente=raw_input ('inserisci l\' esponente')&lt;br /&gt;
&lt;br /&gt;
    base=int(base)&lt;br /&gt;
    result=int(result)&lt;br /&gt;
&lt;br /&gt;
    result=1&lt;br /&gt;
    for i in xrange(esponente):&lt;br /&gt;
         result = result * base&lt;br /&gt;
    print result''&lt;br /&gt;
&lt;br /&gt;
il [http://docs.python.org/lib/built-in-funcs.html built-in] int() è necessario, dato che tutto quello che proviene dalla tastiera viene acquisito da raw_input() come stringa. Dato che dobbiamo usarli come interi, occorre effettuare un cast, ovvero&lt;br /&gt;
una trasformazione di tipo, da stringa a intero.&lt;br /&gt;
E' interessante notare che int() non cerca di fare i miracoli: provate a vedere cosa succede se cercate di convertire &amp;quot;awlerorj&amp;quot; in int!&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3732</id>
		<title>Python Lezione 4 Giugno 2008</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3732"/>
		<updated>2008-06-06T08:37:58Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: /* '''ESEMPIO DELLA SERATA:''' */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Python ==&lt;br /&gt;
[http://www.python.it/ Python] è un linguaggio di programmazione [http://it.wikipedia.org/wiki/Interprete_(informatica) interpretato].&lt;br /&gt;
Il linuaggio interpretato è simile agli altri linguaggi in circolazione ma, invece di essere trasformato direttamente in codice binario dal meccanismo automatico, viene interpretato da questo e poi mandato all'hardware.&lt;br /&gt;
Un linguaggio interpretato non ha bisogno di essere ricompilato: il codice scritto viene interpretato da un interprete a run-time (tempo di esecuzione) e tradotto al volo nel linguaggio macchina.&lt;br /&gt;
Quindi i programmi python possono girare su qualsiasi hardware e sistema operativo su cui è stato portato l'interprete. Ovviamente, questa cosa si paga sul tempo di esecuzione pure: l'approccio ha si i suoi vantaggi, ma rispetto a un linguaggio compilato direttamente in linguaggio macchina per creare un eseguibile, python e gli altri liguaggi interpretati risultano essere più lenti.&lt;br /&gt;
&lt;br /&gt;
Esistono vari interpreti: [http://www.python.org Cpython], o classic python, è l'interprete &amp;quot;ufficiale&amp;quot;, scritto in C e disponibile per linux, mac e windows.&lt;br /&gt;
[http://www.jython.org/Project/ Jython] è un interprete scritto al 100% in Java, e si interfaccia strettamente ai programmi e alla libreria Java, &lt;br /&gt;
[http://www.codeplex.com/Wiki/View.aspx?ProjectName=IronPython IronPython] è un interprete python che gira sulla piattaforma .NET mentre &lt;br /&gt;
[http://codespeak.net/pypy/dist/pypy/doc/home.html PyPy] è (anche) un interprete python scritto in.. python&lt;br /&gt;
&lt;br /&gt;
La prima riga di ogni script python deve iniziare con #!/usr/bin/env python&lt;br /&gt;
&lt;br /&gt;
il #! del file fa capire al sistema operativo (solo su sistemi posix, quindi unix/linux) che quello non è un file di testo ma un eseguibile da eseguire con l'inteprete python.&lt;br /&gt;
&lt;br /&gt;
== COMMENTI ==&lt;br /&gt;
&lt;br /&gt;
: sono righe che l'interprete salta e non legge &lt;br /&gt;
es: &lt;br /&gt;
    ''# stampa:”hello word”''&lt;br /&gt;
&lt;br /&gt;
== PRINT ==&lt;br /&gt;
Lo statement [http://docs.python.org/ref/print.html print] valuta tutte le espressioni presenti e quindi le stampa a video.&lt;br /&gt;
L'espressione da valutare può essere anche un semplice numero o una semplice stringa&lt;br /&gt;
&lt;br /&gt;
    ''print 3''&lt;br /&gt;
stampa 3, e anche se scrivo&lt;br /&gt;
    '' print “3”''&lt;br /&gt;
stampa lo stesso anche se abbiamo passato prima un intero, poi una stringa.&lt;br /&gt;
Questo è normale, perchè il numero &amp;quot;tre&amp;quot; viene rappresentato dal simbolo 3 nel sistema decimale.&lt;br /&gt;
&lt;br /&gt;
Invece, se scrivo&lt;br /&gt;
    ''print 3+2''&lt;br /&gt;
otteniamo a video 5: l'inteprete ha valutato l'espressione, ha eseguito la somma e stampato il situlato.&lt;br /&gt;
Mentre se scriviamo&lt;br /&gt;
    ''print “3+2”''&lt;br /&gt;
il risolutato è &lt;br /&gt;
    ''3+2''&lt;br /&gt;
in quanto abbiamo passato la stringa composta dal carattere 3, dal simbolo + e dal carattere 2.&lt;br /&gt;
&lt;br /&gt;
Le variabili in python non devono essere dichiarate: esistono dalla prima volta in cui gli viene assegnato un valore&lt;br /&gt;
    ''messaggio=”hello world”''&lt;br /&gt;
    ''print messaggio''&lt;br /&gt;
se questo programma viene eseguito il risultatato sarà:&lt;br /&gt;
''hello world''&lt;br /&gt;
l'interprete valuta l'espressione ''messaggio'' e stampa il suo contenuto&lt;br /&gt;
&lt;br /&gt;
== ECCEZIONE ==&lt;br /&gt;
:se io commento la definizione di messaggio (es: ''# messaggio = &amp;quot; hello world &amp;quot;'' ) il programma non sa cos'è messaggio e se scrivo:&lt;br /&gt;
    ''print &amp;quot;messaggio&amp;quot;''&lt;br /&gt;
il risultato sarà:name error, che, viene chiamato eccezione.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== LE STRINGHE ==&lt;br /&gt;
Gli oggetti di tipo stringa supportano svariati metodi e proprietà. E' da notare che le stringhe sono immutabili.&lt;br /&gt;
Se una stringa viene dichiarata la seconda volta, quella precedente viene buttata, non viene modificata per fare spazio alla nuova.&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
    messaggio=”ciao mondo”&lt;br /&gt;
    print “messaggio”''&lt;br /&gt;
stampa&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
In Python non si possono sommare cose diverse, o meglio, lo posso fare solo se è definita una conversione tra i due tipo.&lt;br /&gt;
Le stringhe supportano anche alcuni operatori base:&lt;br /&gt;
    ''print messaggio*2'' &lt;br /&gt;
l'esecuzione darà&lt;br /&gt;
    ''messaggio messaggio&lt;br /&gt;
''&lt;br /&gt;
esempio:&lt;br /&gt;
     ''Print “ciao”+” mondo”''&lt;br /&gt;
lo eseguo e mi darà:&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
== '''Funzione DIR''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
    dir(messaggio)''&lt;br /&gt;
a questo punto il programma da una serie di caratteri incomprensibili.&lt;br /&gt;
Praticamente dà i '''metodi''' che suporta la stringa messaggio.&lt;br /&gt;
&lt;br /&gt;
== I '''metodi''' ==&lt;br /&gt;
sono operazioni che i vari oggetti supportano.&lt;br /&gt;
alcuni metodi, vedendo con la funzione dir(), iniziano e terminano con __ . Tali metodi, chiamati metodi speciali, non dovrebbero essere chiamati direttamente,&lt;br /&gt;
senza che ci sia una ragione specifica per farlo (ovvero: sapete quello che state facendo). In generale possono essere pensati come privati o riservati, anche se non &lt;br /&gt;
essendoci controlli di accesso come in altri linguaggi (public private del java o del c++ ad esempio) nessuno vieta di chiamarli.&lt;br /&gt;
&lt;br /&gt;
Ad esempio, il metodo __add__ delle stringhe è chiamato quando si fa la somma di due stringhe.&lt;br /&gt;
 ''&amp;quot;ciao&amp;quot; + &amp;quot; mondo&amp;quot;'' &lt;br /&gt;
chiama in realtà &lt;br /&gt;
 ''&amp;quot;ciao&amp;quot;.__add__(&amp;quot; mondo&amp;quot;)''&lt;br /&gt;
&lt;br /&gt;
''__ doc__'' ce l'hanno tutti gli oggetti (stringhe, interi...), e contiene una stringa di documentazione dell'oggetto. &lt;br /&gt;
&lt;br /&gt;
i metodi che iniziano per is servono per controllare se una certa proprietà della stringa in esame è vera:&lt;br /&gt;
es: &lt;br /&gt;
    ''messaggio.isalpha()''&lt;br /&gt;
mi dice se messaggio è o meno alfanumerico (composto solo da numeri e cifre, senza spazi, tab, ritorno carrello ecc ecc).&lt;br /&gt;
isalpha è un oggetto quindi ha le proprietà doc .&lt;br /&gt;
se io scrivo&lt;br /&gt;
    ''messaggio.isalpha.__doc__''&lt;br /&gt;
mi dice che fa.&lt;br /&gt;
&lt;br /&gt;
es:&lt;br /&gt;
    '' messaggio=”gigio”&lt;br /&gt;
    messaggio2= messaggio.upper()''&lt;br /&gt;
&lt;br /&gt;
es:&lt;br /&gt;
''TYPE(3)''&lt;br /&gt;
mi dice che variabile  è. se è intero o stringa oppure un complesso, un float o un tipo definito dall'utente.&lt;br /&gt;
Se io scrivo ''DIR(3)''&lt;br /&gt;
mi da tutta la lista dei metodi e delle proprietà degli int (dato che 3 è in intero)&lt;br /&gt;
'''&lt;br /&gt;
&lt;br /&gt;
Esistono stringhe, interi, float (numeri con virgola)booleano (che ha due valori, vero o falso, True e False)e i vari contenitori:&lt;br /&gt;
&lt;br /&gt;
== '''LE LISTE''' ==&lt;br /&gt;
&lt;br /&gt;
es. lo scaffale ha I pc, I pc sono oggetti (pc1,pc2...).Se voglio uno scaffale di pc senza dare I nomi a tutti gli oggetti, definisco lo scaffale.&lt;br /&gt;
Lo scaffale si chiama''' Lista'''  .si usano le parentesi quadre con oggetti separati da virgola&lt;br /&gt;
es.    '' a = [ “pc1” , “schermo rotto” , 2]&lt;br /&gt;
dir (scaffale)''&lt;br /&gt;
da la lista dei metodi, da qui si capisce che la lista è un oggetto.&lt;br /&gt;
Se io faccio&lt;br /&gt;
    ''b = dir (a)''&lt;br /&gt;
o&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a il 4.&lt;br /&gt;
'''la lista MUTA!'''&lt;br /&gt;
Se faccio     ''print (“a”)''&lt;br /&gt;
mi da la lista degli oggetti più il 4.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''TUPLE''' ==&lt;br /&gt;
&lt;br /&gt;
è una lista non mutabile.&lt;br /&gt;
La tupla è molto piu veloce rispetto alla lista.&lt;br /&gt;
Con tuple si usano le parentesi tonde.&lt;br /&gt;
&lt;br /&gt;
== '''DIZIONARI''' ==&lt;br /&gt;
&lt;br /&gt;
il dizionario si definisce con le parentesi graffe {chiave:valore, chiave:valore}&lt;br /&gt;
a{chiave}&lt;br /&gt;
da il valore associato alla chiave.&lt;br /&gt;
&lt;br /&gt;
Dizionari liste e tuple sono dele sequenze e sono iterable e si possono scorrere.&lt;br /&gt;
&lt;br /&gt;
== '''If elif else''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
if condizione :&lt;br /&gt;
&lt;br /&gt;
indentato roba da fare se vero.&lt;br /&gt;
&lt;br /&gt;
Python supporta o tab o spazio, si decide quanti tab o spazi alla prima indentazione.&lt;br /&gt;
Meglio lo spazio perchè in futuro I tab verranno lasciati.&lt;br /&gt;
Di solito si usa 4 spazi.&lt;br /&gt;
Non c'è la graffa in pyton o I begin o gli end, si chiude e si apre la riga solo se si indenta.&lt;br /&gt;
&lt;br /&gt;
Esempio:&lt;br /&gt;
    ''a=3&lt;br /&gt;
    b=1''&lt;br /&gt;
&lt;br /&gt;
    ''if a &amp;gt;b:&lt;br /&gt;
      print (“ a è maggiore di b”)&lt;br /&gt;
    elif a==b:&lt;br /&gt;
      print (“ a è uguale a b”)&lt;br /&gt;
    else:&lt;br /&gt;
       print(“b è maggiore di a”)''&lt;br /&gt;
&lt;br /&gt;
in questo programma definisco due valori, a e b.&lt;br /&gt;
Chiedo al programma se aè maggiore di b di scrivere : a è maggiore di b, se a è uguale a b di scrivere che a è uguale a b e in tutte le altre condizioni (else) di scrivere che a è minore di b.&lt;br /&gt;
&lt;br /&gt;
	'''2.is, is not or, and,!='''&lt;br /&gt;
    ''if a is 1:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
    elif a is not 1:&lt;br /&gt;
      print (“no”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 and b is 3:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 or b is 3:&lt;br /&gt;
      print (“okkei”)&lt;br /&gt;
''&lt;br /&gt;
&lt;br /&gt;
'''!= è il diverso.'''&lt;br /&gt;
&lt;br /&gt;
== '''append, insert''' ==&lt;br /&gt;
&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a il 4.&lt;br /&gt;
Se faccio print (“a”)&lt;br /&gt;
mi da la lista degli oggetti più il 4.&lt;br /&gt;
&lt;br /&gt;
con '''insert''' devo inserire anche la posizione&lt;br /&gt;
    ''a.insert(2,34)''&lt;br /&gt;
mette il 34 in posizione 2&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''for''' ==&lt;br /&gt;
&lt;br /&gt;
specifica un ciclo, fa le cose tante volte fino ad una condizione.&lt;br /&gt;
For variabile in una sequenza di qualche tipo.&lt;br /&gt;
Es:     ''for elemento in a:&lt;br /&gt;
               print elemento''&lt;br /&gt;
&lt;br /&gt;
es b è una tupla.&lt;br /&gt;
Allora posso scrivere:&lt;br /&gt;
    ''for elem in b&lt;br /&gt;
         print “altro elemento”&lt;br /&gt;
         “print elem”''&lt;br /&gt;
&lt;br /&gt;
elem o qualsiasi altro nome gli dia è ogni elemento dentro la tupla o lista o dizionario.&lt;br /&gt;
&lt;br /&gt;
Se io voglio sia la chiave sia il valore in un dizionario (se metto elem mi mette solo la chiave) posso fare:&lt;br /&gt;
for chiave in a:&lt;br /&gt;
	    ''print “chiave: “ + chiave&lt;br /&gt;
	    print “valore: “ + a[chiave]''&lt;br /&gt;
&lt;br /&gt;
'''DOPO I DUE PUNTI METTO SEMPRE IL TAB.'''&lt;br /&gt;
&lt;br /&gt;
== '''xrange''' ==&lt;br /&gt;
&lt;br /&gt;
xrange è un iterable di dieci elementi con il primo valore uguale a 0 .E' una lista ma non ha le proprietà di una lista.&lt;br /&gt;
se io voglio fare un for da uno a dieci (cioè la somma da uno a 10)&lt;br /&gt;
&lt;br /&gt;
es:     ''for I xrange(10)&lt;br /&gt;
               print I''&lt;br /&gt;
lui stampa&lt;br /&gt;
''1&lt;br /&gt;
2&lt;br /&gt;
3&lt;br /&gt;
4&lt;br /&gt;
5&lt;br /&gt;
6&lt;br /&gt;
7&lt;br /&gt;
8&lt;br /&gt;
9&lt;br /&gt;
10''&lt;br /&gt;
&lt;br /&gt;
== '''range''' ==&lt;br /&gt;
&lt;br /&gt;
è una lista.se io scrivo:&lt;br /&gt;
    ''print range(10)''&lt;br /&gt;
lui mi da     ''[0,1,2,3,4,5,6,7,8,9].''&lt;br /&gt;
è più lento di xrange e poi sta morendo&lt;br /&gt;
&lt;br /&gt;
== '''len''' ==&lt;br /&gt;
&lt;br /&gt;
    ''len (a)''&lt;br /&gt;
da la lunghezza della stringa&lt;br /&gt;
&lt;br /&gt;
== '''enumerate''' ==&lt;br /&gt;
&lt;br /&gt;
se io ho una lista di tre elmenti&lt;br /&gt;
''a=[“ciao”,”bel”, “mondo”]''&lt;br /&gt;
&lt;br /&gt;
''for I, elem in enumerate(a):&lt;br /&gt;
     print str(I) + “:” + elem&lt;br /&gt;
''&lt;br /&gt;
da la posizione corrente di ogni elemento.&lt;br /&gt;
''0:ciao&lt;br /&gt;
1:bel&lt;br /&gt;
2:mondo''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''raw_input''' ==&lt;br /&gt;
&lt;br /&gt;
dai il valore.&lt;br /&gt;
''Base= raw_input (“inserisce la base:”)&lt;br /&gt;
esponente=raw_input (“inserisci l'/ esponente”)''&lt;br /&gt;
&lt;br /&gt;
ti chiede il valore di base ed esponente.&lt;br /&gt;
&lt;br /&gt;
== '''Int''' ==&lt;br /&gt;
&lt;br /&gt;
forza il fatto che quel valore sia un intero.&lt;br /&gt;
''&lt;br /&gt;
Es:base=int(base)&lt;br /&gt;
  result=int(result)''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''UPPER,LOWER,CAPITALIZE''' ==&lt;br /&gt;
&lt;br /&gt;
'''capitalize''' è un comando che sulla la stringa su cui viene applicato ,prende la prima lettera dopo gli spazi e ci mette la maiuscola&lt;br /&gt;
&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.capitalize()''&lt;br /&gt;
    ''Ciao mondo''&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.title()&lt;br /&gt;
    Ciao Mondo''&lt;br /&gt;
&lt;br /&gt;
'''LOWER:''' prende la striga e emette tutto minuscolo&lt;br /&gt;
'''UPPER:''' il contrario di lower&lt;br /&gt;
&lt;br /&gt;
== '''ESEMPIO DELLA SERATA:''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Calcolo di una potenza.&lt;br /&gt;
&lt;br /&gt;
    ''&lt;br /&gt;
    base= raw_input (“inserisce la base:”)&lt;br /&gt;
    esponente=raw_input ('inserisci l\' esponente')&lt;br /&gt;
&lt;br /&gt;
    base=int(base)&lt;br /&gt;
    result=int(result)&lt;br /&gt;
&lt;br /&gt;
    result=1&lt;br /&gt;
    for i in xrange(esponente):&lt;br /&gt;
         result = result * base&lt;br /&gt;
    print result''&lt;br /&gt;
&lt;br /&gt;
il [http://docs.python.org/lib/built-in-funcs.html built-in] int() è necessario, dato che tutto quello che proviene dalla tastiera viene acquisito da raw_input() come stringa. Dato che dobbiamo usarli come interi, occorre effettuare un cast, ovvero&lt;br /&gt;
una trasformazione di tipo, da stringa a intero.&lt;br /&gt;
E' interessante notare che int() non cerca di fare i miracoli: provate a vedere cosa succede se cercate di convertire &amp;quot;awlerorj&amp;quot; in int!&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3731</id>
		<title>Python Lezione 4 Giugno 2008</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3731"/>
		<updated>2008-06-06T08:37:20Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: /* I '''metodi''' */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Python ==&lt;br /&gt;
[http://www.python.it/ Python] è un linguaggio di programmazione [http://it.wikipedia.org/wiki/Interprete_(informatica) interpretato].&lt;br /&gt;
Il linuaggio interpretato è simile agli altri linguaggi in circolazione ma, invece di essere trasformato direttamente in codice binario dal meccanismo automatico, viene interpretato da questo e poi mandato all'hardware.&lt;br /&gt;
Un linguaggio interpretato non ha bisogno di essere ricompilato: il codice scritto viene interpretato da un interprete a run-time (tempo di esecuzione) e tradotto al volo nel linguaggio macchina.&lt;br /&gt;
Quindi i programmi python possono girare su qualsiasi hardware e sistema operativo su cui è stato portato l'interprete. Ovviamente, questa cosa si paga sul tempo di esecuzione pure: l'approccio ha si i suoi vantaggi, ma rispetto a un linguaggio compilato direttamente in linguaggio macchina per creare un eseguibile, python e gli altri liguaggi interpretati risultano essere più lenti.&lt;br /&gt;
&lt;br /&gt;
Esistono vari interpreti: [http://www.python.org Cpython], o classic python, è l'interprete &amp;quot;ufficiale&amp;quot;, scritto in C e disponibile per linux, mac e windows.&lt;br /&gt;
[http://www.jython.org/Project/ Jython] è un interprete scritto al 100% in Java, e si interfaccia strettamente ai programmi e alla libreria Java, &lt;br /&gt;
[http://www.codeplex.com/Wiki/View.aspx?ProjectName=IronPython IronPython] è un interprete python che gira sulla piattaforma .NET mentre &lt;br /&gt;
[http://codespeak.net/pypy/dist/pypy/doc/home.html PyPy] è (anche) un interprete python scritto in.. python&lt;br /&gt;
&lt;br /&gt;
La prima riga di ogni script python deve iniziare con #!/usr/bin/env python&lt;br /&gt;
&lt;br /&gt;
il #! del file fa capire al sistema operativo (solo su sistemi posix, quindi unix/linux) che quello non è un file di testo ma un eseguibile da eseguire con l'inteprete python.&lt;br /&gt;
&lt;br /&gt;
== COMMENTI ==&lt;br /&gt;
&lt;br /&gt;
: sono righe che l'interprete salta e non legge &lt;br /&gt;
es: &lt;br /&gt;
    ''# stampa:”hello word”''&lt;br /&gt;
&lt;br /&gt;
== PRINT ==&lt;br /&gt;
Lo statement [http://docs.python.org/ref/print.html print] valuta tutte le espressioni presenti e quindi le stampa a video.&lt;br /&gt;
L'espressione da valutare può essere anche un semplice numero o una semplice stringa&lt;br /&gt;
&lt;br /&gt;
    ''print 3''&lt;br /&gt;
stampa 3, e anche se scrivo&lt;br /&gt;
    '' print “3”''&lt;br /&gt;
stampa lo stesso anche se abbiamo passato prima un intero, poi una stringa.&lt;br /&gt;
Questo è normale, perchè il numero &amp;quot;tre&amp;quot; viene rappresentato dal simbolo 3 nel sistema decimale.&lt;br /&gt;
&lt;br /&gt;
Invece, se scrivo&lt;br /&gt;
    ''print 3+2''&lt;br /&gt;
otteniamo a video 5: l'inteprete ha valutato l'espressione, ha eseguito la somma e stampato il situlato.&lt;br /&gt;
Mentre se scriviamo&lt;br /&gt;
    ''print “3+2”''&lt;br /&gt;
il risolutato è &lt;br /&gt;
    ''3+2''&lt;br /&gt;
in quanto abbiamo passato la stringa composta dal carattere 3, dal simbolo + e dal carattere 2.&lt;br /&gt;
&lt;br /&gt;
Le variabili in python non devono essere dichiarate: esistono dalla prima volta in cui gli viene assegnato un valore&lt;br /&gt;
    ''messaggio=”hello world”''&lt;br /&gt;
    ''print messaggio''&lt;br /&gt;
se questo programma viene eseguito il risultatato sarà:&lt;br /&gt;
''hello world''&lt;br /&gt;
l'interprete valuta l'espressione ''messaggio'' e stampa il suo contenuto&lt;br /&gt;
&lt;br /&gt;
== ECCEZIONE ==&lt;br /&gt;
:se io commento la definizione di messaggio (es: ''# messaggio = &amp;quot; hello world &amp;quot;'' ) il programma non sa cos'è messaggio e se scrivo:&lt;br /&gt;
    ''print &amp;quot;messaggio&amp;quot;''&lt;br /&gt;
il risultato sarà:name error, che, viene chiamato eccezione.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== LE STRINGHE ==&lt;br /&gt;
Gli oggetti di tipo stringa supportano svariati metodi e proprietà. E' da notare che le stringhe sono immutabili.&lt;br /&gt;
Se una stringa viene dichiarata la seconda volta, quella precedente viene buttata, non viene modificata per fare spazio alla nuova.&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
    messaggio=”ciao mondo”&lt;br /&gt;
    print “messaggio”''&lt;br /&gt;
stampa&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
In Python non si possono sommare cose diverse, o meglio, lo posso fare solo se è definita una conversione tra i due tipo.&lt;br /&gt;
Le stringhe supportano anche alcuni operatori base:&lt;br /&gt;
    ''print messaggio*2'' &lt;br /&gt;
l'esecuzione darà&lt;br /&gt;
    ''messaggio messaggio&lt;br /&gt;
''&lt;br /&gt;
esempio:&lt;br /&gt;
     ''Print “ciao”+” mondo”''&lt;br /&gt;
lo eseguo e mi darà:&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
== '''Funzione DIR''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
    dir(messaggio)''&lt;br /&gt;
a questo punto il programma da una serie di caratteri incomprensibili.&lt;br /&gt;
Praticamente dà i '''metodi''' che suporta la stringa messaggio.&lt;br /&gt;
&lt;br /&gt;
== I '''metodi''' ==&lt;br /&gt;
sono operazioni che i vari oggetti supportano.&lt;br /&gt;
alcuni metodi, vedendo con la funzione dir(), iniziano e terminano con __ . Tali metodi, chiamati metodi speciali, non dovrebbero essere chiamati direttamente,&lt;br /&gt;
senza che ci sia una ragione specifica per farlo (ovvero: sapete quello che state facendo). In generale possono essere pensati come privati o riservati, anche se non &lt;br /&gt;
essendoci controlli di accesso come in altri linguaggi (public private del java o del c++ ad esempio) nessuno vieta di chiamarli.&lt;br /&gt;
&lt;br /&gt;
Ad esempio, il metodo __add__ delle stringhe è chiamato quando si fa la somma di due stringhe.&lt;br /&gt;
 ''&amp;quot;ciao&amp;quot; + &amp;quot; mondo&amp;quot;'' &lt;br /&gt;
chiama in realtà &lt;br /&gt;
 ''&amp;quot;ciao&amp;quot;.__add__(&amp;quot; mondo&amp;quot;)''&lt;br /&gt;
&lt;br /&gt;
''__ doc__'' ce l'hanno tutti gli oggetti (stringhe, interi...), e contiene una stringa di documentazione dell'oggetto. &lt;br /&gt;
&lt;br /&gt;
i metodi che iniziano per is servono per controllare se una certa proprietà della stringa in esame è vera:&lt;br /&gt;
es: &lt;br /&gt;
    ''messaggio.isalpha()''&lt;br /&gt;
mi dice se messaggio è o meno alfanumerico (composto solo da numeri e cifre, senza spazi, tab, ritorno carrello ecc ecc).&lt;br /&gt;
isalpha è un oggetto quindi ha le proprietà doc .&lt;br /&gt;
se io scrivo&lt;br /&gt;
    ''messaggio.isalpha.__doc__''&lt;br /&gt;
mi dice che fa.&lt;br /&gt;
&lt;br /&gt;
es:&lt;br /&gt;
    '' messaggio=”gigio”&lt;br /&gt;
    messaggio2= messaggio.upper()''&lt;br /&gt;
&lt;br /&gt;
es:&lt;br /&gt;
''TYPE(3)''&lt;br /&gt;
mi dice che variabile  è. se è intero o stringa oppure un complesso, un float o un tipo definito dall'utente.&lt;br /&gt;
Se io scrivo ''DIR(3)''&lt;br /&gt;
mi da tutta la lista dei metodi e delle proprietà degli int (dato che 3 è in intero)&lt;br /&gt;
'''&lt;br /&gt;
&lt;br /&gt;
Esistono stringhe, interi, float (numeri con virgola)booleano (che ha due valori, vero o falso, True e False)e i vari contenitori:&lt;br /&gt;
&lt;br /&gt;
== '''LE LISTE''' ==&lt;br /&gt;
&lt;br /&gt;
es. lo scaffale ha I pc, I pc sono oggetti (pc1,pc2...).Se voglio uno scaffale di pc senza dare I nomi a tutti gli oggetti, definisco lo scaffale.&lt;br /&gt;
Lo scaffale si chiama''' Lista'''  .si usano le parentesi quadre con oggetti separati da virgola&lt;br /&gt;
es.    '' a = [ “pc1” , “schermo rotto” , 2]&lt;br /&gt;
dir (scaffale)''&lt;br /&gt;
da la lista dei metodi, da qui si capisce che la lista è un oggetto.&lt;br /&gt;
Se io faccio&lt;br /&gt;
    ''b = dir (a)''&lt;br /&gt;
o&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a il 4.&lt;br /&gt;
'''la lista MUTA!'''&lt;br /&gt;
Se faccio     ''print (“a”)''&lt;br /&gt;
mi da la lista degli oggetti più il 4.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''TUPLE''' ==&lt;br /&gt;
&lt;br /&gt;
è una lista non mutabile.&lt;br /&gt;
La tupla è molto piu veloce rispetto alla lista.&lt;br /&gt;
Con tuple si usano le parentesi tonde.&lt;br /&gt;
&lt;br /&gt;
== '''DIZIONARI''' ==&lt;br /&gt;
&lt;br /&gt;
il dizionario si definisce con le parentesi graffe {chiave:valore, chiave:valore}&lt;br /&gt;
a{chiave}&lt;br /&gt;
da il valore associato alla chiave.&lt;br /&gt;
&lt;br /&gt;
Dizionari liste e tuple sono dele sequenze e sono iterable e si possono scorrere.&lt;br /&gt;
&lt;br /&gt;
== '''If elif else''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
if condizione :&lt;br /&gt;
&lt;br /&gt;
indentato roba da fare se vero.&lt;br /&gt;
&lt;br /&gt;
Python supporta o tab o spazio, si decide quanti tab o spazi alla prima indentazione.&lt;br /&gt;
Meglio lo spazio perchè in futuro I tab verranno lasciati.&lt;br /&gt;
Di solito si usa 4 spazi.&lt;br /&gt;
Non c'è la graffa in pyton o I begin o gli end, si chiude e si apre la riga solo se si indenta.&lt;br /&gt;
&lt;br /&gt;
Esempio:&lt;br /&gt;
    ''a=3&lt;br /&gt;
    b=1''&lt;br /&gt;
&lt;br /&gt;
    ''if a &amp;gt;b:&lt;br /&gt;
      print (“ a è maggiore di b”)&lt;br /&gt;
    elif a==b:&lt;br /&gt;
      print (“ a è uguale a b”)&lt;br /&gt;
    else:&lt;br /&gt;
       print(“b è maggiore di a”)''&lt;br /&gt;
&lt;br /&gt;
in questo programma definisco due valori, a e b.&lt;br /&gt;
Chiedo al programma se aè maggiore di b di scrivere : a è maggiore di b, se a è uguale a b di scrivere che a è uguale a b e in tutte le altre condizioni (else) di scrivere che a è minore di b.&lt;br /&gt;
&lt;br /&gt;
	'''2.is, is not or, and,!='''&lt;br /&gt;
    ''if a is 1:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
    elif a is not 1:&lt;br /&gt;
      print (“no”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 and b is 3:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 or b is 3:&lt;br /&gt;
      print (“okkei”)&lt;br /&gt;
''&lt;br /&gt;
&lt;br /&gt;
'''!= è il diverso.'''&lt;br /&gt;
&lt;br /&gt;
== '''append, insert''' ==&lt;br /&gt;
&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a il 4.&lt;br /&gt;
Se faccio print (“a”)&lt;br /&gt;
mi da la lista degli oggetti più il 4.&lt;br /&gt;
&lt;br /&gt;
con '''insert''' devo inserire anche la posizione&lt;br /&gt;
    ''a.insert(2,34)''&lt;br /&gt;
mette il 34 in posizione 2&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''for''' ==&lt;br /&gt;
&lt;br /&gt;
specifica un ciclo, fa le cose tante volte fino ad una condizione.&lt;br /&gt;
For variabile in una sequenza di qualche tipo.&lt;br /&gt;
Es:     ''for elemento in a:&lt;br /&gt;
               print elemento''&lt;br /&gt;
&lt;br /&gt;
es b è una tupla.&lt;br /&gt;
Allora posso scrivere:&lt;br /&gt;
    ''for elem in b&lt;br /&gt;
         print “altro elemento”&lt;br /&gt;
         “print elem”''&lt;br /&gt;
&lt;br /&gt;
elem o qualsiasi altro nome gli dia è ogni elemento dentro la tupla o lista o dizionario.&lt;br /&gt;
&lt;br /&gt;
Se io voglio sia la chiave sia il valore in un dizionario (se metto elem mi mette solo la chiave) posso fare:&lt;br /&gt;
for chiave in a:&lt;br /&gt;
	    ''print “chiave: “ + chiave&lt;br /&gt;
	    print “valore: “ + a[chiave]''&lt;br /&gt;
&lt;br /&gt;
'''DOPO I DUE PUNTI METTO SEMPRE IL TAB.'''&lt;br /&gt;
&lt;br /&gt;
== '''xrange''' ==&lt;br /&gt;
&lt;br /&gt;
xrange è un iterable di dieci elementi con il primo valore uguale a 0 .E' una lista ma non ha le proprietà di una lista.&lt;br /&gt;
se io voglio fare un for da uno a dieci (cioè la somma da uno a 10)&lt;br /&gt;
&lt;br /&gt;
es:     ''for I xrange(10)&lt;br /&gt;
               print I''&lt;br /&gt;
lui stampa&lt;br /&gt;
''1&lt;br /&gt;
2&lt;br /&gt;
3&lt;br /&gt;
4&lt;br /&gt;
5&lt;br /&gt;
6&lt;br /&gt;
7&lt;br /&gt;
8&lt;br /&gt;
9&lt;br /&gt;
10''&lt;br /&gt;
&lt;br /&gt;
== '''range''' ==&lt;br /&gt;
&lt;br /&gt;
è una lista.se io scrivo:&lt;br /&gt;
    ''print range(10)''&lt;br /&gt;
lui mi da     ''[0,1,2,3,4,5,6,7,8,9].''&lt;br /&gt;
è più lento di xrange e poi sta morendo&lt;br /&gt;
&lt;br /&gt;
== '''len''' ==&lt;br /&gt;
&lt;br /&gt;
    ''len (a)''&lt;br /&gt;
da la lunghezza della stringa&lt;br /&gt;
&lt;br /&gt;
== '''enumerate''' ==&lt;br /&gt;
&lt;br /&gt;
se io ho una lista di tre elmenti&lt;br /&gt;
''a=[“ciao”,”bel”, “mondo”]''&lt;br /&gt;
&lt;br /&gt;
''for I, elem in enumerate(a):&lt;br /&gt;
     print str(I) + “:” + elem&lt;br /&gt;
''&lt;br /&gt;
da la posizione corrente di ogni elemento.&lt;br /&gt;
''0:ciao&lt;br /&gt;
1:bel&lt;br /&gt;
2:mondo''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''raw_input''' ==&lt;br /&gt;
&lt;br /&gt;
dai il valore.&lt;br /&gt;
''Base= raw_input (“inserisce la base:”)&lt;br /&gt;
esponente=raw_input (“inserisci l'/ esponente”)''&lt;br /&gt;
&lt;br /&gt;
ti chiede il valore di base ed esponente.&lt;br /&gt;
&lt;br /&gt;
== '''Int''' ==&lt;br /&gt;
&lt;br /&gt;
forza il fatto che quel valore sia un intero.&lt;br /&gt;
''&lt;br /&gt;
Es:base=int(base)&lt;br /&gt;
  result=int(result)''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''UPPER,LOWER,CAPITALIZE''' ==&lt;br /&gt;
&lt;br /&gt;
'''capitalize''' è un comando che sulla la stringa su cui viene applicato ,prende la prima lettera dopo gli spazi e ci mette la maiuscola&lt;br /&gt;
&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.capitalize()''&lt;br /&gt;
    ''Ciao mondo''&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.title()&lt;br /&gt;
    Ciao Mondo''&lt;br /&gt;
&lt;br /&gt;
'''LOWER:''' prende la striga e emette tutto minuscolo&lt;br /&gt;
'''UPPER:''' il contrario di lower&lt;br /&gt;
&lt;br /&gt;
== '''ESEMPIO DELLA SERATA:''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Calcolo di una potenza.&lt;br /&gt;
&lt;br /&gt;
    ''&lt;br /&gt;
    base= raw_input (“inserisce la base:”)&lt;br /&gt;
    esponente=raw_input (“inserisci l\' esponente”)&lt;br /&gt;
&lt;br /&gt;
    base=int(base)&lt;br /&gt;
    result=int(result)&lt;br /&gt;
&lt;br /&gt;
    result=1&lt;br /&gt;
    for i in xrange(esponente):&lt;br /&gt;
         result = result * base&lt;br /&gt;
    print result''&lt;br /&gt;
&lt;br /&gt;
il [http://docs.python.org/lib/built-in-funcs.html built-in] int() è necessario, dato che tutto quello che proviene dalla tastiera viene acquisito da raw_input() come stringa. Dato che dobbiamo usarli come interi, occorre effettuare un cast, ovvero&lt;br /&gt;
una trasformazione di tipo, da stringa a intero.&lt;br /&gt;
E' interessante notare che int() non cerca di fare i miracoli: provate a vedere cosa succede se cercate di convertire &amp;quot;awlerorj&amp;quot; in int!&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3730</id>
		<title>Python Lezione 4 Giugno 2008</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3730"/>
		<updated>2008-06-06T08:28:25Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: /* LE STRINGHE */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Python ==&lt;br /&gt;
[http://www.python.it/ Python] è un linguaggio di programmazione [http://it.wikipedia.org/wiki/Interprete_(informatica) interpretato].&lt;br /&gt;
Il linuaggio interpretato è simile agli altri linguaggi in circolazione ma, invece di essere trasformato direttamente in codice binario dal meccanismo automatico, viene interpretato da questo e poi mandato all'hardware.&lt;br /&gt;
Un linguaggio interpretato non ha bisogno di essere ricompilato: il codice scritto viene interpretato da un interprete a run-time (tempo di esecuzione) e tradotto al volo nel linguaggio macchina.&lt;br /&gt;
Quindi i programmi python possono girare su qualsiasi hardware e sistema operativo su cui è stato portato l'interprete. Ovviamente, questa cosa si paga sul tempo di esecuzione pure: l'approccio ha si i suoi vantaggi, ma rispetto a un linguaggio compilato direttamente in linguaggio macchina per creare un eseguibile, python e gli altri liguaggi interpretati risultano essere più lenti.&lt;br /&gt;
&lt;br /&gt;
Esistono vari interpreti: [http://www.python.org Cpython], o classic python, è l'interprete &amp;quot;ufficiale&amp;quot;, scritto in C e disponibile per linux, mac e windows.&lt;br /&gt;
[http://www.jython.org/Project/ Jython] è un interprete scritto al 100% in Java, e si interfaccia strettamente ai programmi e alla libreria Java, &lt;br /&gt;
[http://www.codeplex.com/Wiki/View.aspx?ProjectName=IronPython IronPython] è un interprete python che gira sulla piattaforma .NET mentre &lt;br /&gt;
[http://codespeak.net/pypy/dist/pypy/doc/home.html PyPy] è (anche) un interprete python scritto in.. python&lt;br /&gt;
&lt;br /&gt;
La prima riga di ogni script python deve iniziare con #!/usr/bin/env python&lt;br /&gt;
&lt;br /&gt;
il #! del file fa capire al sistema operativo (solo su sistemi posix, quindi unix/linux) che quello non è un file di testo ma un eseguibile da eseguire con l'inteprete python.&lt;br /&gt;
&lt;br /&gt;
== COMMENTI ==&lt;br /&gt;
&lt;br /&gt;
: sono righe che l'interprete salta e non legge &lt;br /&gt;
es: &lt;br /&gt;
    ''# stampa:”hello word”''&lt;br /&gt;
&lt;br /&gt;
== PRINT ==&lt;br /&gt;
Lo statement [http://docs.python.org/ref/print.html print] valuta tutte le espressioni presenti e quindi le stampa a video.&lt;br /&gt;
L'espressione da valutare può essere anche un semplice numero o una semplice stringa&lt;br /&gt;
&lt;br /&gt;
    ''print 3''&lt;br /&gt;
stampa 3, e anche se scrivo&lt;br /&gt;
    '' print “3”''&lt;br /&gt;
stampa lo stesso anche se abbiamo passato prima un intero, poi una stringa.&lt;br /&gt;
Questo è normale, perchè il numero &amp;quot;tre&amp;quot; viene rappresentato dal simbolo 3 nel sistema decimale.&lt;br /&gt;
&lt;br /&gt;
Invece, se scrivo&lt;br /&gt;
    ''print 3+2''&lt;br /&gt;
otteniamo a video 5: l'inteprete ha valutato l'espressione, ha eseguito la somma e stampato il situlato.&lt;br /&gt;
Mentre se scriviamo&lt;br /&gt;
    ''print “3+2”''&lt;br /&gt;
il risolutato è &lt;br /&gt;
    ''3+2''&lt;br /&gt;
in quanto abbiamo passato la stringa composta dal carattere 3, dal simbolo + e dal carattere 2.&lt;br /&gt;
&lt;br /&gt;
Le variabili in python non devono essere dichiarate: esistono dalla prima volta in cui gli viene assegnato un valore&lt;br /&gt;
    ''messaggio=”hello world”''&lt;br /&gt;
    ''print messaggio''&lt;br /&gt;
se questo programma viene eseguito il risultatato sarà:&lt;br /&gt;
''hello world''&lt;br /&gt;
l'interprete valuta l'espressione ''messaggio'' e stampa il suo contenuto&lt;br /&gt;
&lt;br /&gt;
== ECCEZIONE ==&lt;br /&gt;
:se io commento la definizione di messaggio (es: ''# messaggio = &amp;quot; hello world &amp;quot;'' ) il programma non sa cos'è messaggio e se scrivo:&lt;br /&gt;
    ''print &amp;quot;messaggio&amp;quot;''&lt;br /&gt;
il risultato sarà:name error, che, viene chiamato eccezione.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== LE STRINGHE ==&lt;br /&gt;
Gli oggetti di tipo stringa supportano svariati metodi e proprietà. E' da notare che le stringhe sono immutabili.&lt;br /&gt;
Se una stringa viene dichiarata la seconda volta, quella precedente viene buttata, non viene modificata per fare spazio alla nuova.&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
    messaggio=”ciao mondo”&lt;br /&gt;
    print “messaggio”''&lt;br /&gt;
stampa&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
In Python non si possono sommare cose diverse, o meglio, lo posso fare solo se è definita una conversione tra i due tipo.&lt;br /&gt;
Le stringhe supportano anche alcuni operatori base:&lt;br /&gt;
    ''print messaggio*2'' &lt;br /&gt;
l'esecuzione darà&lt;br /&gt;
    ''messaggio messaggio&lt;br /&gt;
''&lt;br /&gt;
esempio:&lt;br /&gt;
     ''Print “ciao”+” mondo”''&lt;br /&gt;
lo eseguo e mi darà:&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
== '''Funzione DIR''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
    dir(messaggio)''&lt;br /&gt;
a questo punto il programma da una serie di caratteri incomprensibili.&lt;br /&gt;
Praticamente dà i '''metodi''' che suporta la stringa messaggio.&lt;br /&gt;
&lt;br /&gt;
== I '''metodi''' ==&lt;br /&gt;
 sono operazioni che si possono applicare alla stringa.&lt;br /&gt;
quelli che iniziano con '''__'''spesso vengono usati per scoraggiare la gente ad usarli,in quanto qui non esistono i permessi e ognuno può modificare ciò che vuole.&lt;br /&gt;
&lt;br /&gt;
Quando il metodo inizia con '''AD''' richiama l'operatore dell'addizione&lt;br /&gt;
&lt;br /&gt;
'''__ doc__''' ce l'hanno tutti gli oggetti (stringhe, interi...)&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
metodo '''IS''':&lt;br /&gt;
tutti I metodi che iniziano per is danno come risultato o vero o falso.&lt;br /&gt;
es: &lt;br /&gt;
    ''messaggio.isalpha()''&lt;br /&gt;
mi dice se messaggio è o meno alfanumerico.&lt;br /&gt;
isalpha è un oggetto quindi ha le proprietà doc .&lt;br /&gt;
se io scrivo&lt;br /&gt;
    ''messaggio.isalpa.__doc__''&lt;br /&gt;
mi dice che fa.&lt;br /&gt;
&lt;br /&gt;
Importante metto tra “ solo se è una stringa.&lt;br /&gt;
Se io definisco un oggetto con un altro oggetto con una funzione non metto “.&lt;br /&gt;
es:&lt;br /&gt;
    '' messaggio=”gigio”&lt;br /&gt;
    messaggio2= messaggio.upper()''&lt;br /&gt;
&lt;br /&gt;
es:&lt;br /&gt;
''TYPE(3)''&lt;br /&gt;
mi dice che variabile  è.se è intero o stringa.&lt;br /&gt;
Se io scrivo ''DIR(3)''&lt;br /&gt;
mi da lo stesso pappie di roba di prima.&lt;br /&gt;
'''&lt;br /&gt;
I TIPI DELLA LIBREARIA STANDARD''':sono le variabili, ci sono anche le LISTE&lt;br /&gt;
&lt;br /&gt;
Esistono stringhe, interi, float (numeri con virgola)buleano (che ha due valori, vero o falso, True e false)e i  CONTENITORI:&lt;br /&gt;
&lt;br /&gt;
== '''LE LISTE''' ==&lt;br /&gt;
&lt;br /&gt;
es. lo scaffale ha I pc, I pc sono oggetti (pc1,pc2...).Se voglio uno scaffale di pc senza dare I nomi a tutti gli oggetti, definisco lo scaffale.&lt;br /&gt;
Lo scaffale si chiama''' Lista'''  .si usano le parentesi quadre con oggetti separati da virgola&lt;br /&gt;
es.    '' a = [ “pc1” , “schermo rotto” , 2]&lt;br /&gt;
dir (scaffale)''&lt;br /&gt;
da la lista dei metodi, da qui si capisce che la lista è un oggetto.&lt;br /&gt;
Se io faccio&lt;br /&gt;
    ''b = dir (a)''&lt;br /&gt;
o&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a il 4.&lt;br /&gt;
'''la lista MUTA!'''&lt;br /&gt;
Se faccio     ''print (“a”)''&lt;br /&gt;
mi da la lista degli oggetti più il 4.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''TUPLE''' ==&lt;br /&gt;
&lt;br /&gt;
è una lista non mutabile.&lt;br /&gt;
La tupla è molto piu veloce rispetto alla lista.&lt;br /&gt;
Con tuple si usano le parentesi tonde.&lt;br /&gt;
&lt;br /&gt;
== '''DIZIONARI''' ==&lt;br /&gt;
&lt;br /&gt;
il dizionario si definisce con le parentesi graffe {chiave:valore, chiave:valore}&lt;br /&gt;
a{chiave}&lt;br /&gt;
da il valore associato alla chiave.&lt;br /&gt;
&lt;br /&gt;
Dizionari liste e tuple sono dele sequenze e sono iterable e si possono scorrere.&lt;br /&gt;
&lt;br /&gt;
== '''If elif else''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
if condizione :&lt;br /&gt;
&lt;br /&gt;
indentato roba da fare se vero.&lt;br /&gt;
&lt;br /&gt;
Python supporta o tab o spazio, si decide quanti tab o spazi alla prima indentazione.&lt;br /&gt;
Meglio lo spazio perchè in futuro I tab verranno lasciati.&lt;br /&gt;
Di solito si usa 4 spazi.&lt;br /&gt;
Non c'è la graffa in pyton o I begin o gli end, si chiude e si apre la riga solo se si indenta.&lt;br /&gt;
&lt;br /&gt;
Esempio:&lt;br /&gt;
    ''a=3&lt;br /&gt;
    b=1''&lt;br /&gt;
&lt;br /&gt;
    ''if a &amp;gt;b:&lt;br /&gt;
      print (“ a è maggiore di b”)&lt;br /&gt;
    elif a==b:&lt;br /&gt;
      print (“ a è uguale a b”)&lt;br /&gt;
    else:&lt;br /&gt;
       print(“b è maggiore di a”)''&lt;br /&gt;
&lt;br /&gt;
in questo programma definisco due valori, a e b.&lt;br /&gt;
Chiedo al programma se aè maggiore di b di scrivere : a è maggiore di b, se a è uguale a b di scrivere che a è uguale a b e in tutte le altre condizioni (else) di scrivere che a è minore di b.&lt;br /&gt;
&lt;br /&gt;
	'''2.is, is not or, and,!='''&lt;br /&gt;
    ''if a is 1:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
    elif a is not 1:&lt;br /&gt;
      print (“no”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 and b is 3:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 or b is 3:&lt;br /&gt;
      print (“okkei”)&lt;br /&gt;
''&lt;br /&gt;
&lt;br /&gt;
'''!= è il diverso.'''&lt;br /&gt;
&lt;br /&gt;
== '''append, insert''' ==&lt;br /&gt;
&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a il 4.&lt;br /&gt;
Se faccio print (“a”)&lt;br /&gt;
mi da la lista degli oggetti più il 4.&lt;br /&gt;
&lt;br /&gt;
con '''insert''' devo inserire anche la posizione&lt;br /&gt;
    ''a.insert(2,34)''&lt;br /&gt;
mette il 34 in posizione 2&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''for''' ==&lt;br /&gt;
&lt;br /&gt;
specifica un ciclo, fa le cose tante volte fino ad una condizione.&lt;br /&gt;
For variabile in una sequenza di qualche tipo.&lt;br /&gt;
Es:     ''for elemento in a:&lt;br /&gt;
               print elemento''&lt;br /&gt;
&lt;br /&gt;
es b è una tupla.&lt;br /&gt;
Allora posso scrivere:&lt;br /&gt;
    ''for elem in b&lt;br /&gt;
         print “altro elemento”&lt;br /&gt;
         “print elem”''&lt;br /&gt;
&lt;br /&gt;
elem o qualsiasi altro nome gli dia è ogni elemento dentro la tupla o lista o dizionario.&lt;br /&gt;
&lt;br /&gt;
Se io voglio sia la chiave sia il valore in un dizionario (se metto elem mi mette solo la chiave) posso fare:&lt;br /&gt;
for chiave in a:&lt;br /&gt;
	    ''print “chiave: “ + chiave&lt;br /&gt;
	    print “valore: “ + a[chiave]''&lt;br /&gt;
&lt;br /&gt;
'''DOPO I DUE PUNTI METTO SEMPRE IL TAB.'''&lt;br /&gt;
&lt;br /&gt;
== '''xrange''' ==&lt;br /&gt;
&lt;br /&gt;
xrange è un iterable di dieci elementi con il primo valore uguale a 0 .E' una lista ma non ha le proprietà di una lista.&lt;br /&gt;
se io voglio fare un for da uno a dieci (cioè la somma da uno a 10)&lt;br /&gt;
&lt;br /&gt;
es:     ''for I xrange(10)&lt;br /&gt;
               print I''&lt;br /&gt;
lui stampa&lt;br /&gt;
''1&lt;br /&gt;
2&lt;br /&gt;
3&lt;br /&gt;
4&lt;br /&gt;
5&lt;br /&gt;
6&lt;br /&gt;
7&lt;br /&gt;
8&lt;br /&gt;
9&lt;br /&gt;
10''&lt;br /&gt;
&lt;br /&gt;
== '''range''' ==&lt;br /&gt;
&lt;br /&gt;
è una lista.se io scrivo:&lt;br /&gt;
    ''print range(10)''&lt;br /&gt;
lui mi da     ''[0,1,2,3,4,5,6,7,8,9].''&lt;br /&gt;
è più lento di xrange e poi sta morendo&lt;br /&gt;
&lt;br /&gt;
== '''len''' ==&lt;br /&gt;
&lt;br /&gt;
    ''len (a)''&lt;br /&gt;
da la lunghezza della stringa&lt;br /&gt;
&lt;br /&gt;
== '''enumerate''' ==&lt;br /&gt;
&lt;br /&gt;
se io ho una lista di tre elmenti&lt;br /&gt;
''a=[“ciao”,”bel”, “mondo”]''&lt;br /&gt;
&lt;br /&gt;
''for I, elem in enumerate(a):&lt;br /&gt;
     print str(I) + “:” + elem&lt;br /&gt;
''&lt;br /&gt;
da la posizione corrente di ogni elemento.&lt;br /&gt;
''0:ciao&lt;br /&gt;
1:bel&lt;br /&gt;
2:mondo''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''raw_input''' ==&lt;br /&gt;
&lt;br /&gt;
dai il valore.&lt;br /&gt;
''Base= raw_input (“inserisce la base:”)&lt;br /&gt;
esponente=raw_input (“inserisci l'/ esponente”)''&lt;br /&gt;
&lt;br /&gt;
ti chiede il valore di base ed esponente.&lt;br /&gt;
&lt;br /&gt;
== '''Int''' ==&lt;br /&gt;
&lt;br /&gt;
forza il fatto che quel valore sia un intero.&lt;br /&gt;
''&lt;br /&gt;
Es:base=int(base)&lt;br /&gt;
  result=int(result)''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''UPPER,LOWER,CAPITALIZE''' ==&lt;br /&gt;
&lt;br /&gt;
'''capitalize''' è un comando che sulla la stringa su cui viene applicato ,prende la prima lettera dopo gli spazi e ci mette la maiuscola&lt;br /&gt;
&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.capitalize()''&lt;br /&gt;
    ''Ciao mondo''&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.title()&lt;br /&gt;
    Ciao Mondo''&lt;br /&gt;
&lt;br /&gt;
'''LOWER:''' prende la striga e emette tutto minuscolo&lt;br /&gt;
'''UPPER:''' il contrario di lower&lt;br /&gt;
&lt;br /&gt;
== '''ESEMPIO DELLA SERATA:''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Calcolo di una potenza.&lt;br /&gt;
&lt;br /&gt;
    ''&lt;br /&gt;
    base= raw_input (“inserisce la base:”)&lt;br /&gt;
    esponente=raw_input (“inserisci l\' esponente”)&lt;br /&gt;
&lt;br /&gt;
    base=int(base)&lt;br /&gt;
    result=int(result)&lt;br /&gt;
&lt;br /&gt;
    result=1&lt;br /&gt;
    for i in xrange(esponente):&lt;br /&gt;
         result = result * base&lt;br /&gt;
    print result''&lt;br /&gt;
&lt;br /&gt;
il [http://docs.python.org/lib/built-in-funcs.html built-in] int() è necessario, dato che tutto quello che proviene dalla tastiera viene acquisito da raw_input() come stringa. Dato che dobbiamo usarli come interi, occorre effettuare un cast, ovvero&lt;br /&gt;
una trasformazione di tipo, da stringa a intero.&lt;br /&gt;
E' interessante notare che int() non cerca di fare i miracoli: provate a vedere cosa succede se cercate di convertire &amp;quot;awlerorj&amp;quot; in int!&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3729</id>
		<title>Python Lezione 4 Giugno 2008</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3729"/>
		<updated>2008-06-06T08:19:31Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: /* PRINT */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Python ==&lt;br /&gt;
[http://www.python.it/ Python] è un linguaggio di programmazione [http://it.wikipedia.org/wiki/Interprete_(informatica) interpretato].&lt;br /&gt;
Il linuaggio interpretato è simile agli altri linguaggi in circolazione ma, invece di essere trasformato direttamente in codice binario dal meccanismo automatico, viene interpretato da questo e poi mandato all'hardware.&lt;br /&gt;
Un linguaggio interpretato non ha bisogno di essere ricompilato: il codice scritto viene interpretato da un interprete a run-time (tempo di esecuzione) e tradotto al volo nel linguaggio macchina.&lt;br /&gt;
Quindi i programmi python possono girare su qualsiasi hardware e sistema operativo su cui è stato portato l'interprete. Ovviamente, questa cosa si paga sul tempo di esecuzione pure: l'approccio ha si i suoi vantaggi, ma rispetto a un linguaggio compilato direttamente in linguaggio macchina per creare un eseguibile, python e gli altri liguaggi interpretati risultano essere più lenti.&lt;br /&gt;
&lt;br /&gt;
Esistono vari interpreti: [http://www.python.org Cpython], o classic python, è l'interprete &amp;quot;ufficiale&amp;quot;, scritto in C e disponibile per linux, mac e windows.&lt;br /&gt;
[http://www.jython.org/Project/ Jython] è un interprete scritto al 100% in Java, e si interfaccia strettamente ai programmi e alla libreria Java, &lt;br /&gt;
[http://www.codeplex.com/Wiki/View.aspx?ProjectName=IronPython IronPython] è un interprete python che gira sulla piattaforma .NET mentre &lt;br /&gt;
[http://codespeak.net/pypy/dist/pypy/doc/home.html PyPy] è (anche) un interprete python scritto in.. python&lt;br /&gt;
&lt;br /&gt;
La prima riga di ogni script python deve iniziare con #!/usr/bin/env python&lt;br /&gt;
&lt;br /&gt;
il #! del file fa capire al sistema operativo (solo su sistemi posix, quindi unix/linux) che quello non è un file di testo ma un eseguibile da eseguire con l'inteprete python.&lt;br /&gt;
&lt;br /&gt;
== COMMENTI ==&lt;br /&gt;
&lt;br /&gt;
: sono righe che l'interprete salta e non legge &lt;br /&gt;
es: &lt;br /&gt;
    ''# stampa:”hello word”''&lt;br /&gt;
&lt;br /&gt;
== PRINT ==&lt;br /&gt;
Lo statement [http://docs.python.org/ref/print.html print] valuta tutte le espressioni presenti e quindi le stampa a video.&lt;br /&gt;
L'espressione da valutare può essere anche un semplice numero o una semplice stringa&lt;br /&gt;
&lt;br /&gt;
    ''print 3''&lt;br /&gt;
stampa 3, e anche se scrivo&lt;br /&gt;
    '' print “3”''&lt;br /&gt;
stampa lo stesso anche se abbiamo passato prima un intero, poi una stringa.&lt;br /&gt;
Questo è normale, perchè il numero &amp;quot;tre&amp;quot; viene rappresentato dal simbolo 3 nel sistema decimale.&lt;br /&gt;
&lt;br /&gt;
Invece, se scrivo&lt;br /&gt;
    ''print 3+2''&lt;br /&gt;
otteniamo a video 5: l'inteprete ha valutato l'espressione, ha eseguito la somma e stampato il situlato.&lt;br /&gt;
Mentre se scriviamo&lt;br /&gt;
    ''print “3+2”''&lt;br /&gt;
il risolutato è &lt;br /&gt;
    ''3+2''&lt;br /&gt;
in quanto abbiamo passato la stringa composta dal carattere 3, dal simbolo + e dal carattere 2.&lt;br /&gt;
&lt;br /&gt;
Le variabili in python non devono essere dichiarate: esistono dalla prima volta in cui gli viene assegnato un valore&lt;br /&gt;
    ''messaggio=”hello world”''&lt;br /&gt;
    ''print messaggio''&lt;br /&gt;
se questo programma viene eseguito il risultatato sarà:&lt;br /&gt;
''hello world''&lt;br /&gt;
l'interprete valuta l'espressione ''messaggio'' e stampa il suo contenuto&lt;br /&gt;
&lt;br /&gt;
== ECCEZIONE ==&lt;br /&gt;
:se io commento la definizione di messaggio (es: ''# messaggio = &amp;quot; hello world &amp;quot;'' ) il programma non sa cos'è messaggio e se scrivo:&lt;br /&gt;
    ''print &amp;quot;messaggio&amp;quot;''&lt;br /&gt;
il risultato sarà:name error, che, viene chiamato eccezione.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== LE STRINGHE ==&lt;br /&gt;
supportano molti metodi perchè sono oggetti (che è un altro nome per variabile).le stringhe sono immutabili.&lt;br /&gt;
Se una stringa viene dichiarata la seconda volta, diversamente dalla prima, quella precedente viene buttata.&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
     messaggio=”ciao mondo”&lt;br /&gt;
    print “messaggio”''&lt;br /&gt;
lui scrive&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
In Python non si possono sommare cose diverse, o meglio, lo posso fare ma mi converte il numero in stringa.per esempio &lt;br /&gt;
    ''print messaggio*2'' &lt;br /&gt;
l'esecuzione darà&lt;br /&gt;
    ''messaggio messaggio&lt;br /&gt;
''&lt;br /&gt;
esempio:&lt;br /&gt;
     ''Print “ciao”+”mondo”''&lt;br /&gt;
lo eseguo e mi darà:&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
Se si scrive python da riga di comando parte l'interprete se scriviamo roba lui l'esegue e si usa per provare le cose.per uscire premere ctrl+d.&lt;br /&gt;
&lt;br /&gt;
LE STRINGHE SONO IMMUTABILI.&lt;br /&gt;
&lt;br /&gt;
== '''Funzione DIR''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
    dir(messaggio)''&lt;br /&gt;
a questo punto il programma da una serie di caratteri incomprensibili.&lt;br /&gt;
Praticamente dà i '''metodi''' che suporta la stringa messaggio.&lt;br /&gt;
&lt;br /&gt;
== I '''metodi''' ==&lt;br /&gt;
 sono operazioni che si possono applicare alla stringa.&lt;br /&gt;
quelli che iniziano con '''__'''spesso vengono usati per scoraggiare la gente ad usarli,in quanto qui non esistono i permessi e ognuno può modificare ciò che vuole.&lt;br /&gt;
&lt;br /&gt;
Quando il metodo inizia con '''AD''' richiama l'operatore dell'addizione&lt;br /&gt;
&lt;br /&gt;
'''__ doc__''' ce l'hanno tutti gli oggetti (stringhe, interi...)&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
metodo '''IS''':&lt;br /&gt;
tutti I metodi che iniziano per is danno come risultato o vero o falso.&lt;br /&gt;
es: &lt;br /&gt;
    ''messaggio.isalpha()''&lt;br /&gt;
mi dice se messaggio è o meno alfanumerico.&lt;br /&gt;
isalpha è un oggetto quindi ha le proprietà doc .&lt;br /&gt;
se io scrivo&lt;br /&gt;
    ''messaggio.isalpa.__doc__''&lt;br /&gt;
mi dice che fa.&lt;br /&gt;
&lt;br /&gt;
Importante metto tra “ solo se è una stringa.&lt;br /&gt;
Se io definisco un oggetto con un altro oggetto con una funzione non metto “.&lt;br /&gt;
es:&lt;br /&gt;
    '' messaggio=”gigio”&lt;br /&gt;
    messaggio2= messaggio.upper()''&lt;br /&gt;
&lt;br /&gt;
es:&lt;br /&gt;
''TYPE(3)''&lt;br /&gt;
mi dice che variabile  è.se è intero o stringa.&lt;br /&gt;
Se io scrivo ''DIR(3)''&lt;br /&gt;
mi da lo stesso pappie di roba di prima.&lt;br /&gt;
'''&lt;br /&gt;
I TIPI DELLA LIBREARIA STANDARD''':sono le variabili, ci sono anche le LISTE&lt;br /&gt;
&lt;br /&gt;
Esistono stringhe, interi, float (numeri con virgola)buleano (che ha due valori, vero o falso, True e false)e i  CONTENITORI:&lt;br /&gt;
&lt;br /&gt;
== '''LE LISTE''' ==&lt;br /&gt;
&lt;br /&gt;
es. lo scaffale ha I pc, I pc sono oggetti (pc1,pc2...).Se voglio uno scaffale di pc senza dare I nomi a tutti gli oggetti, definisco lo scaffale.&lt;br /&gt;
Lo scaffale si chiama''' Lista'''  .si usano le parentesi quadre con oggetti separati da virgola&lt;br /&gt;
es.    '' a = [ “pc1” , “schermo rotto” , 2]&lt;br /&gt;
dir (scaffale)''&lt;br /&gt;
da la lista dei metodi, da qui si capisce che la lista è un oggetto.&lt;br /&gt;
Se io faccio&lt;br /&gt;
    ''b = dir (a)''&lt;br /&gt;
o&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a il 4.&lt;br /&gt;
'''la lista MUTA!'''&lt;br /&gt;
Se faccio     ''print (“a”)''&lt;br /&gt;
mi da la lista degli oggetti più il 4.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''TUPLE''' ==&lt;br /&gt;
&lt;br /&gt;
è una lista non mutabile.&lt;br /&gt;
La tupla è molto piu veloce rispetto alla lista.&lt;br /&gt;
Con tuple si usano le parentesi tonde.&lt;br /&gt;
&lt;br /&gt;
== '''DIZIONARI''' ==&lt;br /&gt;
&lt;br /&gt;
il dizionario si definisce con le parentesi graffe {chiave:valore, chiave:valore}&lt;br /&gt;
a{chiave}&lt;br /&gt;
da il valore associato alla chiave.&lt;br /&gt;
&lt;br /&gt;
Dizionari liste e tuple sono dele sequenze e sono iterable e si possono scorrere.&lt;br /&gt;
&lt;br /&gt;
== '''If elif else''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
if condizione :&lt;br /&gt;
&lt;br /&gt;
indentato roba da fare se vero.&lt;br /&gt;
&lt;br /&gt;
Python supporta o tab o spazio, si decide quanti tab o spazi alla prima indentazione.&lt;br /&gt;
Meglio lo spazio perchè in futuro I tab verranno lasciati.&lt;br /&gt;
Di solito si usa 4 spazi.&lt;br /&gt;
Non c'è la graffa in pyton o I begin o gli end, si chiude e si apre la riga solo se si indenta.&lt;br /&gt;
&lt;br /&gt;
Esempio:&lt;br /&gt;
    ''a=3&lt;br /&gt;
    b=1''&lt;br /&gt;
&lt;br /&gt;
    ''if a &amp;gt;b:&lt;br /&gt;
      print (“ a è maggiore di b”)&lt;br /&gt;
    elif a==b:&lt;br /&gt;
      print (“ a è uguale a b”)&lt;br /&gt;
    else:&lt;br /&gt;
       print(“b è maggiore di a”)''&lt;br /&gt;
&lt;br /&gt;
in questo programma definisco due valori, a e b.&lt;br /&gt;
Chiedo al programma se aè maggiore di b di scrivere : a è maggiore di b, se a è uguale a b di scrivere che a è uguale a b e in tutte le altre condizioni (else) di scrivere che a è minore di b.&lt;br /&gt;
&lt;br /&gt;
	'''2.is, is not or, and,!='''&lt;br /&gt;
    ''if a is 1:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
    elif a is not 1:&lt;br /&gt;
      print (“no”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 and b is 3:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 or b is 3:&lt;br /&gt;
      print (“okkei”)&lt;br /&gt;
''&lt;br /&gt;
&lt;br /&gt;
'''!= è il diverso.'''&lt;br /&gt;
&lt;br /&gt;
== '''append, insert''' ==&lt;br /&gt;
&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a il 4.&lt;br /&gt;
Se faccio print (“a”)&lt;br /&gt;
mi da la lista degli oggetti più il 4.&lt;br /&gt;
&lt;br /&gt;
con '''insert''' devo inserire anche la posizione&lt;br /&gt;
    ''a.insert(2,34)''&lt;br /&gt;
mette il 34 in posizione 2&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''for''' ==&lt;br /&gt;
&lt;br /&gt;
specifica un ciclo, fa le cose tante volte fino ad una condizione.&lt;br /&gt;
For variabile in una sequenza di qualche tipo.&lt;br /&gt;
Es:     ''for elemento in a:&lt;br /&gt;
               print elemento''&lt;br /&gt;
&lt;br /&gt;
es b è una tupla.&lt;br /&gt;
Allora posso scrivere:&lt;br /&gt;
    ''for elem in b&lt;br /&gt;
         print “altro elemento”&lt;br /&gt;
         “print elem”''&lt;br /&gt;
&lt;br /&gt;
elem o qualsiasi altro nome gli dia è ogni elemento dentro la tupla o lista o dizionario.&lt;br /&gt;
&lt;br /&gt;
Se io voglio sia la chiave sia il valore in un dizionario (se metto elem mi mette solo la chiave) posso fare:&lt;br /&gt;
for chiave in a:&lt;br /&gt;
	    ''print “chiave: “ + chiave&lt;br /&gt;
	    print “valore: “ + a[chiave]''&lt;br /&gt;
&lt;br /&gt;
'''DOPO I DUE PUNTI METTO SEMPRE IL TAB.'''&lt;br /&gt;
&lt;br /&gt;
== '''xrange''' ==&lt;br /&gt;
&lt;br /&gt;
xrange è un iterable di dieci elementi con il primo valore uguale a 0 .E' una lista ma non ha le proprietà di una lista.&lt;br /&gt;
se io voglio fare un for da uno a dieci (cioè la somma da uno a 10)&lt;br /&gt;
&lt;br /&gt;
es:     ''for I xrange(10)&lt;br /&gt;
               print I''&lt;br /&gt;
lui stampa&lt;br /&gt;
''1&lt;br /&gt;
2&lt;br /&gt;
3&lt;br /&gt;
4&lt;br /&gt;
5&lt;br /&gt;
6&lt;br /&gt;
7&lt;br /&gt;
8&lt;br /&gt;
9&lt;br /&gt;
10''&lt;br /&gt;
&lt;br /&gt;
== '''range''' ==&lt;br /&gt;
&lt;br /&gt;
è una lista.se io scrivo:&lt;br /&gt;
    ''print range(10)''&lt;br /&gt;
lui mi da     ''[0,1,2,3,4,5,6,7,8,9].''&lt;br /&gt;
è più lento di xrange e poi sta morendo&lt;br /&gt;
&lt;br /&gt;
== '''len''' ==&lt;br /&gt;
&lt;br /&gt;
    ''len (a)''&lt;br /&gt;
da la lunghezza della stringa&lt;br /&gt;
&lt;br /&gt;
== '''enumerate''' ==&lt;br /&gt;
&lt;br /&gt;
se io ho una lista di tre elmenti&lt;br /&gt;
''a=[“ciao”,”bel”, “mondo”]''&lt;br /&gt;
&lt;br /&gt;
''for I, elem in enumerate(a):&lt;br /&gt;
     print str(I) + “:” + elem&lt;br /&gt;
''&lt;br /&gt;
da la posizione corrente di ogni elemento.&lt;br /&gt;
''0:ciao&lt;br /&gt;
1:bel&lt;br /&gt;
2:mondo''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''raw_input''' ==&lt;br /&gt;
&lt;br /&gt;
dai il valore.&lt;br /&gt;
''Base= raw_input (“inserisce la base:”)&lt;br /&gt;
esponente=raw_input (“inserisci l'/ esponente”)''&lt;br /&gt;
&lt;br /&gt;
ti chiede il valore di base ed esponente.&lt;br /&gt;
&lt;br /&gt;
== '''Int''' ==&lt;br /&gt;
&lt;br /&gt;
forza il fatto che quel valore sia un intero.&lt;br /&gt;
''&lt;br /&gt;
Es:base=int(base)&lt;br /&gt;
  result=int(result)''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''UPPER,LOWER,CAPITALIZE''' ==&lt;br /&gt;
&lt;br /&gt;
'''capitalize''' è un comando che sulla la stringa su cui viene applicato ,prende la prima lettera dopo gli spazi e ci mette la maiuscola&lt;br /&gt;
&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.capitalize()''&lt;br /&gt;
    ''Ciao mondo''&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.title()&lt;br /&gt;
    Ciao Mondo''&lt;br /&gt;
&lt;br /&gt;
'''LOWER:''' prende la striga e emette tutto minuscolo&lt;br /&gt;
'''UPPER:''' il contrario di lower&lt;br /&gt;
&lt;br /&gt;
== '''ESEMPIO DELLA SERATA:''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Calcolo di una potenza.&lt;br /&gt;
&lt;br /&gt;
    ''&lt;br /&gt;
    base= raw_input (“inserisce la base:”)&lt;br /&gt;
    esponente=raw_input (“inserisci l\' esponente”)&lt;br /&gt;
&lt;br /&gt;
    base=int(base)&lt;br /&gt;
    result=int(result)&lt;br /&gt;
&lt;br /&gt;
    result=1&lt;br /&gt;
    for i in xrange(esponente):&lt;br /&gt;
         result = result * base&lt;br /&gt;
    print result''&lt;br /&gt;
&lt;br /&gt;
il [http://docs.python.org/lib/built-in-funcs.html built-in] int() è necessario, dato che tutto quello che proviene dalla tastiera viene acquisito da raw_input() come stringa. Dato che dobbiamo usarli come interi, occorre effettuare un cast, ovvero&lt;br /&gt;
una trasformazione di tipo, da stringa a intero.&lt;br /&gt;
E' interessante notare che int() non cerca di fare i miracoli: provate a vedere cosa succede se cercate di convertire &amp;quot;awlerorj&amp;quot; in int!&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3728</id>
		<title>Python Lezione 4 Giugno 2008</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3728"/>
		<updated>2008-06-06T08:13:12Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: /* Python */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Python ==&lt;br /&gt;
[http://www.python.it/ Python] è un linguaggio di programmazione [http://it.wikipedia.org/wiki/Interprete_(informatica) interpretato].&lt;br /&gt;
Il linuaggio interpretato è simile agli altri linguaggi in circolazione ma, invece di essere trasformato direttamente in codice binario dal meccanismo automatico, viene interpretato da questo e poi mandato all'hardware.&lt;br /&gt;
Un linguaggio interpretato non ha bisogno di essere ricompilato: il codice scritto viene interpretato da un interprete a run-time (tempo di esecuzione) e tradotto al volo nel linguaggio macchina.&lt;br /&gt;
Quindi i programmi python possono girare su qualsiasi hardware e sistema operativo su cui è stato portato l'interprete. Ovviamente, questa cosa si paga sul tempo di esecuzione pure: l'approccio ha si i suoi vantaggi, ma rispetto a un linguaggio compilato direttamente in linguaggio macchina per creare un eseguibile, python e gli altri liguaggi interpretati risultano essere più lenti.&lt;br /&gt;
&lt;br /&gt;
Esistono vari interpreti: [http://www.python.org Cpython], o classic python, è l'interprete &amp;quot;ufficiale&amp;quot;, scritto in C e disponibile per linux, mac e windows.&lt;br /&gt;
[http://www.jython.org/Project/ Jython] è un interprete scritto al 100% in Java, e si interfaccia strettamente ai programmi e alla libreria Java, &lt;br /&gt;
[http://www.codeplex.com/Wiki/View.aspx?ProjectName=IronPython IronPython] è un interprete python che gira sulla piattaforma .NET mentre &lt;br /&gt;
[http://codespeak.net/pypy/dist/pypy/doc/home.html PyPy] è (anche) un interprete python scritto in.. python&lt;br /&gt;
&lt;br /&gt;
La prima riga di ogni script python deve iniziare con #!/usr/bin/env python&lt;br /&gt;
&lt;br /&gt;
il #! del file fa capire al sistema operativo (solo su sistemi posix, quindi unix/linux) che quello non è un file di testo ma un eseguibile da eseguire con l'inteprete python.&lt;br /&gt;
&lt;br /&gt;
== COMMENTI ==&lt;br /&gt;
&lt;br /&gt;
: sono righe che l'interprete salta e non legge &lt;br /&gt;
es: &lt;br /&gt;
    ''# stampa:”hello word”''&lt;br /&gt;
&lt;br /&gt;
== PRINT ==&lt;br /&gt;
: è una funzione, è seguito da una stringa (una cosa tra 2 virgolete).La stringa deve essere tra virgolette in tutti i comandi, i numeri interi invece no.&lt;br /&gt;
Il punto e virgola in molti dei linguaggi di porgrammazione si mette alla fine di ogi riga, in Python si può ma un buon pitonista in genere non lo fa mai.&lt;br /&gt;
PRINT stampa l'oggetto che viene dopo.&lt;br /&gt;
Se scrivo:&lt;br /&gt;
    ''print 3''&lt;br /&gt;
se si esegue questo stampa 3&lt;br /&gt;
se scrivo&lt;br /&gt;
    '' print “3”''&lt;br /&gt;
stampa lo stesso ma in questo caso l'oggetto che si passsa è una stringa&lt;br /&gt;
se scrivo&lt;br /&gt;
    ''print 3+2''&lt;br /&gt;
scrive&lt;br /&gt;
    '' 5''&lt;br /&gt;
se scrivo&lt;br /&gt;
    ''print “3+2”''&lt;br /&gt;
lui mi dà&lt;br /&gt;
    ''3+2''&lt;br /&gt;
&lt;br /&gt;
Le variabili non importa dichiararle, basta scrivere ad un certo punto&lt;br /&gt;
    ''messaggio=”hello world”''&lt;br /&gt;
    ''print messaggio''&lt;br /&gt;
se questo programma viene eseguito il risultatato sarà:&lt;br /&gt;
''hello world''&lt;br /&gt;
l'interprete va a vedere cosa c'è dentro la variabile messaggio e stampa hello world&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== ECCEZIONE ==&lt;br /&gt;
:se io commento la definizione di messaggio (es: ''# messaggio = &amp;quot; hello world &amp;quot;'' ) il programma non sa cos'è messaggio e se scrivo:&lt;br /&gt;
    ''print &amp;quot;messaggio&amp;quot;''&lt;br /&gt;
il risultato sarà:name error, che, viene chiamato eccezione.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== LE STRINGHE ==&lt;br /&gt;
supportano molti metodi perchè sono oggetti (che è un altro nome per variabile).le stringhe sono immutabili.&lt;br /&gt;
Se una stringa viene dichiarata la seconda volta, diversamente dalla prima, quella precedente viene buttata.&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
     messaggio=”ciao mondo”&lt;br /&gt;
    print “messaggio”''&lt;br /&gt;
lui scrive&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
In Python non si possono sommare cose diverse, o meglio, lo posso fare ma mi converte il numero in stringa.per esempio &lt;br /&gt;
    ''print messaggio*2'' &lt;br /&gt;
l'esecuzione darà&lt;br /&gt;
    ''messaggio messaggio&lt;br /&gt;
''&lt;br /&gt;
esempio:&lt;br /&gt;
     ''Print “ciao”+”mondo”''&lt;br /&gt;
lo eseguo e mi darà:&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
Se si scrive python da riga di comando parte l'interprete se scriviamo roba lui l'esegue e si usa per provare le cose.per uscire premere ctrl+d.&lt;br /&gt;
&lt;br /&gt;
LE STRINGHE SONO IMMUTABILI.&lt;br /&gt;
&lt;br /&gt;
== '''Funzione DIR''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
    dir(messaggio)''&lt;br /&gt;
a questo punto il programma da una serie di caratteri incomprensibili.&lt;br /&gt;
Praticamente dà i '''metodi''' che suporta la stringa messaggio.&lt;br /&gt;
&lt;br /&gt;
== I '''metodi''' ==&lt;br /&gt;
 sono operazioni che si possono applicare alla stringa.&lt;br /&gt;
quelli che iniziano con '''__'''spesso vengono usati per scoraggiare la gente ad usarli,in quanto qui non esistono i permessi e ognuno può modificare ciò che vuole.&lt;br /&gt;
&lt;br /&gt;
Quando il metodo inizia con '''AD''' richiama l'operatore dell'addizione&lt;br /&gt;
&lt;br /&gt;
'''__ doc__''' ce l'hanno tutti gli oggetti (stringhe, interi...)&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
metodo '''IS''':&lt;br /&gt;
tutti I metodi che iniziano per is danno come risultato o vero o falso.&lt;br /&gt;
es: &lt;br /&gt;
    ''messaggio.isalpha()''&lt;br /&gt;
mi dice se messaggio è o meno alfanumerico.&lt;br /&gt;
isalpha è un oggetto quindi ha le proprietà doc .&lt;br /&gt;
se io scrivo&lt;br /&gt;
    ''messaggio.isalpa.__doc__''&lt;br /&gt;
mi dice che fa.&lt;br /&gt;
&lt;br /&gt;
Importante metto tra “ solo se è una stringa.&lt;br /&gt;
Se io definisco un oggetto con un altro oggetto con una funzione non metto “.&lt;br /&gt;
es:&lt;br /&gt;
    '' messaggio=”gigio”&lt;br /&gt;
    messaggio2= messaggio.upper()''&lt;br /&gt;
&lt;br /&gt;
es:&lt;br /&gt;
''TYPE(3)''&lt;br /&gt;
mi dice che variabile  è.se è intero o stringa.&lt;br /&gt;
Se io scrivo ''DIR(3)''&lt;br /&gt;
mi da lo stesso pappie di roba di prima.&lt;br /&gt;
'''&lt;br /&gt;
I TIPI DELLA LIBREARIA STANDARD''':sono le variabili, ci sono anche le LISTE&lt;br /&gt;
&lt;br /&gt;
Esistono stringhe, interi, float (numeri con virgola)buleano (che ha due valori, vero o falso, True e false)e i  CONTENITORI:&lt;br /&gt;
&lt;br /&gt;
== '''LE LISTE''' ==&lt;br /&gt;
&lt;br /&gt;
es. lo scaffale ha I pc, I pc sono oggetti (pc1,pc2...).Se voglio uno scaffale di pc senza dare I nomi a tutti gli oggetti, definisco lo scaffale.&lt;br /&gt;
Lo scaffale si chiama''' Lista'''  .si usano le parentesi quadre con oggetti separati da virgola&lt;br /&gt;
es.    '' a = [ “pc1” , “schermo rotto” , 2]&lt;br /&gt;
dir (scaffale)''&lt;br /&gt;
da la lista dei metodi, da qui si capisce che la lista è un oggetto.&lt;br /&gt;
Se io faccio&lt;br /&gt;
    ''b = dir (a)''&lt;br /&gt;
o&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a il 4.&lt;br /&gt;
'''la lista MUTA!'''&lt;br /&gt;
Se faccio     ''print (“a”)''&lt;br /&gt;
mi da la lista degli oggetti più il 4.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''TUPLE''' ==&lt;br /&gt;
&lt;br /&gt;
è una lista non mutabile.&lt;br /&gt;
La tupla è molto piu veloce rispetto alla lista.&lt;br /&gt;
Con tuple si usano le parentesi tonde.&lt;br /&gt;
&lt;br /&gt;
== '''DIZIONARI''' ==&lt;br /&gt;
&lt;br /&gt;
il dizionario si definisce con le parentesi graffe {chiave:valore, chiave:valore}&lt;br /&gt;
a{chiave}&lt;br /&gt;
da il valore associato alla chiave.&lt;br /&gt;
&lt;br /&gt;
Dizionari liste e tuple sono dele sequenze e sono iterable e si possono scorrere.&lt;br /&gt;
&lt;br /&gt;
== '''If elif else''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
if condizione :&lt;br /&gt;
&lt;br /&gt;
indentato roba da fare se vero.&lt;br /&gt;
&lt;br /&gt;
Python supporta o tab o spazio, si decide quanti tab o spazi alla prima indentazione.&lt;br /&gt;
Meglio lo spazio perchè in futuro I tab verranno lasciati.&lt;br /&gt;
Di solito si usa 4 spazi.&lt;br /&gt;
Non c'è la graffa in pyton o I begin o gli end, si chiude e si apre la riga solo se si indenta.&lt;br /&gt;
&lt;br /&gt;
Esempio:&lt;br /&gt;
    ''a=3&lt;br /&gt;
    b=1''&lt;br /&gt;
&lt;br /&gt;
    ''if a &amp;gt;b:&lt;br /&gt;
      print (“ a è maggiore di b”)&lt;br /&gt;
    elif a==b:&lt;br /&gt;
      print (“ a è uguale a b”)&lt;br /&gt;
    else:&lt;br /&gt;
       print(“b è maggiore di a”)''&lt;br /&gt;
&lt;br /&gt;
in questo programma definisco due valori, a e b.&lt;br /&gt;
Chiedo al programma se aè maggiore di b di scrivere : a è maggiore di b, se a è uguale a b di scrivere che a è uguale a b e in tutte le altre condizioni (else) di scrivere che a è minore di b.&lt;br /&gt;
&lt;br /&gt;
	'''2.is, is not or, and,!='''&lt;br /&gt;
    ''if a is 1:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
    elif a is not 1:&lt;br /&gt;
      print (“no”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 and b is 3:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 or b is 3:&lt;br /&gt;
      print (“okkei”)&lt;br /&gt;
''&lt;br /&gt;
&lt;br /&gt;
'''!= è il diverso.'''&lt;br /&gt;
&lt;br /&gt;
== '''append, insert''' ==&lt;br /&gt;
&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a il 4.&lt;br /&gt;
Se faccio print (“a”)&lt;br /&gt;
mi da la lista degli oggetti più il 4.&lt;br /&gt;
&lt;br /&gt;
con '''insert''' devo inserire anche la posizione&lt;br /&gt;
    ''a.insert(2,34)''&lt;br /&gt;
mette il 34 in posizione 2&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''for''' ==&lt;br /&gt;
&lt;br /&gt;
specifica un ciclo, fa le cose tante volte fino ad una condizione.&lt;br /&gt;
For variabile in una sequenza di qualche tipo.&lt;br /&gt;
Es:     ''for elemento in a:&lt;br /&gt;
               print elemento''&lt;br /&gt;
&lt;br /&gt;
es b è una tupla.&lt;br /&gt;
Allora posso scrivere:&lt;br /&gt;
    ''for elem in b&lt;br /&gt;
         print “altro elemento”&lt;br /&gt;
         “print elem”''&lt;br /&gt;
&lt;br /&gt;
elem o qualsiasi altro nome gli dia è ogni elemento dentro la tupla o lista o dizionario.&lt;br /&gt;
&lt;br /&gt;
Se io voglio sia la chiave sia il valore in un dizionario (se metto elem mi mette solo la chiave) posso fare:&lt;br /&gt;
for chiave in a:&lt;br /&gt;
	    ''print “chiave: “ + chiave&lt;br /&gt;
	    print “valore: “ + a[chiave]''&lt;br /&gt;
&lt;br /&gt;
'''DOPO I DUE PUNTI METTO SEMPRE IL TAB.'''&lt;br /&gt;
&lt;br /&gt;
== '''xrange''' ==&lt;br /&gt;
&lt;br /&gt;
xrange è un iterable di dieci elementi con il primo valore uguale a 0 .E' una lista ma non ha le proprietà di una lista.&lt;br /&gt;
se io voglio fare un for da uno a dieci (cioè la somma da uno a 10)&lt;br /&gt;
&lt;br /&gt;
es:     ''for I xrange(10)&lt;br /&gt;
               print I''&lt;br /&gt;
lui stampa&lt;br /&gt;
''1&lt;br /&gt;
2&lt;br /&gt;
3&lt;br /&gt;
4&lt;br /&gt;
5&lt;br /&gt;
6&lt;br /&gt;
7&lt;br /&gt;
8&lt;br /&gt;
9&lt;br /&gt;
10''&lt;br /&gt;
&lt;br /&gt;
== '''range''' ==&lt;br /&gt;
&lt;br /&gt;
è una lista.se io scrivo:&lt;br /&gt;
    ''print range(10)''&lt;br /&gt;
lui mi da     ''[0,1,2,3,4,5,6,7,8,9].''&lt;br /&gt;
è più lento di xrange e poi sta morendo&lt;br /&gt;
&lt;br /&gt;
== '''len''' ==&lt;br /&gt;
&lt;br /&gt;
    ''len (a)''&lt;br /&gt;
da la lunghezza della stringa&lt;br /&gt;
&lt;br /&gt;
== '''enumerate''' ==&lt;br /&gt;
&lt;br /&gt;
se io ho una lista di tre elmenti&lt;br /&gt;
''a=[“ciao”,”bel”, “mondo”]''&lt;br /&gt;
&lt;br /&gt;
''for I, elem in enumerate(a):&lt;br /&gt;
     print str(I) + “:” + elem&lt;br /&gt;
''&lt;br /&gt;
da la posizione corrente di ogni elemento.&lt;br /&gt;
''0:ciao&lt;br /&gt;
1:bel&lt;br /&gt;
2:mondo''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''raw_input''' ==&lt;br /&gt;
&lt;br /&gt;
dai il valore.&lt;br /&gt;
''Base= raw_input (“inserisce la base:”)&lt;br /&gt;
esponente=raw_input (“inserisci l'/ esponente”)''&lt;br /&gt;
&lt;br /&gt;
ti chiede il valore di base ed esponente.&lt;br /&gt;
&lt;br /&gt;
== '''Int''' ==&lt;br /&gt;
&lt;br /&gt;
forza il fatto che quel valore sia un intero.&lt;br /&gt;
''&lt;br /&gt;
Es:base=int(base)&lt;br /&gt;
  result=int(result)''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''UPPER,LOWER,CAPITALIZE''' ==&lt;br /&gt;
&lt;br /&gt;
'''capitalize''' è un comando che sulla la stringa su cui viene applicato ,prende la prima lettera dopo gli spazi e ci mette la maiuscola&lt;br /&gt;
&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.capitalize()''&lt;br /&gt;
    ''Ciao mondo''&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.title()&lt;br /&gt;
    Ciao Mondo''&lt;br /&gt;
&lt;br /&gt;
'''LOWER:''' prende la striga e emette tutto minuscolo&lt;br /&gt;
'''UPPER:''' il contrario di lower&lt;br /&gt;
&lt;br /&gt;
== '''ESEMPIO DELLA SERATA:''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Calcolo di una potenza.&lt;br /&gt;
&lt;br /&gt;
    ''&lt;br /&gt;
    base= raw_input (“inserisce la base:”)&lt;br /&gt;
    esponente=raw_input (“inserisci l\' esponente”)&lt;br /&gt;
&lt;br /&gt;
    base=int(base)&lt;br /&gt;
    result=int(result)&lt;br /&gt;
&lt;br /&gt;
    result=1&lt;br /&gt;
    for i in xrange(esponente):&lt;br /&gt;
         result = result * base&lt;br /&gt;
    print result''&lt;br /&gt;
&lt;br /&gt;
il [http://docs.python.org/lib/built-in-funcs.html built-in] int() è necessario, dato che tutto quello che proviene dalla tastiera viene acquisito da raw_input() come stringa. Dato che dobbiamo usarli come interi, occorre effettuare un cast, ovvero&lt;br /&gt;
una trasformazione di tipo, da stringa a intero.&lt;br /&gt;
E' interessante notare che int() non cerca di fare i miracoli: provate a vedere cosa succede se cercate di convertire &amp;quot;awlerorj&amp;quot; in int!&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3727</id>
		<title>Python Lezione 4 Giugno 2008</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3727"/>
		<updated>2008-06-06T08:12:23Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: /* '''ESEMPIO DELLA SERATA:''' */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Python ==&lt;br /&gt;
[http://www.python.it/ Python] è un linguaggio di programmazione [http://it.wikipedia.org/wiki/Interprete_(informatica) interpretato].&lt;br /&gt;
Il linuaggio interpretato è simile agli altri linguaggi in circolazione ma, invece di essere trasformato direttamente in codice binario dal meccanismo automatico, viene interpretato da questo e poi mandato all'hardware.&lt;br /&gt;
Un linguaggio interpretato non ha bisogno di essere ricompilato: il codice scritto viene interpretato da un interprete a run-time (tempo di esecuzione) e tradotto al volo nel linguaggio macchina.&lt;br /&gt;
Quindi i programmi python possono girare su qualsiasi hardware e sistema operativo su cui è stato portato l'interprete. Ovviamente, questa cosa si paga sul tempo di esecuzione pure: l'approccio ha si i suoi vantaggi, ma rispetto a un linguaggio compilato direttamente in linguaggio macchina per creare un eseguibile, python e gli altri liguaggi interpretati risultano essere più lenti.&lt;br /&gt;
&lt;br /&gt;
Esistono vari interpreti: [http://www.python.org Cpython], o classic python, è l'interprete &amp;quot;ufficiale&amp;quot;, scritto in C e disponibile per linux, mac e windows.&lt;br /&gt;
[http://www.jython.org/Project/ Jython] è un interprete scritto al 100% in Java, e si interfaccia strettamente ai programmi e alla libreria Java, &lt;br /&gt;
[http://www.codeplex.com/Wiki/View.aspx?ProjectName=IronPython IronPython] è un interprete python che gira sulla piattaforma .NET mentre &lt;br /&gt;
[http://codespeak.net/pypy/dist/pypy/doc/home.html PyPy] è (anche) un interprete python scritto in.. python&lt;br /&gt;
&lt;br /&gt;
La prima riga di ogni script python deve iniziare con &lt;br /&gt;
#!usr/bin/env python&lt;br /&gt;
&lt;br /&gt;
il #! del file fa capire al sistema operativo (solo su sistemi posix, quindi unix/linux) che quello non è un file di testo ma un eseguibile da eseguire con l'inteprete python.&lt;br /&gt;
&lt;br /&gt;
== COMMENTI ==&lt;br /&gt;
&lt;br /&gt;
: sono righe che l'interprete salta e non legge &lt;br /&gt;
es: &lt;br /&gt;
    ''# stampa:”hello word”''&lt;br /&gt;
&lt;br /&gt;
== PRINT ==&lt;br /&gt;
: è una funzione, è seguito da una stringa (una cosa tra 2 virgolete).La stringa deve essere tra virgolette in tutti i comandi, i numeri interi invece no.&lt;br /&gt;
Il punto e virgola in molti dei linguaggi di porgrammazione si mette alla fine di ogi riga, in Python si può ma un buon pitonista in genere non lo fa mai.&lt;br /&gt;
PRINT stampa l'oggetto che viene dopo.&lt;br /&gt;
Se scrivo:&lt;br /&gt;
    ''print 3''&lt;br /&gt;
se si esegue questo stampa 3&lt;br /&gt;
se scrivo&lt;br /&gt;
    '' print “3”''&lt;br /&gt;
stampa lo stesso ma in questo caso l'oggetto che si passsa è una stringa&lt;br /&gt;
se scrivo&lt;br /&gt;
    ''print 3+2''&lt;br /&gt;
scrive&lt;br /&gt;
    '' 5''&lt;br /&gt;
se scrivo&lt;br /&gt;
    ''print “3+2”''&lt;br /&gt;
lui mi dà&lt;br /&gt;
    ''3+2''&lt;br /&gt;
&lt;br /&gt;
Le variabili non importa dichiararle, basta scrivere ad un certo punto&lt;br /&gt;
    ''messaggio=”hello world”''&lt;br /&gt;
    ''print messaggio''&lt;br /&gt;
se questo programma viene eseguito il risultatato sarà:&lt;br /&gt;
''hello world''&lt;br /&gt;
l'interprete va a vedere cosa c'è dentro la variabile messaggio e stampa hello world&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== ECCEZIONE ==&lt;br /&gt;
:se io commento la definizione di messaggio (es: ''# messaggio = &amp;quot; hello world &amp;quot;'' ) il programma non sa cos'è messaggio e se scrivo:&lt;br /&gt;
    ''print &amp;quot;messaggio&amp;quot;''&lt;br /&gt;
il risultato sarà:name error, che, viene chiamato eccezione.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== LE STRINGHE ==&lt;br /&gt;
supportano molti metodi perchè sono oggetti (che è un altro nome per variabile).le stringhe sono immutabili.&lt;br /&gt;
Se una stringa viene dichiarata la seconda volta, diversamente dalla prima, quella precedente viene buttata.&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
     messaggio=”ciao mondo”&lt;br /&gt;
    print “messaggio”''&lt;br /&gt;
lui scrive&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
In Python non si possono sommare cose diverse, o meglio, lo posso fare ma mi converte il numero in stringa.per esempio &lt;br /&gt;
    ''print messaggio*2'' &lt;br /&gt;
l'esecuzione darà&lt;br /&gt;
    ''messaggio messaggio&lt;br /&gt;
''&lt;br /&gt;
esempio:&lt;br /&gt;
     ''Print “ciao”+”mondo”''&lt;br /&gt;
lo eseguo e mi darà:&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
Se si scrive python da riga di comando parte l'interprete se scriviamo roba lui l'esegue e si usa per provare le cose.per uscire premere ctrl+d.&lt;br /&gt;
&lt;br /&gt;
LE STRINGHE SONO IMMUTABILI.&lt;br /&gt;
&lt;br /&gt;
== '''Funzione DIR''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
    dir(messaggio)''&lt;br /&gt;
a questo punto il programma da una serie di caratteri incomprensibili.&lt;br /&gt;
Praticamente dà i '''metodi''' che suporta la stringa messaggio.&lt;br /&gt;
&lt;br /&gt;
== I '''metodi''' ==&lt;br /&gt;
 sono operazioni che si possono applicare alla stringa.&lt;br /&gt;
quelli che iniziano con '''__'''spesso vengono usati per scoraggiare la gente ad usarli,in quanto qui non esistono i permessi e ognuno può modificare ciò che vuole.&lt;br /&gt;
&lt;br /&gt;
Quando il metodo inizia con '''AD''' richiama l'operatore dell'addizione&lt;br /&gt;
&lt;br /&gt;
'''__ doc__''' ce l'hanno tutti gli oggetti (stringhe, interi...)&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
metodo '''IS''':&lt;br /&gt;
tutti I metodi che iniziano per is danno come risultato o vero o falso.&lt;br /&gt;
es: &lt;br /&gt;
    ''messaggio.isalpha()''&lt;br /&gt;
mi dice se messaggio è o meno alfanumerico.&lt;br /&gt;
isalpha è un oggetto quindi ha le proprietà doc .&lt;br /&gt;
se io scrivo&lt;br /&gt;
    ''messaggio.isalpa.__doc__''&lt;br /&gt;
mi dice che fa.&lt;br /&gt;
&lt;br /&gt;
Importante metto tra “ solo se è una stringa.&lt;br /&gt;
Se io definisco un oggetto con un altro oggetto con una funzione non metto “.&lt;br /&gt;
es:&lt;br /&gt;
    '' messaggio=”gigio”&lt;br /&gt;
    messaggio2= messaggio.upper()''&lt;br /&gt;
&lt;br /&gt;
es:&lt;br /&gt;
''TYPE(3)''&lt;br /&gt;
mi dice che variabile  è.se è intero o stringa.&lt;br /&gt;
Se io scrivo ''DIR(3)''&lt;br /&gt;
mi da lo stesso pappie di roba di prima.&lt;br /&gt;
'''&lt;br /&gt;
I TIPI DELLA LIBREARIA STANDARD''':sono le variabili, ci sono anche le LISTE&lt;br /&gt;
&lt;br /&gt;
Esistono stringhe, interi, float (numeri con virgola)buleano (che ha due valori, vero o falso, True e false)e i  CONTENITORI:&lt;br /&gt;
&lt;br /&gt;
== '''LE LISTE''' ==&lt;br /&gt;
&lt;br /&gt;
es. lo scaffale ha I pc, I pc sono oggetti (pc1,pc2...).Se voglio uno scaffale di pc senza dare I nomi a tutti gli oggetti, definisco lo scaffale.&lt;br /&gt;
Lo scaffale si chiama''' Lista'''  .si usano le parentesi quadre con oggetti separati da virgola&lt;br /&gt;
es.    '' a = [ “pc1” , “schermo rotto” , 2]&lt;br /&gt;
dir (scaffale)''&lt;br /&gt;
da la lista dei metodi, da qui si capisce che la lista è un oggetto.&lt;br /&gt;
Se io faccio&lt;br /&gt;
    ''b = dir (a)''&lt;br /&gt;
o&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a il 4.&lt;br /&gt;
'''la lista MUTA!'''&lt;br /&gt;
Se faccio     ''print (“a”)''&lt;br /&gt;
mi da la lista degli oggetti più il 4.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''TUPLE''' ==&lt;br /&gt;
&lt;br /&gt;
è una lista non mutabile.&lt;br /&gt;
La tupla è molto piu veloce rispetto alla lista.&lt;br /&gt;
Con tuple si usano le parentesi tonde.&lt;br /&gt;
&lt;br /&gt;
== '''DIZIONARI''' ==&lt;br /&gt;
&lt;br /&gt;
il dizionario si definisce con le parentesi graffe {chiave:valore, chiave:valore}&lt;br /&gt;
a{chiave}&lt;br /&gt;
da il valore associato alla chiave.&lt;br /&gt;
&lt;br /&gt;
Dizionari liste e tuple sono dele sequenze e sono iterable e si possono scorrere.&lt;br /&gt;
&lt;br /&gt;
== '''If elif else''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
if condizione :&lt;br /&gt;
&lt;br /&gt;
indentato roba da fare se vero.&lt;br /&gt;
&lt;br /&gt;
Python supporta o tab o spazio, si decide quanti tab o spazi alla prima indentazione.&lt;br /&gt;
Meglio lo spazio perchè in futuro I tab verranno lasciati.&lt;br /&gt;
Di solito si usa 4 spazi.&lt;br /&gt;
Non c'è la graffa in pyton o I begin o gli end, si chiude e si apre la riga solo se si indenta.&lt;br /&gt;
&lt;br /&gt;
Esempio:&lt;br /&gt;
    ''a=3&lt;br /&gt;
    b=1''&lt;br /&gt;
&lt;br /&gt;
    ''if a &amp;gt;b:&lt;br /&gt;
      print (“ a è maggiore di b”)&lt;br /&gt;
    elif a==b:&lt;br /&gt;
      print (“ a è uguale a b”)&lt;br /&gt;
    else:&lt;br /&gt;
       print(“b è maggiore di a”)''&lt;br /&gt;
&lt;br /&gt;
in questo programma definisco due valori, a e b.&lt;br /&gt;
Chiedo al programma se aè maggiore di b di scrivere : a è maggiore di b, se a è uguale a b di scrivere che a è uguale a b e in tutte le altre condizioni (else) di scrivere che a è minore di b.&lt;br /&gt;
&lt;br /&gt;
	'''2.is, is not or, and,!='''&lt;br /&gt;
    ''if a is 1:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
    elif a is not 1:&lt;br /&gt;
      print (“no”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 and b is 3:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 or b is 3:&lt;br /&gt;
      print (“okkei”)&lt;br /&gt;
''&lt;br /&gt;
&lt;br /&gt;
'''!= è il diverso.'''&lt;br /&gt;
&lt;br /&gt;
== '''append, insert''' ==&lt;br /&gt;
&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a il 4.&lt;br /&gt;
Se faccio print (“a”)&lt;br /&gt;
mi da la lista degli oggetti più il 4.&lt;br /&gt;
&lt;br /&gt;
con '''insert''' devo inserire anche la posizione&lt;br /&gt;
    ''a.insert(2,34)''&lt;br /&gt;
mette il 34 in posizione 2&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''for''' ==&lt;br /&gt;
&lt;br /&gt;
specifica un ciclo, fa le cose tante volte fino ad una condizione.&lt;br /&gt;
For variabile in una sequenza di qualche tipo.&lt;br /&gt;
Es:     ''for elemento in a:&lt;br /&gt;
               print elemento''&lt;br /&gt;
&lt;br /&gt;
es b è una tupla.&lt;br /&gt;
Allora posso scrivere:&lt;br /&gt;
    ''for elem in b&lt;br /&gt;
         print “altro elemento”&lt;br /&gt;
         “print elem”''&lt;br /&gt;
&lt;br /&gt;
elem o qualsiasi altro nome gli dia è ogni elemento dentro la tupla o lista o dizionario.&lt;br /&gt;
&lt;br /&gt;
Se io voglio sia la chiave sia il valore in un dizionario (se metto elem mi mette solo la chiave) posso fare:&lt;br /&gt;
for chiave in a:&lt;br /&gt;
	    ''print “chiave: “ + chiave&lt;br /&gt;
	    print “valore: “ + a[chiave]''&lt;br /&gt;
&lt;br /&gt;
'''DOPO I DUE PUNTI METTO SEMPRE IL TAB.'''&lt;br /&gt;
&lt;br /&gt;
== '''xrange''' ==&lt;br /&gt;
&lt;br /&gt;
xrange è un iterable di dieci elementi con il primo valore uguale a 0 .E' una lista ma non ha le proprietà di una lista.&lt;br /&gt;
se io voglio fare un for da uno a dieci (cioè la somma da uno a 10)&lt;br /&gt;
&lt;br /&gt;
es:     ''for I xrange(10)&lt;br /&gt;
               print I''&lt;br /&gt;
lui stampa&lt;br /&gt;
''1&lt;br /&gt;
2&lt;br /&gt;
3&lt;br /&gt;
4&lt;br /&gt;
5&lt;br /&gt;
6&lt;br /&gt;
7&lt;br /&gt;
8&lt;br /&gt;
9&lt;br /&gt;
10''&lt;br /&gt;
&lt;br /&gt;
== '''range''' ==&lt;br /&gt;
&lt;br /&gt;
è una lista.se io scrivo:&lt;br /&gt;
    ''print range(10)''&lt;br /&gt;
lui mi da     ''[0,1,2,3,4,5,6,7,8,9].''&lt;br /&gt;
è più lento di xrange e poi sta morendo&lt;br /&gt;
&lt;br /&gt;
== '''len''' ==&lt;br /&gt;
&lt;br /&gt;
    ''len (a)''&lt;br /&gt;
da la lunghezza della stringa&lt;br /&gt;
&lt;br /&gt;
== '''enumerate''' ==&lt;br /&gt;
&lt;br /&gt;
se io ho una lista di tre elmenti&lt;br /&gt;
''a=[“ciao”,”bel”, “mondo”]''&lt;br /&gt;
&lt;br /&gt;
''for I, elem in enumerate(a):&lt;br /&gt;
     print str(I) + “:” + elem&lt;br /&gt;
''&lt;br /&gt;
da la posizione corrente di ogni elemento.&lt;br /&gt;
''0:ciao&lt;br /&gt;
1:bel&lt;br /&gt;
2:mondo''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''raw_input''' ==&lt;br /&gt;
&lt;br /&gt;
dai il valore.&lt;br /&gt;
''Base= raw_input (“inserisce la base:”)&lt;br /&gt;
esponente=raw_input (“inserisci l'/ esponente”)''&lt;br /&gt;
&lt;br /&gt;
ti chiede il valore di base ed esponente.&lt;br /&gt;
&lt;br /&gt;
== '''Int''' ==&lt;br /&gt;
&lt;br /&gt;
forza il fatto che quel valore sia un intero.&lt;br /&gt;
''&lt;br /&gt;
Es:base=int(base)&lt;br /&gt;
  result=int(result)''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''UPPER,LOWER,CAPITALIZE''' ==&lt;br /&gt;
&lt;br /&gt;
'''capitalize''' è un comando che sulla la stringa su cui viene applicato ,prende la prima lettera dopo gli spazi e ci mette la maiuscola&lt;br /&gt;
&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.capitalize()''&lt;br /&gt;
    ''Ciao mondo''&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.title()&lt;br /&gt;
    Ciao Mondo''&lt;br /&gt;
&lt;br /&gt;
'''LOWER:''' prende la striga e emette tutto minuscolo&lt;br /&gt;
'''UPPER:''' il contrario di lower&lt;br /&gt;
&lt;br /&gt;
== '''ESEMPIO DELLA SERATA:''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Calcolo di una potenza.&lt;br /&gt;
&lt;br /&gt;
    ''&lt;br /&gt;
    base= raw_input (“inserisce la base:”)&lt;br /&gt;
    esponente=raw_input (“inserisci l\' esponente”)&lt;br /&gt;
&lt;br /&gt;
    base=int(base)&lt;br /&gt;
    result=int(result)&lt;br /&gt;
&lt;br /&gt;
    result=1&lt;br /&gt;
    for i in xrange(esponente):&lt;br /&gt;
         result = result * base&lt;br /&gt;
    print result''&lt;br /&gt;
&lt;br /&gt;
il [http://docs.python.org/lib/built-in-funcs.html built-in] int() è necessario, dato che tutto quello che proviene dalla tastiera viene acquisito da raw_input() come stringa. Dato che dobbiamo usarli come interi, occorre effettuare un cast, ovvero&lt;br /&gt;
una trasformazione di tipo, da stringa a intero.&lt;br /&gt;
E' interessante notare che int() non cerca di fare i miracoli: provate a vedere cosa succede se cercate di convertire &amp;quot;awlerorj&amp;quot; in int!&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3726</id>
		<title>Python Lezione 4 Giugno 2008</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3726"/>
		<updated>2008-06-06T08:12:03Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: /* '''ESEMPIO DELLA SERATA:''' */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Python ==&lt;br /&gt;
[http://www.python.it/ Python] è un linguaggio di programmazione [http://it.wikipedia.org/wiki/Interprete_(informatica) interpretato].&lt;br /&gt;
Il linuaggio interpretato è simile agli altri linguaggi in circolazione ma, invece di essere trasformato direttamente in codice binario dal meccanismo automatico, viene interpretato da questo e poi mandato all'hardware.&lt;br /&gt;
Un linguaggio interpretato non ha bisogno di essere ricompilato: il codice scritto viene interpretato da un interprete a run-time (tempo di esecuzione) e tradotto al volo nel linguaggio macchina.&lt;br /&gt;
Quindi i programmi python possono girare su qualsiasi hardware e sistema operativo su cui è stato portato l'interprete. Ovviamente, questa cosa si paga sul tempo di esecuzione pure: l'approccio ha si i suoi vantaggi, ma rispetto a un linguaggio compilato direttamente in linguaggio macchina per creare un eseguibile, python e gli altri liguaggi interpretati risultano essere più lenti.&lt;br /&gt;
&lt;br /&gt;
Esistono vari interpreti: [http://www.python.org Cpython], o classic python, è l'interprete &amp;quot;ufficiale&amp;quot;, scritto in C e disponibile per linux, mac e windows.&lt;br /&gt;
[http://www.jython.org/Project/ Jython] è un interprete scritto al 100% in Java, e si interfaccia strettamente ai programmi e alla libreria Java, &lt;br /&gt;
[http://www.codeplex.com/Wiki/View.aspx?ProjectName=IronPython IronPython] è un interprete python che gira sulla piattaforma .NET mentre &lt;br /&gt;
[http://codespeak.net/pypy/dist/pypy/doc/home.html PyPy] è (anche) un interprete python scritto in.. python&lt;br /&gt;
&lt;br /&gt;
La prima riga di ogni script python deve iniziare con &lt;br /&gt;
#!usr/bin/env python&lt;br /&gt;
&lt;br /&gt;
il #! del file fa capire al sistema operativo (solo su sistemi posix, quindi unix/linux) che quello non è un file di testo ma un eseguibile da eseguire con l'inteprete python.&lt;br /&gt;
&lt;br /&gt;
== COMMENTI ==&lt;br /&gt;
&lt;br /&gt;
: sono righe che l'interprete salta e non legge &lt;br /&gt;
es: &lt;br /&gt;
    ''# stampa:”hello word”''&lt;br /&gt;
&lt;br /&gt;
== PRINT ==&lt;br /&gt;
: è una funzione, è seguito da una stringa (una cosa tra 2 virgolete).La stringa deve essere tra virgolette in tutti i comandi, i numeri interi invece no.&lt;br /&gt;
Il punto e virgola in molti dei linguaggi di porgrammazione si mette alla fine di ogi riga, in Python si può ma un buon pitonista in genere non lo fa mai.&lt;br /&gt;
PRINT stampa l'oggetto che viene dopo.&lt;br /&gt;
Se scrivo:&lt;br /&gt;
    ''print 3''&lt;br /&gt;
se si esegue questo stampa 3&lt;br /&gt;
se scrivo&lt;br /&gt;
    '' print “3”''&lt;br /&gt;
stampa lo stesso ma in questo caso l'oggetto che si passsa è una stringa&lt;br /&gt;
se scrivo&lt;br /&gt;
    ''print 3+2''&lt;br /&gt;
scrive&lt;br /&gt;
    '' 5''&lt;br /&gt;
se scrivo&lt;br /&gt;
    ''print “3+2”''&lt;br /&gt;
lui mi dà&lt;br /&gt;
    ''3+2''&lt;br /&gt;
&lt;br /&gt;
Le variabili non importa dichiararle, basta scrivere ad un certo punto&lt;br /&gt;
    ''messaggio=”hello world”''&lt;br /&gt;
    ''print messaggio''&lt;br /&gt;
se questo programma viene eseguito il risultatato sarà:&lt;br /&gt;
''hello world''&lt;br /&gt;
l'interprete va a vedere cosa c'è dentro la variabile messaggio e stampa hello world&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== ECCEZIONE ==&lt;br /&gt;
:se io commento la definizione di messaggio (es: ''# messaggio = &amp;quot; hello world &amp;quot;'' ) il programma non sa cos'è messaggio e se scrivo:&lt;br /&gt;
    ''print &amp;quot;messaggio&amp;quot;''&lt;br /&gt;
il risultato sarà:name error, che, viene chiamato eccezione.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== LE STRINGHE ==&lt;br /&gt;
supportano molti metodi perchè sono oggetti (che è un altro nome per variabile).le stringhe sono immutabili.&lt;br /&gt;
Se una stringa viene dichiarata la seconda volta, diversamente dalla prima, quella precedente viene buttata.&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
     messaggio=”ciao mondo”&lt;br /&gt;
    print “messaggio”''&lt;br /&gt;
lui scrive&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
In Python non si possono sommare cose diverse, o meglio, lo posso fare ma mi converte il numero in stringa.per esempio &lt;br /&gt;
    ''print messaggio*2'' &lt;br /&gt;
l'esecuzione darà&lt;br /&gt;
    ''messaggio messaggio&lt;br /&gt;
''&lt;br /&gt;
esempio:&lt;br /&gt;
     ''Print “ciao”+”mondo”''&lt;br /&gt;
lo eseguo e mi darà:&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
Se si scrive python da riga di comando parte l'interprete se scriviamo roba lui l'esegue e si usa per provare le cose.per uscire premere ctrl+d.&lt;br /&gt;
&lt;br /&gt;
LE STRINGHE SONO IMMUTABILI.&lt;br /&gt;
&lt;br /&gt;
== '''Funzione DIR''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
    dir(messaggio)''&lt;br /&gt;
a questo punto il programma da una serie di caratteri incomprensibili.&lt;br /&gt;
Praticamente dà i '''metodi''' che suporta la stringa messaggio.&lt;br /&gt;
&lt;br /&gt;
== I '''metodi''' ==&lt;br /&gt;
 sono operazioni che si possono applicare alla stringa.&lt;br /&gt;
quelli che iniziano con '''__'''spesso vengono usati per scoraggiare la gente ad usarli,in quanto qui non esistono i permessi e ognuno può modificare ciò che vuole.&lt;br /&gt;
&lt;br /&gt;
Quando il metodo inizia con '''AD''' richiama l'operatore dell'addizione&lt;br /&gt;
&lt;br /&gt;
'''__ doc__''' ce l'hanno tutti gli oggetti (stringhe, interi...)&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
metodo '''IS''':&lt;br /&gt;
tutti I metodi che iniziano per is danno come risultato o vero o falso.&lt;br /&gt;
es: &lt;br /&gt;
    ''messaggio.isalpha()''&lt;br /&gt;
mi dice se messaggio è o meno alfanumerico.&lt;br /&gt;
isalpha è un oggetto quindi ha le proprietà doc .&lt;br /&gt;
se io scrivo&lt;br /&gt;
    ''messaggio.isalpa.__doc__''&lt;br /&gt;
mi dice che fa.&lt;br /&gt;
&lt;br /&gt;
Importante metto tra “ solo se è una stringa.&lt;br /&gt;
Se io definisco un oggetto con un altro oggetto con una funzione non metto “.&lt;br /&gt;
es:&lt;br /&gt;
    '' messaggio=”gigio”&lt;br /&gt;
    messaggio2= messaggio.upper()''&lt;br /&gt;
&lt;br /&gt;
es:&lt;br /&gt;
''TYPE(3)''&lt;br /&gt;
mi dice che variabile  è.se è intero o stringa.&lt;br /&gt;
Se io scrivo ''DIR(3)''&lt;br /&gt;
mi da lo stesso pappie di roba di prima.&lt;br /&gt;
'''&lt;br /&gt;
I TIPI DELLA LIBREARIA STANDARD''':sono le variabili, ci sono anche le LISTE&lt;br /&gt;
&lt;br /&gt;
Esistono stringhe, interi, float (numeri con virgola)buleano (che ha due valori, vero o falso, True e false)e i  CONTENITORI:&lt;br /&gt;
&lt;br /&gt;
== '''LE LISTE''' ==&lt;br /&gt;
&lt;br /&gt;
es. lo scaffale ha I pc, I pc sono oggetti (pc1,pc2...).Se voglio uno scaffale di pc senza dare I nomi a tutti gli oggetti, definisco lo scaffale.&lt;br /&gt;
Lo scaffale si chiama''' Lista'''  .si usano le parentesi quadre con oggetti separati da virgola&lt;br /&gt;
es.    '' a = [ “pc1” , “schermo rotto” , 2]&lt;br /&gt;
dir (scaffale)''&lt;br /&gt;
da la lista dei metodi, da qui si capisce che la lista è un oggetto.&lt;br /&gt;
Se io faccio&lt;br /&gt;
    ''b = dir (a)''&lt;br /&gt;
o&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a il 4.&lt;br /&gt;
'''la lista MUTA!'''&lt;br /&gt;
Se faccio     ''print (“a”)''&lt;br /&gt;
mi da la lista degli oggetti più il 4.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''TUPLE''' ==&lt;br /&gt;
&lt;br /&gt;
è una lista non mutabile.&lt;br /&gt;
La tupla è molto piu veloce rispetto alla lista.&lt;br /&gt;
Con tuple si usano le parentesi tonde.&lt;br /&gt;
&lt;br /&gt;
== '''DIZIONARI''' ==&lt;br /&gt;
&lt;br /&gt;
il dizionario si definisce con le parentesi graffe {chiave:valore, chiave:valore}&lt;br /&gt;
a{chiave}&lt;br /&gt;
da il valore associato alla chiave.&lt;br /&gt;
&lt;br /&gt;
Dizionari liste e tuple sono dele sequenze e sono iterable e si possono scorrere.&lt;br /&gt;
&lt;br /&gt;
== '''If elif else''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
if condizione :&lt;br /&gt;
&lt;br /&gt;
indentato roba da fare se vero.&lt;br /&gt;
&lt;br /&gt;
Python supporta o tab o spazio, si decide quanti tab o spazi alla prima indentazione.&lt;br /&gt;
Meglio lo spazio perchè in futuro I tab verranno lasciati.&lt;br /&gt;
Di solito si usa 4 spazi.&lt;br /&gt;
Non c'è la graffa in pyton o I begin o gli end, si chiude e si apre la riga solo se si indenta.&lt;br /&gt;
&lt;br /&gt;
Esempio:&lt;br /&gt;
    ''a=3&lt;br /&gt;
    b=1''&lt;br /&gt;
&lt;br /&gt;
    ''if a &amp;gt;b:&lt;br /&gt;
      print (“ a è maggiore di b”)&lt;br /&gt;
    elif a==b:&lt;br /&gt;
      print (“ a è uguale a b”)&lt;br /&gt;
    else:&lt;br /&gt;
       print(“b è maggiore di a”)''&lt;br /&gt;
&lt;br /&gt;
in questo programma definisco due valori, a e b.&lt;br /&gt;
Chiedo al programma se aè maggiore di b di scrivere : a è maggiore di b, se a è uguale a b di scrivere che a è uguale a b e in tutte le altre condizioni (else) di scrivere che a è minore di b.&lt;br /&gt;
&lt;br /&gt;
	'''2.is, is not or, and,!='''&lt;br /&gt;
    ''if a is 1:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
    elif a is not 1:&lt;br /&gt;
      print (“no”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 and b is 3:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 or b is 3:&lt;br /&gt;
      print (“okkei”)&lt;br /&gt;
''&lt;br /&gt;
&lt;br /&gt;
'''!= è il diverso.'''&lt;br /&gt;
&lt;br /&gt;
== '''append, insert''' ==&lt;br /&gt;
&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a il 4.&lt;br /&gt;
Se faccio print (“a”)&lt;br /&gt;
mi da la lista degli oggetti più il 4.&lt;br /&gt;
&lt;br /&gt;
con '''insert''' devo inserire anche la posizione&lt;br /&gt;
    ''a.insert(2,34)''&lt;br /&gt;
mette il 34 in posizione 2&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''for''' ==&lt;br /&gt;
&lt;br /&gt;
specifica un ciclo, fa le cose tante volte fino ad una condizione.&lt;br /&gt;
For variabile in una sequenza di qualche tipo.&lt;br /&gt;
Es:     ''for elemento in a:&lt;br /&gt;
               print elemento''&lt;br /&gt;
&lt;br /&gt;
es b è una tupla.&lt;br /&gt;
Allora posso scrivere:&lt;br /&gt;
    ''for elem in b&lt;br /&gt;
         print “altro elemento”&lt;br /&gt;
         “print elem”''&lt;br /&gt;
&lt;br /&gt;
elem o qualsiasi altro nome gli dia è ogni elemento dentro la tupla o lista o dizionario.&lt;br /&gt;
&lt;br /&gt;
Se io voglio sia la chiave sia il valore in un dizionario (se metto elem mi mette solo la chiave) posso fare:&lt;br /&gt;
for chiave in a:&lt;br /&gt;
	    ''print “chiave: “ + chiave&lt;br /&gt;
	    print “valore: “ + a[chiave]''&lt;br /&gt;
&lt;br /&gt;
'''DOPO I DUE PUNTI METTO SEMPRE IL TAB.'''&lt;br /&gt;
&lt;br /&gt;
== '''xrange''' ==&lt;br /&gt;
&lt;br /&gt;
xrange è un iterable di dieci elementi con il primo valore uguale a 0 .E' una lista ma non ha le proprietà di una lista.&lt;br /&gt;
se io voglio fare un for da uno a dieci (cioè la somma da uno a 10)&lt;br /&gt;
&lt;br /&gt;
es:     ''for I xrange(10)&lt;br /&gt;
               print I''&lt;br /&gt;
lui stampa&lt;br /&gt;
''1&lt;br /&gt;
2&lt;br /&gt;
3&lt;br /&gt;
4&lt;br /&gt;
5&lt;br /&gt;
6&lt;br /&gt;
7&lt;br /&gt;
8&lt;br /&gt;
9&lt;br /&gt;
10''&lt;br /&gt;
&lt;br /&gt;
== '''range''' ==&lt;br /&gt;
&lt;br /&gt;
è una lista.se io scrivo:&lt;br /&gt;
    ''print range(10)''&lt;br /&gt;
lui mi da     ''[0,1,2,3,4,5,6,7,8,9].''&lt;br /&gt;
è più lento di xrange e poi sta morendo&lt;br /&gt;
&lt;br /&gt;
== '''len''' ==&lt;br /&gt;
&lt;br /&gt;
    ''len (a)''&lt;br /&gt;
da la lunghezza della stringa&lt;br /&gt;
&lt;br /&gt;
== '''enumerate''' ==&lt;br /&gt;
&lt;br /&gt;
se io ho una lista di tre elmenti&lt;br /&gt;
''a=[“ciao”,”bel”, “mondo”]''&lt;br /&gt;
&lt;br /&gt;
''for I, elem in enumerate(a):&lt;br /&gt;
     print str(I) + “:” + elem&lt;br /&gt;
''&lt;br /&gt;
da la posizione corrente di ogni elemento.&lt;br /&gt;
''0:ciao&lt;br /&gt;
1:bel&lt;br /&gt;
2:mondo''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''raw_input''' ==&lt;br /&gt;
&lt;br /&gt;
dai il valore.&lt;br /&gt;
''Base= raw_input (“inserisce la base:”)&lt;br /&gt;
esponente=raw_input (“inserisci l'/ esponente”)''&lt;br /&gt;
&lt;br /&gt;
ti chiede il valore di base ed esponente.&lt;br /&gt;
&lt;br /&gt;
== '''Int''' ==&lt;br /&gt;
&lt;br /&gt;
forza il fatto che quel valore sia un intero.&lt;br /&gt;
''&lt;br /&gt;
Es:base=int(base)&lt;br /&gt;
  result=int(result)''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''UPPER,LOWER,CAPITALIZE''' ==&lt;br /&gt;
&lt;br /&gt;
'''capitalize''' è un comando che sulla la stringa su cui viene applicato ,prende la prima lettera dopo gli spazi e ci mette la maiuscola&lt;br /&gt;
&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.capitalize()''&lt;br /&gt;
    ''Ciao mondo''&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.title()&lt;br /&gt;
    Ciao Mondo''&lt;br /&gt;
&lt;br /&gt;
'''LOWER:''' prende la striga e emette tutto minuscolo&lt;br /&gt;
'''UPPER:''' il contrario di lower&lt;br /&gt;
&lt;br /&gt;
== '''ESEMPIO DELLA SERATA:''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Calcolo di una potenza.&lt;br /&gt;
&lt;br /&gt;
    ''&lt;br /&gt;
    base= raw_input (“inserisce la base:”)&lt;br /&gt;
    esponente=raw_input (“inserisci l'/ esponente”)&lt;br /&gt;
&lt;br /&gt;
    base=int(base)&lt;br /&gt;
    result=int(result)&lt;br /&gt;
&lt;br /&gt;
    result=1&lt;br /&gt;
    for i in xrange(esponente):&lt;br /&gt;
         result = result * base&lt;br /&gt;
    print result''&lt;br /&gt;
&lt;br /&gt;
il [http://docs.python.org/lib/built-in-funcs.html built-in] int() è necessario, dato che tutto quello che proviene dalla tastiera viene acquisito da raw_input() come stringa. Dato che dobbiamo usarli come interi, occorre effettuare un cast, ovvero&lt;br /&gt;
una trasformazione di tipo, da stringa a intero.&lt;br /&gt;
E' interessante notare che int() non cerca di fare i miracoli: provate a vedere cosa succede se cercate di convertire &amp;quot;awlerorj&amp;quot; in int!&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3725</id>
		<title>Python Lezione 4 Giugno 2008</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3725"/>
		<updated>2008-06-06T08:11:05Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: /* '''ESEMPIO DELLA SERATA:''' */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Python ==&lt;br /&gt;
[http://www.python.it/ Python] è un linguaggio di programmazione [http://it.wikipedia.org/wiki/Interprete_(informatica) interpretato].&lt;br /&gt;
Il linuaggio interpretato è simile agli altri linguaggi in circolazione ma, invece di essere trasformato direttamente in codice binario dal meccanismo automatico, viene interpretato da questo e poi mandato all'hardware.&lt;br /&gt;
Un linguaggio interpretato non ha bisogno di essere ricompilato: il codice scritto viene interpretato da un interprete a run-time (tempo di esecuzione) e tradotto al volo nel linguaggio macchina.&lt;br /&gt;
Quindi i programmi python possono girare su qualsiasi hardware e sistema operativo su cui è stato portato l'interprete. Ovviamente, questa cosa si paga sul tempo di esecuzione pure: l'approccio ha si i suoi vantaggi, ma rispetto a un linguaggio compilato direttamente in linguaggio macchina per creare un eseguibile, python e gli altri liguaggi interpretati risultano essere più lenti.&lt;br /&gt;
&lt;br /&gt;
Esistono vari interpreti: [http://www.python.org Cpython], o classic python, è l'interprete &amp;quot;ufficiale&amp;quot;, scritto in C e disponibile per linux, mac e windows.&lt;br /&gt;
[http://www.jython.org/Project/ Jython] è un interprete scritto al 100% in Java, e si interfaccia strettamente ai programmi e alla libreria Java, &lt;br /&gt;
[http://www.codeplex.com/Wiki/View.aspx?ProjectName=IronPython IronPython] è un interprete python che gira sulla piattaforma .NET mentre &lt;br /&gt;
[http://codespeak.net/pypy/dist/pypy/doc/home.html PyPy] è (anche) un interprete python scritto in.. python&lt;br /&gt;
&lt;br /&gt;
La prima riga di ogni script python deve iniziare con &lt;br /&gt;
#!usr/bin/env python&lt;br /&gt;
&lt;br /&gt;
il #! del file fa capire al sistema operativo (solo su sistemi posix, quindi unix/linux) che quello non è un file di testo ma un eseguibile da eseguire con l'inteprete python.&lt;br /&gt;
&lt;br /&gt;
== COMMENTI ==&lt;br /&gt;
&lt;br /&gt;
: sono righe che l'interprete salta e non legge &lt;br /&gt;
es: &lt;br /&gt;
    ''# stampa:”hello word”''&lt;br /&gt;
&lt;br /&gt;
== PRINT ==&lt;br /&gt;
: è una funzione, è seguito da una stringa (una cosa tra 2 virgolete).La stringa deve essere tra virgolette in tutti i comandi, i numeri interi invece no.&lt;br /&gt;
Il punto e virgola in molti dei linguaggi di porgrammazione si mette alla fine di ogi riga, in Python si può ma un buon pitonista in genere non lo fa mai.&lt;br /&gt;
PRINT stampa l'oggetto che viene dopo.&lt;br /&gt;
Se scrivo:&lt;br /&gt;
    ''print 3''&lt;br /&gt;
se si esegue questo stampa 3&lt;br /&gt;
se scrivo&lt;br /&gt;
    '' print “3”''&lt;br /&gt;
stampa lo stesso ma in questo caso l'oggetto che si passsa è una stringa&lt;br /&gt;
se scrivo&lt;br /&gt;
    ''print 3+2''&lt;br /&gt;
scrive&lt;br /&gt;
    '' 5''&lt;br /&gt;
se scrivo&lt;br /&gt;
    ''print “3+2”''&lt;br /&gt;
lui mi dà&lt;br /&gt;
    ''3+2''&lt;br /&gt;
&lt;br /&gt;
Le variabili non importa dichiararle, basta scrivere ad un certo punto&lt;br /&gt;
    ''messaggio=”hello world”''&lt;br /&gt;
    ''print messaggio''&lt;br /&gt;
se questo programma viene eseguito il risultatato sarà:&lt;br /&gt;
''hello world''&lt;br /&gt;
l'interprete va a vedere cosa c'è dentro la variabile messaggio e stampa hello world&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== ECCEZIONE ==&lt;br /&gt;
:se io commento la definizione di messaggio (es: ''# messaggio = &amp;quot; hello world &amp;quot;'' ) il programma non sa cos'è messaggio e se scrivo:&lt;br /&gt;
    ''print &amp;quot;messaggio&amp;quot;''&lt;br /&gt;
il risultato sarà:name error, che, viene chiamato eccezione.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== LE STRINGHE ==&lt;br /&gt;
supportano molti metodi perchè sono oggetti (che è un altro nome per variabile).le stringhe sono immutabili.&lt;br /&gt;
Se una stringa viene dichiarata la seconda volta, diversamente dalla prima, quella precedente viene buttata.&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
     messaggio=”ciao mondo”&lt;br /&gt;
    print “messaggio”''&lt;br /&gt;
lui scrive&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
In Python non si possono sommare cose diverse, o meglio, lo posso fare ma mi converte il numero in stringa.per esempio &lt;br /&gt;
    ''print messaggio*2'' &lt;br /&gt;
l'esecuzione darà&lt;br /&gt;
    ''messaggio messaggio&lt;br /&gt;
''&lt;br /&gt;
esempio:&lt;br /&gt;
     ''Print “ciao”+”mondo”''&lt;br /&gt;
lo eseguo e mi darà:&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
Se si scrive python da riga di comando parte l'interprete se scriviamo roba lui l'esegue e si usa per provare le cose.per uscire premere ctrl+d.&lt;br /&gt;
&lt;br /&gt;
LE STRINGHE SONO IMMUTABILI.&lt;br /&gt;
&lt;br /&gt;
== '''Funzione DIR''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
    dir(messaggio)''&lt;br /&gt;
a questo punto il programma da una serie di caratteri incomprensibili.&lt;br /&gt;
Praticamente dà i '''metodi''' che suporta la stringa messaggio.&lt;br /&gt;
&lt;br /&gt;
== I '''metodi''' ==&lt;br /&gt;
 sono operazioni che si possono applicare alla stringa.&lt;br /&gt;
quelli che iniziano con '''__'''spesso vengono usati per scoraggiare la gente ad usarli,in quanto qui non esistono i permessi e ognuno può modificare ciò che vuole.&lt;br /&gt;
&lt;br /&gt;
Quando il metodo inizia con '''AD''' richiama l'operatore dell'addizione&lt;br /&gt;
&lt;br /&gt;
'''__ doc__''' ce l'hanno tutti gli oggetti (stringhe, interi...)&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
metodo '''IS''':&lt;br /&gt;
tutti I metodi che iniziano per is danno come risultato o vero o falso.&lt;br /&gt;
es: &lt;br /&gt;
    ''messaggio.isalpha()''&lt;br /&gt;
mi dice se messaggio è o meno alfanumerico.&lt;br /&gt;
isalpha è un oggetto quindi ha le proprietà doc .&lt;br /&gt;
se io scrivo&lt;br /&gt;
    ''messaggio.isalpa.__doc__''&lt;br /&gt;
mi dice che fa.&lt;br /&gt;
&lt;br /&gt;
Importante metto tra “ solo se è una stringa.&lt;br /&gt;
Se io definisco un oggetto con un altro oggetto con una funzione non metto “.&lt;br /&gt;
es:&lt;br /&gt;
    '' messaggio=”gigio”&lt;br /&gt;
    messaggio2= messaggio.upper()''&lt;br /&gt;
&lt;br /&gt;
es:&lt;br /&gt;
''TYPE(3)''&lt;br /&gt;
mi dice che variabile  è.se è intero o stringa.&lt;br /&gt;
Se io scrivo ''DIR(3)''&lt;br /&gt;
mi da lo stesso pappie di roba di prima.&lt;br /&gt;
'''&lt;br /&gt;
I TIPI DELLA LIBREARIA STANDARD''':sono le variabili, ci sono anche le LISTE&lt;br /&gt;
&lt;br /&gt;
Esistono stringhe, interi, float (numeri con virgola)buleano (che ha due valori, vero o falso, True e false)e i  CONTENITORI:&lt;br /&gt;
&lt;br /&gt;
== '''LE LISTE''' ==&lt;br /&gt;
&lt;br /&gt;
es. lo scaffale ha I pc, I pc sono oggetti (pc1,pc2...).Se voglio uno scaffale di pc senza dare I nomi a tutti gli oggetti, definisco lo scaffale.&lt;br /&gt;
Lo scaffale si chiama''' Lista'''  .si usano le parentesi quadre con oggetti separati da virgola&lt;br /&gt;
es.    '' a = [ “pc1” , “schermo rotto” , 2]&lt;br /&gt;
dir (scaffale)''&lt;br /&gt;
da la lista dei metodi, da qui si capisce che la lista è un oggetto.&lt;br /&gt;
Se io faccio&lt;br /&gt;
    ''b = dir (a)''&lt;br /&gt;
o&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a il 4.&lt;br /&gt;
'''la lista MUTA!'''&lt;br /&gt;
Se faccio     ''print (“a”)''&lt;br /&gt;
mi da la lista degli oggetti più il 4.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''TUPLE''' ==&lt;br /&gt;
&lt;br /&gt;
è una lista non mutabile.&lt;br /&gt;
La tupla è molto piu veloce rispetto alla lista.&lt;br /&gt;
Con tuple si usano le parentesi tonde.&lt;br /&gt;
&lt;br /&gt;
== '''DIZIONARI''' ==&lt;br /&gt;
&lt;br /&gt;
il dizionario si definisce con le parentesi graffe {chiave:valore, chiave:valore}&lt;br /&gt;
a{chiave}&lt;br /&gt;
da il valore associato alla chiave.&lt;br /&gt;
&lt;br /&gt;
Dizionari liste e tuple sono dele sequenze e sono iterable e si possono scorrere.&lt;br /&gt;
&lt;br /&gt;
== '''If elif else''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
if condizione :&lt;br /&gt;
&lt;br /&gt;
indentato roba da fare se vero.&lt;br /&gt;
&lt;br /&gt;
Python supporta o tab o spazio, si decide quanti tab o spazi alla prima indentazione.&lt;br /&gt;
Meglio lo spazio perchè in futuro I tab verranno lasciati.&lt;br /&gt;
Di solito si usa 4 spazi.&lt;br /&gt;
Non c'è la graffa in pyton o I begin o gli end, si chiude e si apre la riga solo se si indenta.&lt;br /&gt;
&lt;br /&gt;
Esempio:&lt;br /&gt;
    ''a=3&lt;br /&gt;
    b=1''&lt;br /&gt;
&lt;br /&gt;
    ''if a &amp;gt;b:&lt;br /&gt;
      print (“ a è maggiore di b”)&lt;br /&gt;
    elif a==b:&lt;br /&gt;
      print (“ a è uguale a b”)&lt;br /&gt;
    else:&lt;br /&gt;
       print(“b è maggiore di a”)''&lt;br /&gt;
&lt;br /&gt;
in questo programma definisco due valori, a e b.&lt;br /&gt;
Chiedo al programma se aè maggiore di b di scrivere : a è maggiore di b, se a è uguale a b di scrivere che a è uguale a b e in tutte le altre condizioni (else) di scrivere che a è minore di b.&lt;br /&gt;
&lt;br /&gt;
	'''2.is, is not or, and,!='''&lt;br /&gt;
    ''if a is 1:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
    elif a is not 1:&lt;br /&gt;
      print (“no”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 and b is 3:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 or b is 3:&lt;br /&gt;
      print (“okkei”)&lt;br /&gt;
''&lt;br /&gt;
&lt;br /&gt;
'''!= è il diverso.'''&lt;br /&gt;
&lt;br /&gt;
== '''append, insert''' ==&lt;br /&gt;
&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a il 4.&lt;br /&gt;
Se faccio print (“a”)&lt;br /&gt;
mi da la lista degli oggetti più il 4.&lt;br /&gt;
&lt;br /&gt;
con '''insert''' devo inserire anche la posizione&lt;br /&gt;
    ''a.insert(2,34)''&lt;br /&gt;
mette il 34 in posizione 2&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''for''' ==&lt;br /&gt;
&lt;br /&gt;
specifica un ciclo, fa le cose tante volte fino ad una condizione.&lt;br /&gt;
For variabile in una sequenza di qualche tipo.&lt;br /&gt;
Es:     ''for elemento in a:&lt;br /&gt;
               print elemento''&lt;br /&gt;
&lt;br /&gt;
es b è una tupla.&lt;br /&gt;
Allora posso scrivere:&lt;br /&gt;
    ''for elem in b&lt;br /&gt;
         print “altro elemento”&lt;br /&gt;
         “print elem”''&lt;br /&gt;
&lt;br /&gt;
elem o qualsiasi altro nome gli dia è ogni elemento dentro la tupla o lista o dizionario.&lt;br /&gt;
&lt;br /&gt;
Se io voglio sia la chiave sia il valore in un dizionario (se metto elem mi mette solo la chiave) posso fare:&lt;br /&gt;
for chiave in a:&lt;br /&gt;
	    ''print “chiave: “ + chiave&lt;br /&gt;
	    print “valore: “ + a[chiave]''&lt;br /&gt;
&lt;br /&gt;
'''DOPO I DUE PUNTI METTO SEMPRE IL TAB.'''&lt;br /&gt;
&lt;br /&gt;
== '''xrange''' ==&lt;br /&gt;
&lt;br /&gt;
xrange è un iterable di dieci elementi con il primo valore uguale a 0 .E' una lista ma non ha le proprietà di una lista.&lt;br /&gt;
se io voglio fare un for da uno a dieci (cioè la somma da uno a 10)&lt;br /&gt;
&lt;br /&gt;
es:     ''for I xrange(10)&lt;br /&gt;
               print I''&lt;br /&gt;
lui stampa&lt;br /&gt;
''1&lt;br /&gt;
2&lt;br /&gt;
3&lt;br /&gt;
4&lt;br /&gt;
5&lt;br /&gt;
6&lt;br /&gt;
7&lt;br /&gt;
8&lt;br /&gt;
9&lt;br /&gt;
10''&lt;br /&gt;
&lt;br /&gt;
== '''range''' ==&lt;br /&gt;
&lt;br /&gt;
è una lista.se io scrivo:&lt;br /&gt;
    ''print range(10)''&lt;br /&gt;
lui mi da     ''[0,1,2,3,4,5,6,7,8,9].''&lt;br /&gt;
è più lento di xrange e poi sta morendo&lt;br /&gt;
&lt;br /&gt;
== '''len''' ==&lt;br /&gt;
&lt;br /&gt;
    ''len (a)''&lt;br /&gt;
da la lunghezza della stringa&lt;br /&gt;
&lt;br /&gt;
== '''enumerate''' ==&lt;br /&gt;
&lt;br /&gt;
se io ho una lista di tre elmenti&lt;br /&gt;
''a=[“ciao”,”bel”, “mondo”]''&lt;br /&gt;
&lt;br /&gt;
''for I, elem in enumerate(a):&lt;br /&gt;
     print str(I) + “:” + elem&lt;br /&gt;
''&lt;br /&gt;
da la posizione corrente di ogni elemento.&lt;br /&gt;
''0:ciao&lt;br /&gt;
1:bel&lt;br /&gt;
2:mondo''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''raw_input''' ==&lt;br /&gt;
&lt;br /&gt;
dai il valore.&lt;br /&gt;
''Base= raw_input (“inserisce la base:”)&lt;br /&gt;
esponente=raw_input (“inserisci l'/ esponente”)''&lt;br /&gt;
&lt;br /&gt;
ti chiede il valore di base ed esponente.&lt;br /&gt;
&lt;br /&gt;
== '''Int''' ==&lt;br /&gt;
&lt;br /&gt;
forza il fatto che quel valore sia un intero.&lt;br /&gt;
''&lt;br /&gt;
Es:base=int(base)&lt;br /&gt;
  result=int(result)''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''UPPER,LOWER,CAPITALIZE''' ==&lt;br /&gt;
&lt;br /&gt;
'''capitalize''' è un comando che sulla la stringa su cui viene applicato ,prende la prima lettera dopo gli spazi e ci mette la maiuscola&lt;br /&gt;
&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.capitalize()''&lt;br /&gt;
    ''Ciao mondo''&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.title()&lt;br /&gt;
    Ciao Mondo''&lt;br /&gt;
&lt;br /&gt;
'''LOWER:''' prende la striga e emette tutto minuscolo&lt;br /&gt;
'''UPPER:''' il contrario di lower&lt;br /&gt;
&lt;br /&gt;
== '''ESEMPIO DELLA SERATA:''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Calcolo di una potenza.&lt;br /&gt;
&lt;br /&gt;
    ''Base= raw_input (“inserisce la base:”)&lt;br /&gt;
    esponente=raw_input (“inserisci l'/ esponente”)&lt;br /&gt;
&lt;br /&gt;
    base=int(base)&lt;br /&gt;
    result=int(result)&lt;br /&gt;
&lt;br /&gt;
    result=1&lt;br /&gt;
    for i in xrange(esponente):&lt;br /&gt;
         result = result * base&lt;br /&gt;
    print result''&lt;br /&gt;
&lt;br /&gt;
il [http://docs.python.org/lib/built-in-funcs.html built-in] int() è necessario, dato che tutto quello che proviene dalla tastiera viene acquisito da raw_input() come stringa. Dato che dobbiamo usarli come interi, occorre effettuare un cast, ovvero&lt;br /&gt;
una trasformazione di tipo, da stringa a intero.&lt;br /&gt;
E' interessante notare che int() non cerca di fare i miracoli: provate a vedere cosa succede se cercate di convertire &amp;quot;awlerorj&amp;quot; in int!&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3724</id>
		<title>Python Lezione 4 Giugno 2008</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3724"/>
		<updated>2008-06-06T08:09:39Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: /* '''ESEMPIO DELLA SERATA:''' */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Python ==&lt;br /&gt;
[http://www.python.it/ Python] è un linguaggio di programmazione [http://it.wikipedia.org/wiki/Interprete_(informatica) interpretato].&lt;br /&gt;
Il linuaggio interpretato è simile agli altri linguaggi in circolazione ma, invece di essere trasformato direttamente in codice binario dal meccanismo automatico, viene interpretato da questo e poi mandato all'hardware.&lt;br /&gt;
Un linguaggio interpretato non ha bisogno di essere ricompilato: il codice scritto viene interpretato da un interprete a run-time (tempo di esecuzione) e tradotto al volo nel linguaggio macchina.&lt;br /&gt;
Quindi i programmi python possono girare su qualsiasi hardware e sistema operativo su cui è stato portato l'interprete. Ovviamente, questa cosa si paga sul tempo di esecuzione pure: l'approccio ha si i suoi vantaggi, ma rispetto a un linguaggio compilato direttamente in linguaggio macchina per creare un eseguibile, python e gli altri liguaggi interpretati risultano essere più lenti.&lt;br /&gt;
&lt;br /&gt;
Esistono vari interpreti: [http://www.python.org Cpython], o classic python, è l'interprete &amp;quot;ufficiale&amp;quot;, scritto in C e disponibile per linux, mac e windows.&lt;br /&gt;
[http://www.jython.org/Project/ Jython] è un interprete scritto al 100% in Java, e si interfaccia strettamente ai programmi e alla libreria Java, &lt;br /&gt;
[http://www.codeplex.com/Wiki/View.aspx?ProjectName=IronPython IronPython] è un interprete python che gira sulla piattaforma .NET mentre &lt;br /&gt;
[http://codespeak.net/pypy/dist/pypy/doc/home.html PyPy] è (anche) un interprete python scritto in.. python&lt;br /&gt;
&lt;br /&gt;
La prima riga di ogni script python deve iniziare con &lt;br /&gt;
#!usr/bin/env python&lt;br /&gt;
&lt;br /&gt;
il #! del file fa capire al sistema operativo (solo su sistemi posix, quindi unix/linux) che quello non è un file di testo ma un eseguibile da eseguire con l'inteprete python.&lt;br /&gt;
&lt;br /&gt;
== COMMENTI ==&lt;br /&gt;
&lt;br /&gt;
: sono righe che l'interprete salta e non legge &lt;br /&gt;
es: &lt;br /&gt;
    ''# stampa:”hello word”''&lt;br /&gt;
&lt;br /&gt;
== PRINT ==&lt;br /&gt;
: è una funzione, è seguito da una stringa (una cosa tra 2 virgolete).La stringa deve essere tra virgolette in tutti i comandi, i numeri interi invece no.&lt;br /&gt;
Il punto e virgola in molti dei linguaggi di porgrammazione si mette alla fine di ogi riga, in Python si può ma un buon pitonista in genere non lo fa mai.&lt;br /&gt;
PRINT stampa l'oggetto che viene dopo.&lt;br /&gt;
Se scrivo:&lt;br /&gt;
    ''print 3''&lt;br /&gt;
se si esegue questo stampa 3&lt;br /&gt;
se scrivo&lt;br /&gt;
    '' print “3”''&lt;br /&gt;
stampa lo stesso ma in questo caso l'oggetto che si passsa è una stringa&lt;br /&gt;
se scrivo&lt;br /&gt;
    ''print 3+2''&lt;br /&gt;
scrive&lt;br /&gt;
    '' 5''&lt;br /&gt;
se scrivo&lt;br /&gt;
    ''print “3+2”''&lt;br /&gt;
lui mi dà&lt;br /&gt;
    ''3+2''&lt;br /&gt;
&lt;br /&gt;
Le variabili non importa dichiararle, basta scrivere ad un certo punto&lt;br /&gt;
    ''messaggio=”hello world”''&lt;br /&gt;
    ''print messaggio''&lt;br /&gt;
se questo programma viene eseguito il risultatato sarà:&lt;br /&gt;
''hello world''&lt;br /&gt;
l'interprete va a vedere cosa c'è dentro la variabile messaggio e stampa hello world&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== ECCEZIONE ==&lt;br /&gt;
:se io commento la definizione di messaggio (es: ''# messaggio = &amp;quot; hello world &amp;quot;'' ) il programma non sa cos'è messaggio e se scrivo:&lt;br /&gt;
    ''print &amp;quot;messaggio&amp;quot;''&lt;br /&gt;
il risultato sarà:name error, che, viene chiamato eccezione.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== LE STRINGHE ==&lt;br /&gt;
supportano molti metodi perchè sono oggetti (che è un altro nome per variabile).le stringhe sono immutabili.&lt;br /&gt;
Se una stringa viene dichiarata la seconda volta, diversamente dalla prima, quella precedente viene buttata.&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
     messaggio=”ciao mondo”&lt;br /&gt;
    print “messaggio”''&lt;br /&gt;
lui scrive&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
In Python non si possono sommare cose diverse, o meglio, lo posso fare ma mi converte il numero in stringa.per esempio &lt;br /&gt;
    ''print messaggio*2'' &lt;br /&gt;
l'esecuzione darà&lt;br /&gt;
    ''messaggio messaggio&lt;br /&gt;
''&lt;br /&gt;
esempio:&lt;br /&gt;
     ''Print “ciao”+”mondo”''&lt;br /&gt;
lo eseguo e mi darà:&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
Se si scrive python da riga di comando parte l'interprete se scriviamo roba lui l'esegue e si usa per provare le cose.per uscire premere ctrl+d.&lt;br /&gt;
&lt;br /&gt;
LE STRINGHE SONO IMMUTABILI.&lt;br /&gt;
&lt;br /&gt;
== '''Funzione DIR''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
    dir(messaggio)''&lt;br /&gt;
a questo punto il programma da una serie di caratteri incomprensibili.&lt;br /&gt;
Praticamente dà i '''metodi''' che suporta la stringa messaggio.&lt;br /&gt;
&lt;br /&gt;
== I '''metodi''' ==&lt;br /&gt;
 sono operazioni che si possono applicare alla stringa.&lt;br /&gt;
quelli che iniziano con '''__'''spesso vengono usati per scoraggiare la gente ad usarli,in quanto qui non esistono i permessi e ognuno può modificare ciò che vuole.&lt;br /&gt;
&lt;br /&gt;
Quando il metodo inizia con '''AD''' richiama l'operatore dell'addizione&lt;br /&gt;
&lt;br /&gt;
'''__ doc__''' ce l'hanno tutti gli oggetti (stringhe, interi...)&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
metodo '''IS''':&lt;br /&gt;
tutti I metodi che iniziano per is danno come risultato o vero o falso.&lt;br /&gt;
es: &lt;br /&gt;
    ''messaggio.isalpha()''&lt;br /&gt;
mi dice se messaggio è o meno alfanumerico.&lt;br /&gt;
isalpha è un oggetto quindi ha le proprietà doc .&lt;br /&gt;
se io scrivo&lt;br /&gt;
    ''messaggio.isalpa.__doc__''&lt;br /&gt;
mi dice che fa.&lt;br /&gt;
&lt;br /&gt;
Importante metto tra “ solo se è una stringa.&lt;br /&gt;
Se io definisco un oggetto con un altro oggetto con una funzione non metto “.&lt;br /&gt;
es:&lt;br /&gt;
    '' messaggio=”gigio”&lt;br /&gt;
    messaggio2= messaggio.upper()''&lt;br /&gt;
&lt;br /&gt;
es:&lt;br /&gt;
''TYPE(3)''&lt;br /&gt;
mi dice che variabile  è.se è intero o stringa.&lt;br /&gt;
Se io scrivo ''DIR(3)''&lt;br /&gt;
mi da lo stesso pappie di roba di prima.&lt;br /&gt;
'''&lt;br /&gt;
I TIPI DELLA LIBREARIA STANDARD''':sono le variabili, ci sono anche le LISTE&lt;br /&gt;
&lt;br /&gt;
Esistono stringhe, interi, float (numeri con virgola)buleano (che ha due valori, vero o falso, True e false)e i  CONTENITORI:&lt;br /&gt;
&lt;br /&gt;
== '''LE LISTE''' ==&lt;br /&gt;
&lt;br /&gt;
es. lo scaffale ha I pc, I pc sono oggetti (pc1,pc2...).Se voglio uno scaffale di pc senza dare I nomi a tutti gli oggetti, definisco lo scaffale.&lt;br /&gt;
Lo scaffale si chiama''' Lista'''  .si usano le parentesi quadre con oggetti separati da virgola&lt;br /&gt;
es.    '' a = [ “pc1” , “schermo rotto” , 2]&lt;br /&gt;
dir (scaffale)''&lt;br /&gt;
da la lista dei metodi, da qui si capisce che la lista è un oggetto.&lt;br /&gt;
Se io faccio&lt;br /&gt;
    ''b = dir (a)''&lt;br /&gt;
o&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a il 4.&lt;br /&gt;
'''la lista MUTA!'''&lt;br /&gt;
Se faccio     ''print (“a”)''&lt;br /&gt;
mi da la lista degli oggetti più il 4.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''TUPLE''' ==&lt;br /&gt;
&lt;br /&gt;
è una lista non mutabile.&lt;br /&gt;
La tupla è molto piu veloce rispetto alla lista.&lt;br /&gt;
Con tuple si usano le parentesi tonde.&lt;br /&gt;
&lt;br /&gt;
== '''DIZIONARI''' ==&lt;br /&gt;
&lt;br /&gt;
il dizionario si definisce con le parentesi graffe {chiave:valore, chiave:valore}&lt;br /&gt;
a{chiave}&lt;br /&gt;
da il valore associato alla chiave.&lt;br /&gt;
&lt;br /&gt;
Dizionari liste e tuple sono dele sequenze e sono iterable e si possono scorrere.&lt;br /&gt;
&lt;br /&gt;
== '''If elif else''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
if condizione :&lt;br /&gt;
&lt;br /&gt;
indentato roba da fare se vero.&lt;br /&gt;
&lt;br /&gt;
Python supporta o tab o spazio, si decide quanti tab o spazi alla prima indentazione.&lt;br /&gt;
Meglio lo spazio perchè in futuro I tab verranno lasciati.&lt;br /&gt;
Di solito si usa 4 spazi.&lt;br /&gt;
Non c'è la graffa in pyton o I begin o gli end, si chiude e si apre la riga solo se si indenta.&lt;br /&gt;
&lt;br /&gt;
Esempio:&lt;br /&gt;
    ''a=3&lt;br /&gt;
    b=1''&lt;br /&gt;
&lt;br /&gt;
    ''if a &amp;gt;b:&lt;br /&gt;
      print (“ a è maggiore di b”)&lt;br /&gt;
    elif a==b:&lt;br /&gt;
      print (“ a è uguale a b”)&lt;br /&gt;
    else:&lt;br /&gt;
       print(“b è maggiore di a”)''&lt;br /&gt;
&lt;br /&gt;
in questo programma definisco due valori, a e b.&lt;br /&gt;
Chiedo al programma se aè maggiore di b di scrivere : a è maggiore di b, se a è uguale a b di scrivere che a è uguale a b e in tutte le altre condizioni (else) di scrivere che a è minore di b.&lt;br /&gt;
&lt;br /&gt;
	'''2.is, is not or, and,!='''&lt;br /&gt;
    ''if a is 1:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
    elif a is not 1:&lt;br /&gt;
      print (“no”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 and b is 3:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 or b is 3:&lt;br /&gt;
      print (“okkei”)&lt;br /&gt;
''&lt;br /&gt;
&lt;br /&gt;
'''!= è il diverso.'''&lt;br /&gt;
&lt;br /&gt;
== '''append, insert''' ==&lt;br /&gt;
&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a il 4.&lt;br /&gt;
Se faccio print (“a”)&lt;br /&gt;
mi da la lista degli oggetti più il 4.&lt;br /&gt;
&lt;br /&gt;
con '''insert''' devo inserire anche la posizione&lt;br /&gt;
    ''a.insert(2,34)''&lt;br /&gt;
mette il 34 in posizione 2&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''for''' ==&lt;br /&gt;
&lt;br /&gt;
specifica un ciclo, fa le cose tante volte fino ad una condizione.&lt;br /&gt;
For variabile in una sequenza di qualche tipo.&lt;br /&gt;
Es:     ''for elemento in a:&lt;br /&gt;
               print elemento''&lt;br /&gt;
&lt;br /&gt;
es b è una tupla.&lt;br /&gt;
Allora posso scrivere:&lt;br /&gt;
    ''for elem in b&lt;br /&gt;
         print “altro elemento”&lt;br /&gt;
         “print elem”''&lt;br /&gt;
&lt;br /&gt;
elem o qualsiasi altro nome gli dia è ogni elemento dentro la tupla o lista o dizionario.&lt;br /&gt;
&lt;br /&gt;
Se io voglio sia la chiave sia il valore in un dizionario (se metto elem mi mette solo la chiave) posso fare:&lt;br /&gt;
for chiave in a:&lt;br /&gt;
	    ''print “chiave: “ + chiave&lt;br /&gt;
	    print “valore: “ + a[chiave]''&lt;br /&gt;
&lt;br /&gt;
'''DOPO I DUE PUNTI METTO SEMPRE IL TAB.'''&lt;br /&gt;
&lt;br /&gt;
== '''xrange''' ==&lt;br /&gt;
&lt;br /&gt;
xrange è un iterable di dieci elementi con il primo valore uguale a 0 .E' una lista ma non ha le proprietà di una lista.&lt;br /&gt;
se io voglio fare un for da uno a dieci (cioè la somma da uno a 10)&lt;br /&gt;
&lt;br /&gt;
es:     ''for I xrange(10)&lt;br /&gt;
               print I''&lt;br /&gt;
lui stampa&lt;br /&gt;
''1&lt;br /&gt;
2&lt;br /&gt;
3&lt;br /&gt;
4&lt;br /&gt;
5&lt;br /&gt;
6&lt;br /&gt;
7&lt;br /&gt;
8&lt;br /&gt;
9&lt;br /&gt;
10''&lt;br /&gt;
&lt;br /&gt;
== '''range''' ==&lt;br /&gt;
&lt;br /&gt;
è una lista.se io scrivo:&lt;br /&gt;
    ''print range(10)''&lt;br /&gt;
lui mi da     ''[0,1,2,3,4,5,6,7,8,9].''&lt;br /&gt;
è più lento di xrange e poi sta morendo&lt;br /&gt;
&lt;br /&gt;
== '''len''' ==&lt;br /&gt;
&lt;br /&gt;
    ''len (a)''&lt;br /&gt;
da la lunghezza della stringa&lt;br /&gt;
&lt;br /&gt;
== '''enumerate''' ==&lt;br /&gt;
&lt;br /&gt;
se io ho una lista di tre elmenti&lt;br /&gt;
''a=[“ciao”,”bel”, “mondo”]''&lt;br /&gt;
&lt;br /&gt;
''for I, elem in enumerate(a):&lt;br /&gt;
     print str(I) + “:” + elem&lt;br /&gt;
''&lt;br /&gt;
da la posizione corrente di ogni elemento.&lt;br /&gt;
''0:ciao&lt;br /&gt;
1:bel&lt;br /&gt;
2:mondo''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''raw_input''' ==&lt;br /&gt;
&lt;br /&gt;
dai il valore.&lt;br /&gt;
''Base= raw_input (“inserisce la base:”)&lt;br /&gt;
esponente=raw_input (“inserisci l'/ esponente”)''&lt;br /&gt;
&lt;br /&gt;
ti chiede il valore di base ed esponente.&lt;br /&gt;
&lt;br /&gt;
== '''Int''' ==&lt;br /&gt;
&lt;br /&gt;
forza il fatto che quel valore sia un intero.&lt;br /&gt;
''&lt;br /&gt;
Es:base=int(base)&lt;br /&gt;
  result=int(result)''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''UPPER,LOWER,CAPITALIZE''' ==&lt;br /&gt;
&lt;br /&gt;
'''capitalize''' è un comando che sulla la stringa su cui viene applicato ,prende la prima lettera dopo gli spazi e ci mette la maiuscola&lt;br /&gt;
&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.capitalize()''&lt;br /&gt;
    ''Ciao mondo''&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.title()&lt;br /&gt;
    Ciao Mondo''&lt;br /&gt;
&lt;br /&gt;
'''LOWER:''' prende la striga e emette tutto minuscolo&lt;br /&gt;
'''UPPER:''' il contrario di lower&lt;br /&gt;
&lt;br /&gt;
== '''ESEMPIO DELLA SERATA:''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Calcolo di una potenza.&lt;br /&gt;
&lt;br /&gt;
    ''Base= raw_input (“inserisce la base:”)&lt;br /&gt;
    esponente=raw_input (“inserisci l'/ esponente”)&lt;br /&gt;
&lt;br /&gt;
    base=int(base)&lt;br /&gt;
    result=int(result)&lt;br /&gt;
&lt;br /&gt;
    result=1&lt;br /&gt;
    for i in xrange(esponente):&lt;br /&gt;
         result = result * base&lt;br /&gt;
    print result''&lt;br /&gt;
&lt;br /&gt;
il built-in int() è necessario, dato che tutto quello che proviene dalla tastiera viene acquisito da raw_input() come stringa. Dato che dobbiamo usarli come interi, occorre effettuare un cast, ovvero&lt;br /&gt;
una trasformazione di tipo, da stringa a intero.&lt;br /&gt;
E' interessante notare che int() non cerca di fare i miracoli: provate a vedere cosa succede se cercate di convertire &amp;quot;awlerorj&amp;quot; in int!&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3723</id>
		<title>Python Lezione 4 Giugno 2008</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3723"/>
		<updated>2008-06-06T08:06:32Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: /* '''xrange''' */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Python ==&lt;br /&gt;
[http://www.python.it/ Python] è un linguaggio di programmazione [http://it.wikipedia.org/wiki/Interprete_(informatica) interpretato].&lt;br /&gt;
Il linuaggio interpretato è simile agli altri linguaggi in circolazione ma, invece di essere trasformato direttamente in codice binario dal meccanismo automatico, viene interpretato da questo e poi mandato all'hardware.&lt;br /&gt;
Un linguaggio interpretato non ha bisogno di essere ricompilato: il codice scritto viene interpretato da un interprete a run-time (tempo di esecuzione) e tradotto al volo nel linguaggio macchina.&lt;br /&gt;
Quindi i programmi python possono girare su qualsiasi hardware e sistema operativo su cui è stato portato l'interprete. Ovviamente, questa cosa si paga sul tempo di esecuzione pure: l'approccio ha si i suoi vantaggi, ma rispetto a un linguaggio compilato direttamente in linguaggio macchina per creare un eseguibile, python e gli altri liguaggi interpretati risultano essere più lenti.&lt;br /&gt;
&lt;br /&gt;
Esistono vari interpreti: [http://www.python.org Cpython], o classic python, è l'interprete &amp;quot;ufficiale&amp;quot;, scritto in C e disponibile per linux, mac e windows.&lt;br /&gt;
[http://www.jython.org/Project/ Jython] è un interprete scritto al 100% in Java, e si interfaccia strettamente ai programmi e alla libreria Java, &lt;br /&gt;
[http://www.codeplex.com/Wiki/View.aspx?ProjectName=IronPython IronPython] è un interprete python che gira sulla piattaforma .NET mentre &lt;br /&gt;
[http://codespeak.net/pypy/dist/pypy/doc/home.html PyPy] è (anche) un interprete python scritto in.. python&lt;br /&gt;
&lt;br /&gt;
La prima riga di ogni script python deve iniziare con &lt;br /&gt;
#!usr/bin/env python&lt;br /&gt;
&lt;br /&gt;
il #! del file fa capire al sistema operativo (solo su sistemi posix, quindi unix/linux) che quello non è un file di testo ma un eseguibile da eseguire con l'inteprete python.&lt;br /&gt;
&lt;br /&gt;
== COMMENTI ==&lt;br /&gt;
&lt;br /&gt;
: sono righe che l'interprete salta e non legge &lt;br /&gt;
es: &lt;br /&gt;
    ''# stampa:”hello word”''&lt;br /&gt;
&lt;br /&gt;
== PRINT ==&lt;br /&gt;
: è una funzione, è seguito da una stringa (una cosa tra 2 virgolete).La stringa deve essere tra virgolette in tutti i comandi, i numeri interi invece no.&lt;br /&gt;
Il punto e virgola in molti dei linguaggi di porgrammazione si mette alla fine di ogi riga, in Python si può ma un buon pitonista in genere non lo fa mai.&lt;br /&gt;
PRINT stampa l'oggetto che viene dopo.&lt;br /&gt;
Se scrivo:&lt;br /&gt;
    ''print 3''&lt;br /&gt;
se si esegue questo stampa 3&lt;br /&gt;
se scrivo&lt;br /&gt;
    '' print “3”''&lt;br /&gt;
stampa lo stesso ma in questo caso l'oggetto che si passsa è una stringa&lt;br /&gt;
se scrivo&lt;br /&gt;
    ''print 3+2''&lt;br /&gt;
scrive&lt;br /&gt;
    '' 5''&lt;br /&gt;
se scrivo&lt;br /&gt;
    ''print “3+2”''&lt;br /&gt;
lui mi dà&lt;br /&gt;
    ''3+2''&lt;br /&gt;
&lt;br /&gt;
Le variabili non importa dichiararle, basta scrivere ad un certo punto&lt;br /&gt;
    ''messaggio=”hello world”''&lt;br /&gt;
    ''print messaggio''&lt;br /&gt;
se questo programma viene eseguito il risultatato sarà:&lt;br /&gt;
''hello world''&lt;br /&gt;
l'interprete va a vedere cosa c'è dentro la variabile messaggio e stampa hello world&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== ECCEZIONE ==&lt;br /&gt;
:se io commento la definizione di messaggio (es: ''# messaggio = &amp;quot; hello world &amp;quot;'' ) il programma non sa cos'è messaggio e se scrivo:&lt;br /&gt;
    ''print &amp;quot;messaggio&amp;quot;''&lt;br /&gt;
il risultato sarà:name error, che, viene chiamato eccezione.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== LE STRINGHE ==&lt;br /&gt;
supportano molti metodi perchè sono oggetti (che è un altro nome per variabile).le stringhe sono immutabili.&lt;br /&gt;
Se una stringa viene dichiarata la seconda volta, diversamente dalla prima, quella precedente viene buttata.&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
     messaggio=”ciao mondo”&lt;br /&gt;
    print “messaggio”''&lt;br /&gt;
lui scrive&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
In Python non si possono sommare cose diverse, o meglio, lo posso fare ma mi converte il numero in stringa.per esempio &lt;br /&gt;
    ''print messaggio*2'' &lt;br /&gt;
l'esecuzione darà&lt;br /&gt;
    ''messaggio messaggio&lt;br /&gt;
''&lt;br /&gt;
esempio:&lt;br /&gt;
     ''Print “ciao”+”mondo”''&lt;br /&gt;
lo eseguo e mi darà:&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
Se si scrive python da riga di comando parte l'interprete se scriviamo roba lui l'esegue e si usa per provare le cose.per uscire premere ctrl+d.&lt;br /&gt;
&lt;br /&gt;
LE STRINGHE SONO IMMUTABILI.&lt;br /&gt;
&lt;br /&gt;
== '''Funzione DIR''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
    dir(messaggio)''&lt;br /&gt;
a questo punto il programma da una serie di caratteri incomprensibili.&lt;br /&gt;
Praticamente dà i '''metodi''' che suporta la stringa messaggio.&lt;br /&gt;
&lt;br /&gt;
== I '''metodi''' ==&lt;br /&gt;
 sono operazioni che si possono applicare alla stringa.&lt;br /&gt;
quelli che iniziano con '''__'''spesso vengono usati per scoraggiare la gente ad usarli,in quanto qui non esistono i permessi e ognuno può modificare ciò che vuole.&lt;br /&gt;
&lt;br /&gt;
Quando il metodo inizia con '''AD''' richiama l'operatore dell'addizione&lt;br /&gt;
&lt;br /&gt;
'''__ doc__''' ce l'hanno tutti gli oggetti (stringhe, interi...)&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
metodo '''IS''':&lt;br /&gt;
tutti I metodi che iniziano per is danno come risultato o vero o falso.&lt;br /&gt;
es: &lt;br /&gt;
    ''messaggio.isalpha()''&lt;br /&gt;
mi dice se messaggio è o meno alfanumerico.&lt;br /&gt;
isalpha è un oggetto quindi ha le proprietà doc .&lt;br /&gt;
se io scrivo&lt;br /&gt;
    ''messaggio.isalpa.__doc__''&lt;br /&gt;
mi dice che fa.&lt;br /&gt;
&lt;br /&gt;
Importante metto tra “ solo se è una stringa.&lt;br /&gt;
Se io definisco un oggetto con un altro oggetto con una funzione non metto “.&lt;br /&gt;
es:&lt;br /&gt;
    '' messaggio=”gigio”&lt;br /&gt;
    messaggio2= messaggio.upper()''&lt;br /&gt;
&lt;br /&gt;
es:&lt;br /&gt;
''TYPE(3)''&lt;br /&gt;
mi dice che variabile  è.se è intero o stringa.&lt;br /&gt;
Se io scrivo ''DIR(3)''&lt;br /&gt;
mi da lo stesso pappie di roba di prima.&lt;br /&gt;
'''&lt;br /&gt;
I TIPI DELLA LIBREARIA STANDARD''':sono le variabili, ci sono anche le LISTE&lt;br /&gt;
&lt;br /&gt;
Esistono stringhe, interi, float (numeri con virgola)buleano (che ha due valori, vero o falso, True e false)e i  CONTENITORI:&lt;br /&gt;
&lt;br /&gt;
== '''LE LISTE''' ==&lt;br /&gt;
&lt;br /&gt;
es. lo scaffale ha I pc, I pc sono oggetti (pc1,pc2...).Se voglio uno scaffale di pc senza dare I nomi a tutti gli oggetti, definisco lo scaffale.&lt;br /&gt;
Lo scaffale si chiama''' Lista'''  .si usano le parentesi quadre con oggetti separati da virgola&lt;br /&gt;
es.    '' a = [ “pc1” , “schermo rotto” , 2]&lt;br /&gt;
dir (scaffale)''&lt;br /&gt;
da la lista dei metodi, da qui si capisce che la lista è un oggetto.&lt;br /&gt;
Se io faccio&lt;br /&gt;
    ''b = dir (a)''&lt;br /&gt;
o&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a il 4.&lt;br /&gt;
'''la lista MUTA!'''&lt;br /&gt;
Se faccio     ''print (“a”)''&lt;br /&gt;
mi da la lista degli oggetti più il 4.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''TUPLE''' ==&lt;br /&gt;
&lt;br /&gt;
è una lista non mutabile.&lt;br /&gt;
La tupla è molto piu veloce rispetto alla lista.&lt;br /&gt;
Con tuple si usano le parentesi tonde.&lt;br /&gt;
&lt;br /&gt;
== '''DIZIONARI''' ==&lt;br /&gt;
&lt;br /&gt;
il dizionario si definisce con le parentesi graffe {chiave:valore, chiave:valore}&lt;br /&gt;
a{chiave}&lt;br /&gt;
da il valore associato alla chiave.&lt;br /&gt;
&lt;br /&gt;
Dizionari liste e tuple sono dele sequenze e sono iterable e si possono scorrere.&lt;br /&gt;
&lt;br /&gt;
== '''If elif else''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
if condizione :&lt;br /&gt;
&lt;br /&gt;
indentato roba da fare se vero.&lt;br /&gt;
&lt;br /&gt;
Python supporta o tab o spazio, si decide quanti tab o spazi alla prima indentazione.&lt;br /&gt;
Meglio lo spazio perchè in futuro I tab verranno lasciati.&lt;br /&gt;
Di solito si usa 4 spazi.&lt;br /&gt;
Non c'è la graffa in pyton o I begin o gli end, si chiude e si apre la riga solo se si indenta.&lt;br /&gt;
&lt;br /&gt;
Esempio:&lt;br /&gt;
    ''a=3&lt;br /&gt;
    b=1''&lt;br /&gt;
&lt;br /&gt;
    ''if a &amp;gt;b:&lt;br /&gt;
      print (“ a è maggiore di b”)&lt;br /&gt;
    elif a==b:&lt;br /&gt;
      print (“ a è uguale a b”)&lt;br /&gt;
    else:&lt;br /&gt;
       print(“b è maggiore di a”)''&lt;br /&gt;
&lt;br /&gt;
in questo programma definisco due valori, a e b.&lt;br /&gt;
Chiedo al programma se aè maggiore di b di scrivere : a è maggiore di b, se a è uguale a b di scrivere che a è uguale a b e in tutte le altre condizioni (else) di scrivere che a è minore di b.&lt;br /&gt;
&lt;br /&gt;
	'''2.is, is not or, and,!='''&lt;br /&gt;
    ''if a is 1:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
    elif a is not 1:&lt;br /&gt;
      print (“no”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 and b is 3:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 or b is 3:&lt;br /&gt;
      print (“okkei”)&lt;br /&gt;
''&lt;br /&gt;
&lt;br /&gt;
'''!= è il diverso.'''&lt;br /&gt;
&lt;br /&gt;
== '''append, insert''' ==&lt;br /&gt;
&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a il 4.&lt;br /&gt;
Se faccio print (“a”)&lt;br /&gt;
mi da la lista degli oggetti più il 4.&lt;br /&gt;
&lt;br /&gt;
con '''insert''' devo inserire anche la posizione&lt;br /&gt;
    ''a.insert(2,34)''&lt;br /&gt;
mette il 34 in posizione 2&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''for''' ==&lt;br /&gt;
&lt;br /&gt;
specifica un ciclo, fa le cose tante volte fino ad una condizione.&lt;br /&gt;
For variabile in una sequenza di qualche tipo.&lt;br /&gt;
Es:     ''for elemento in a:&lt;br /&gt;
               print elemento''&lt;br /&gt;
&lt;br /&gt;
es b è una tupla.&lt;br /&gt;
Allora posso scrivere:&lt;br /&gt;
    ''for elem in b&lt;br /&gt;
         print “altro elemento”&lt;br /&gt;
         “print elem”''&lt;br /&gt;
&lt;br /&gt;
elem o qualsiasi altro nome gli dia è ogni elemento dentro la tupla o lista o dizionario.&lt;br /&gt;
&lt;br /&gt;
Se io voglio sia la chiave sia il valore in un dizionario (se metto elem mi mette solo la chiave) posso fare:&lt;br /&gt;
for chiave in a:&lt;br /&gt;
	    ''print “chiave: “ + chiave&lt;br /&gt;
	    print “valore: “ + a[chiave]''&lt;br /&gt;
&lt;br /&gt;
'''DOPO I DUE PUNTI METTO SEMPRE IL TAB.'''&lt;br /&gt;
&lt;br /&gt;
== '''xrange''' ==&lt;br /&gt;
&lt;br /&gt;
xrange è un iterable di dieci elementi con il primo valore uguale a 0 .E' una lista ma non ha le proprietà di una lista.&lt;br /&gt;
se io voglio fare un for da uno a dieci (cioè la somma da uno a 10)&lt;br /&gt;
&lt;br /&gt;
es:     ''for I xrange(10)&lt;br /&gt;
               print I''&lt;br /&gt;
lui stampa&lt;br /&gt;
''1&lt;br /&gt;
2&lt;br /&gt;
3&lt;br /&gt;
4&lt;br /&gt;
5&lt;br /&gt;
6&lt;br /&gt;
7&lt;br /&gt;
8&lt;br /&gt;
9&lt;br /&gt;
10''&lt;br /&gt;
&lt;br /&gt;
== '''range''' ==&lt;br /&gt;
&lt;br /&gt;
è una lista.se io scrivo:&lt;br /&gt;
    ''print range(10)''&lt;br /&gt;
lui mi da     ''[0,1,2,3,4,5,6,7,8,9].''&lt;br /&gt;
è più lento di xrange e poi sta morendo&lt;br /&gt;
&lt;br /&gt;
== '''len''' ==&lt;br /&gt;
&lt;br /&gt;
    ''len (a)''&lt;br /&gt;
da la lunghezza della stringa&lt;br /&gt;
&lt;br /&gt;
== '''enumerate''' ==&lt;br /&gt;
&lt;br /&gt;
se io ho una lista di tre elmenti&lt;br /&gt;
''a=[“ciao”,”bel”, “mondo”]''&lt;br /&gt;
&lt;br /&gt;
''for I, elem in enumerate(a):&lt;br /&gt;
     print str(I) + “:” + elem&lt;br /&gt;
''&lt;br /&gt;
da la posizione corrente di ogni elemento.&lt;br /&gt;
''0:ciao&lt;br /&gt;
1:bel&lt;br /&gt;
2:mondo''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''raw_input''' ==&lt;br /&gt;
&lt;br /&gt;
dai il valore.&lt;br /&gt;
''Base= raw_input (“inserisce la base:”)&lt;br /&gt;
esponente=raw_input (“inserisci l'/ esponente”)''&lt;br /&gt;
&lt;br /&gt;
ti chiede il valore di base ed esponente.&lt;br /&gt;
&lt;br /&gt;
== '''Int''' ==&lt;br /&gt;
&lt;br /&gt;
forza il fatto che quel valore sia un intero.&lt;br /&gt;
''&lt;br /&gt;
Es:base=int(base)&lt;br /&gt;
  result=int(result)''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''UPPER,LOWER,CAPITALIZE''' ==&lt;br /&gt;
&lt;br /&gt;
'''capitalize''' è un comando che sulla la stringa su cui viene applicato ,prende la prima lettera dopo gli spazi e ci mette la maiuscola&lt;br /&gt;
&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.capitalize()''&lt;br /&gt;
    ''Ciao mondo''&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.title()&lt;br /&gt;
    Ciao Mondo''&lt;br /&gt;
&lt;br /&gt;
'''LOWER:''' prende la striga e emette tutto minuscolo&lt;br /&gt;
'''UPPER:''' il contrario di lower&lt;br /&gt;
&lt;br /&gt;
== '''ESEMPIO DELLA SERATA:''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Calcolo di una potenza.&lt;br /&gt;
&lt;br /&gt;
    ''Base= raw_input (“inserisce la base:”)&lt;br /&gt;
    esponente=raw_input (“inserisci l'/ esponente”)&lt;br /&gt;
&lt;br /&gt;
    base=int(base)&lt;br /&gt;
    result=int(result)&lt;br /&gt;
&lt;br /&gt;
    result=1&lt;br /&gt;
    for i in xrange(esponente):&lt;br /&gt;
    result = result * base&lt;br /&gt;
    print result''&lt;br /&gt;
&lt;br /&gt;
l'operatore int forza il fatto che l'operatore deve essere un intero, lo dobbiamo scrivere, altrimenti non funziona perchè lui lo vede come stringa&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3722</id>
		<title>Python Lezione 4 Giugno 2008</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3722"/>
		<updated>2008-06-06T08:06:01Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: /* Python */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Python ==&lt;br /&gt;
[http://www.python.it/ Python] è un linguaggio di programmazione [http://it.wikipedia.org/wiki/Interprete_(informatica) interpretato].&lt;br /&gt;
Il linuaggio interpretato è simile agli altri linguaggi in circolazione ma, invece di essere trasformato direttamente in codice binario dal meccanismo automatico, viene interpretato da questo e poi mandato all'hardware.&lt;br /&gt;
Un linguaggio interpretato non ha bisogno di essere ricompilato: il codice scritto viene interpretato da un interprete a run-time (tempo di esecuzione) e tradotto al volo nel linguaggio macchina.&lt;br /&gt;
Quindi i programmi python possono girare su qualsiasi hardware e sistema operativo su cui è stato portato l'interprete. Ovviamente, questa cosa si paga sul tempo di esecuzione pure: l'approccio ha si i suoi vantaggi, ma rispetto a un linguaggio compilato direttamente in linguaggio macchina per creare un eseguibile, python e gli altri liguaggi interpretati risultano essere più lenti.&lt;br /&gt;
&lt;br /&gt;
Esistono vari interpreti: [http://www.python.org Cpython], o classic python, è l'interprete &amp;quot;ufficiale&amp;quot;, scritto in C e disponibile per linux, mac e windows.&lt;br /&gt;
[http://www.jython.org/Project/ Jython] è un interprete scritto al 100% in Java, e si interfaccia strettamente ai programmi e alla libreria Java, &lt;br /&gt;
[http://www.codeplex.com/Wiki/View.aspx?ProjectName=IronPython IronPython] è un interprete python che gira sulla piattaforma .NET mentre &lt;br /&gt;
[http://codespeak.net/pypy/dist/pypy/doc/home.html PyPy] è (anche) un interprete python scritto in.. python&lt;br /&gt;
&lt;br /&gt;
La prima riga di ogni script python deve iniziare con &lt;br /&gt;
#!usr/bin/env python&lt;br /&gt;
&lt;br /&gt;
il #! del file fa capire al sistema operativo (solo su sistemi posix, quindi unix/linux) che quello non è un file di testo ma un eseguibile da eseguire con l'inteprete python.&lt;br /&gt;
&lt;br /&gt;
== COMMENTI ==&lt;br /&gt;
&lt;br /&gt;
: sono righe che l'interprete salta e non legge &lt;br /&gt;
es: &lt;br /&gt;
    ''# stampa:”hello word”''&lt;br /&gt;
&lt;br /&gt;
== PRINT ==&lt;br /&gt;
: è una funzione, è seguito da una stringa (una cosa tra 2 virgolete).La stringa deve essere tra virgolette in tutti i comandi, i numeri interi invece no.&lt;br /&gt;
Il punto e virgola in molti dei linguaggi di porgrammazione si mette alla fine di ogi riga, in Python si può ma un buon pitonista in genere non lo fa mai.&lt;br /&gt;
PRINT stampa l'oggetto che viene dopo.&lt;br /&gt;
Se scrivo:&lt;br /&gt;
    ''print 3''&lt;br /&gt;
se si esegue questo stampa 3&lt;br /&gt;
se scrivo&lt;br /&gt;
    '' print “3”''&lt;br /&gt;
stampa lo stesso ma in questo caso l'oggetto che si passsa è una stringa&lt;br /&gt;
se scrivo&lt;br /&gt;
    ''print 3+2''&lt;br /&gt;
scrive&lt;br /&gt;
    '' 5''&lt;br /&gt;
se scrivo&lt;br /&gt;
    ''print “3+2”''&lt;br /&gt;
lui mi dà&lt;br /&gt;
    ''3+2''&lt;br /&gt;
&lt;br /&gt;
Le variabili non importa dichiararle, basta scrivere ad un certo punto&lt;br /&gt;
    ''messaggio=”hello world”''&lt;br /&gt;
    ''print messaggio''&lt;br /&gt;
se questo programma viene eseguito il risultatato sarà:&lt;br /&gt;
''hello world''&lt;br /&gt;
l'interprete va a vedere cosa c'è dentro la variabile messaggio e stampa hello world&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== ECCEZIONE ==&lt;br /&gt;
:se io commento la definizione di messaggio (es: ''# messaggio = &amp;quot; hello world &amp;quot;'' ) il programma non sa cos'è messaggio e se scrivo:&lt;br /&gt;
    ''print &amp;quot;messaggio&amp;quot;''&lt;br /&gt;
il risultato sarà:name error, che, viene chiamato eccezione.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== LE STRINGHE ==&lt;br /&gt;
supportano molti metodi perchè sono oggetti (che è un altro nome per variabile).le stringhe sono immutabili.&lt;br /&gt;
Se una stringa viene dichiarata la seconda volta, diversamente dalla prima, quella precedente viene buttata.&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
     messaggio=”ciao mondo”&lt;br /&gt;
    print “messaggio”''&lt;br /&gt;
lui scrive&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
In Python non si possono sommare cose diverse, o meglio, lo posso fare ma mi converte il numero in stringa.per esempio &lt;br /&gt;
    ''print messaggio*2'' &lt;br /&gt;
l'esecuzione darà&lt;br /&gt;
    ''messaggio messaggio&lt;br /&gt;
''&lt;br /&gt;
esempio:&lt;br /&gt;
     ''Print “ciao”+”mondo”''&lt;br /&gt;
lo eseguo e mi darà:&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
Se si scrive python da riga di comando parte l'interprete se scriviamo roba lui l'esegue e si usa per provare le cose.per uscire premere ctrl+d.&lt;br /&gt;
&lt;br /&gt;
LE STRINGHE SONO IMMUTABILI.&lt;br /&gt;
&lt;br /&gt;
== '''Funzione DIR''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
    dir(messaggio)''&lt;br /&gt;
a questo punto il programma da una serie di caratteri incomprensibili.&lt;br /&gt;
Praticamente dà i '''metodi''' che suporta la stringa messaggio.&lt;br /&gt;
&lt;br /&gt;
== I '''metodi''' ==&lt;br /&gt;
 sono operazioni che si possono applicare alla stringa.&lt;br /&gt;
quelli che iniziano con '''__'''spesso vengono usati per scoraggiare la gente ad usarli,in quanto qui non esistono i permessi e ognuno può modificare ciò che vuole.&lt;br /&gt;
&lt;br /&gt;
Quando il metodo inizia con '''AD''' richiama l'operatore dell'addizione&lt;br /&gt;
&lt;br /&gt;
'''__ doc__''' ce l'hanno tutti gli oggetti (stringhe, interi...)&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
metodo '''IS''':&lt;br /&gt;
tutti I metodi che iniziano per is danno come risultato o vero o falso.&lt;br /&gt;
es: &lt;br /&gt;
    ''messaggio.isalpha()''&lt;br /&gt;
mi dice se messaggio è o meno alfanumerico.&lt;br /&gt;
isalpha è un oggetto quindi ha le proprietà doc .&lt;br /&gt;
se io scrivo&lt;br /&gt;
    ''messaggio.isalpa.__doc__''&lt;br /&gt;
mi dice che fa.&lt;br /&gt;
&lt;br /&gt;
Importante metto tra “ solo se è una stringa.&lt;br /&gt;
Se io definisco un oggetto con un altro oggetto con una funzione non metto “.&lt;br /&gt;
es:&lt;br /&gt;
    '' messaggio=”gigio”&lt;br /&gt;
    messaggio2= messaggio.upper()''&lt;br /&gt;
&lt;br /&gt;
es:&lt;br /&gt;
''TYPE(3)''&lt;br /&gt;
mi dice che variabile  è.se è intero o stringa.&lt;br /&gt;
Se io scrivo ''DIR(3)''&lt;br /&gt;
mi da lo stesso pappie di roba di prima.&lt;br /&gt;
'''&lt;br /&gt;
I TIPI DELLA LIBREARIA STANDARD''':sono le variabili, ci sono anche le LISTE&lt;br /&gt;
&lt;br /&gt;
Esistono stringhe, interi, float (numeri con virgola)buleano (che ha due valori, vero o falso, True e false)e i  CONTENITORI:&lt;br /&gt;
&lt;br /&gt;
== '''LE LISTE''' ==&lt;br /&gt;
&lt;br /&gt;
es. lo scaffale ha I pc, I pc sono oggetti (pc1,pc2...).Se voglio uno scaffale di pc senza dare I nomi a tutti gli oggetti, definisco lo scaffale.&lt;br /&gt;
Lo scaffale si chiama''' Lista'''  .si usano le parentesi quadre con oggetti separati da virgola&lt;br /&gt;
es.    '' a = [ “pc1” , “schermo rotto” , 2]&lt;br /&gt;
dir (scaffale)''&lt;br /&gt;
da la lista dei metodi, da qui si capisce che la lista è un oggetto.&lt;br /&gt;
Se io faccio&lt;br /&gt;
    ''b = dir (a)''&lt;br /&gt;
o&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a il 4.&lt;br /&gt;
'''la lista MUTA!'''&lt;br /&gt;
Se faccio     ''print (“a”)''&lt;br /&gt;
mi da la lista degli oggetti più il 4.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''TUPLE''' ==&lt;br /&gt;
&lt;br /&gt;
è una lista non mutabile.&lt;br /&gt;
La tupla è molto piu veloce rispetto alla lista.&lt;br /&gt;
Con tuple si usano le parentesi tonde.&lt;br /&gt;
&lt;br /&gt;
== '''DIZIONARI''' ==&lt;br /&gt;
&lt;br /&gt;
il dizionario si definisce con le parentesi graffe {chiave:valore, chiave:valore}&lt;br /&gt;
a{chiave}&lt;br /&gt;
da il valore associato alla chiave.&lt;br /&gt;
&lt;br /&gt;
Dizionari liste e tuple sono dele sequenze e sono iterable e si possono scorrere.&lt;br /&gt;
&lt;br /&gt;
== '''If elif else''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
if condizione :&lt;br /&gt;
&lt;br /&gt;
indentato roba da fare se vero.&lt;br /&gt;
&lt;br /&gt;
Python supporta o tab o spazio, si decide quanti tab o spazi alla prima indentazione.&lt;br /&gt;
Meglio lo spazio perchè in futuro I tab verranno lasciati.&lt;br /&gt;
Di solito si usa 4 spazi.&lt;br /&gt;
Non c'è la graffa in pyton o I begin o gli end, si chiude e si apre la riga solo se si indenta.&lt;br /&gt;
&lt;br /&gt;
Esempio:&lt;br /&gt;
    ''a=3&lt;br /&gt;
    b=1''&lt;br /&gt;
&lt;br /&gt;
    ''if a &amp;gt;b:&lt;br /&gt;
      print (“ a è maggiore di b”)&lt;br /&gt;
    elif a==b:&lt;br /&gt;
      print (“ a è uguale a b”)&lt;br /&gt;
    else:&lt;br /&gt;
       print(“b è maggiore di a”)''&lt;br /&gt;
&lt;br /&gt;
in questo programma definisco due valori, a e b.&lt;br /&gt;
Chiedo al programma se aè maggiore di b di scrivere : a è maggiore di b, se a è uguale a b di scrivere che a è uguale a b e in tutte le altre condizioni (else) di scrivere che a è minore di b.&lt;br /&gt;
&lt;br /&gt;
	'''2.is, is not or, and,!='''&lt;br /&gt;
    ''if a is 1:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
    elif a is not 1:&lt;br /&gt;
      print (“no”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 and b is 3:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 or b is 3:&lt;br /&gt;
      print (“okkei”)&lt;br /&gt;
''&lt;br /&gt;
&lt;br /&gt;
'''!= è il diverso.'''&lt;br /&gt;
&lt;br /&gt;
== '''append, insert''' ==&lt;br /&gt;
&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a il 4.&lt;br /&gt;
Se faccio print (“a”)&lt;br /&gt;
mi da la lista degli oggetti più il 4.&lt;br /&gt;
&lt;br /&gt;
con '''insert''' devo inserire anche la posizione&lt;br /&gt;
    ''a.insert(2,34)''&lt;br /&gt;
mette il 34 in posizione 2&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''for''' ==&lt;br /&gt;
&lt;br /&gt;
specifica un ciclo, fa le cose tante volte fino ad una condizione.&lt;br /&gt;
For variabile in una sequenza di qualche tipo.&lt;br /&gt;
Es:     ''for elemento in a:&lt;br /&gt;
               print elemento''&lt;br /&gt;
&lt;br /&gt;
es b è una tupla.&lt;br /&gt;
Allora posso scrivere:&lt;br /&gt;
    ''for elem in b&lt;br /&gt;
         print “altro elemento”&lt;br /&gt;
         “print elem”''&lt;br /&gt;
&lt;br /&gt;
elem o qualsiasi altro nome gli dia è ogni elemento dentro la tupla o lista o dizionario.&lt;br /&gt;
&lt;br /&gt;
Se io voglio sia la chiave sia il valore in un dizionario (se metto elem mi mette solo la chiave) posso fare:&lt;br /&gt;
for chiave in a:&lt;br /&gt;
	    ''print “chiave: “ + chiave&lt;br /&gt;
	    print “valore: “ + a[chiave]''&lt;br /&gt;
&lt;br /&gt;
'''DOPO I DUE PUNTI METTO SEMPRE IL TAB.'''&lt;br /&gt;
&lt;br /&gt;
== '''xrange''' ==&lt;br /&gt;
&lt;br /&gt;
xrange è un iterable di dieci elementi con il primo valore uguale a 0 .E' una lista ma non ha le proprietà di una lista.&lt;br /&gt;
se io voglio fare un for da uno a dieci (cioè la somma da uno a 10)&lt;br /&gt;
&lt;br /&gt;
es:     ''for I xrange(10)&lt;br /&gt;
               print I''&lt;br /&gt;
lui stampa&lt;br /&gt;
''1&lt;br /&gt;
2&lt;br /&gt;
3&lt;br /&gt;
4&lt;br /&gt;
5&lt;br /&gt;
6&lt;br /&gt;
7&lt;br /&gt;
8&lt;br /&gt;
9&lt;br /&gt;
10''&lt;br /&gt;
xrange vale solo per for.&lt;br /&gt;
&lt;br /&gt;
== '''range''' ==&lt;br /&gt;
&lt;br /&gt;
è una lista.se io scrivo:&lt;br /&gt;
    ''print range(10)''&lt;br /&gt;
lui mi da     ''[0,1,2,3,4,5,6,7,8,9].''&lt;br /&gt;
è più lento di xrange e poi sta morendo&lt;br /&gt;
&lt;br /&gt;
== '''len''' ==&lt;br /&gt;
&lt;br /&gt;
    ''len (a)''&lt;br /&gt;
da la lunghezza della stringa&lt;br /&gt;
&lt;br /&gt;
== '''enumerate''' ==&lt;br /&gt;
&lt;br /&gt;
se io ho una lista di tre elmenti&lt;br /&gt;
''a=[“ciao”,”bel”, “mondo”]''&lt;br /&gt;
&lt;br /&gt;
''for I, elem in enumerate(a):&lt;br /&gt;
     print str(I) + “:” + elem&lt;br /&gt;
''&lt;br /&gt;
da la posizione corrente di ogni elemento.&lt;br /&gt;
''0:ciao&lt;br /&gt;
1:bel&lt;br /&gt;
2:mondo''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''raw_input''' ==&lt;br /&gt;
&lt;br /&gt;
dai il valore.&lt;br /&gt;
''Base= raw_input (“inserisce la base:”)&lt;br /&gt;
esponente=raw_input (“inserisci l'/ esponente”)''&lt;br /&gt;
&lt;br /&gt;
ti chiede il valore di base ed esponente.&lt;br /&gt;
&lt;br /&gt;
== '''Int''' ==&lt;br /&gt;
&lt;br /&gt;
forza il fatto che quel valore sia un intero.&lt;br /&gt;
''&lt;br /&gt;
Es:base=int(base)&lt;br /&gt;
  result=int(result)''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''UPPER,LOWER,CAPITALIZE''' ==&lt;br /&gt;
&lt;br /&gt;
'''capitalize''' è un comando che sulla la stringa su cui viene applicato ,prende la prima lettera dopo gli spazi e ci mette la maiuscola&lt;br /&gt;
&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.capitalize()''&lt;br /&gt;
    ''Ciao mondo''&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.title()&lt;br /&gt;
    Ciao Mondo''&lt;br /&gt;
&lt;br /&gt;
'''LOWER:''' prende la striga e emette tutto minuscolo&lt;br /&gt;
'''UPPER:''' il contrario di lower&lt;br /&gt;
&lt;br /&gt;
== '''ESEMPIO DELLA SERATA:''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Calcolo di una potenza.&lt;br /&gt;
&lt;br /&gt;
    ''Base= raw_input (“inserisce la base:”)&lt;br /&gt;
    esponente=raw_input (“inserisci l'/ esponente”)&lt;br /&gt;
&lt;br /&gt;
    base=int(base)&lt;br /&gt;
    result=int(result)&lt;br /&gt;
&lt;br /&gt;
    result=1&lt;br /&gt;
    for i in xrange(esponente):&lt;br /&gt;
    result = result * base&lt;br /&gt;
    print result''&lt;br /&gt;
&lt;br /&gt;
l'operatore int forza il fatto che l'operatore deve essere un intero, lo dobbiamo scrivere, altrimenti non funziona perchè lui lo vede come stringa&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3721</id>
		<title>Python Lezione 4 Giugno 2008</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3721"/>
		<updated>2008-06-06T08:05:26Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: /* Python */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Python ==&lt;br /&gt;
[http://www.python.it/ Python] è un linguaggio di programmazione [http://it.wikipedia.org/wiki/Interprete_(informatica) interpretato].&lt;br /&gt;
Il linuaggio interpretato è simile agli altri linguaggi in circolazione ma, invece di essere trasformato direttamente in codice binario dal meccanismo automatico, viene interpretato da questo e poi mandato all'hardware.&lt;br /&gt;
Un linguaggio interpretato non ha bisogno di essere ricompilato: il codice scritto viene interpretato da un interprete a run-time (tempo di esecuzione) e tradotto al volo nel linguaggio macchina.&lt;br /&gt;
Quindi i programmi python possono girare su qualsiasi hardware e sistema operativo su cui è stato portato l'interprete. Ovviamente, questa cosa si paga sul tempo di esecuzione pure: l'approccio ha si i suoi vantaggi, ma rispetto a un linguaggio compilato direttamente in linguaggio macchina per creare un eseguibile, python e gli altri liguaggi interpretati risultano essere più lenti.&lt;br /&gt;
&lt;br /&gt;
Esistono vari interpreti: [http://www.python.org Cpython], o classic python, è l'interprete &amp;quot;ufficiale&amp;quot;, scritto in C e disponibile per linux, mac e windows.&lt;br /&gt;
[http://www.jython.org/Project/ Jython] è un interprete scritto al 100% in Java, e si interfaccia strettamente ai programmi e alla libreria Java&lt;br /&gt;
[http://www.codeplex.com/Wiki/View.aspx?ProjectName=IronPython IronPython] è un interprete python che gira sulla piattaforma .NET&lt;br /&gt;
[http://codespeak.net/pypy/dist/pypy/doc/home.html PyPy] è (anche) un interprete python scritto in.. python&lt;br /&gt;
&lt;br /&gt;
La prima riga di ogni script python deve iniziare con &lt;br /&gt;
#!usr/bin/env python&lt;br /&gt;
&lt;br /&gt;
il #! del file fa capire al sistema operativo (solo su sistemi posix, quindi unix/linux) che quello non è un file di testo ma un eseguibile da eseguire con l'inteprete python.&lt;br /&gt;
&lt;br /&gt;
== COMMENTI ==&lt;br /&gt;
&lt;br /&gt;
: sono righe che l'interprete salta e non legge &lt;br /&gt;
es: &lt;br /&gt;
    ''# stampa:”hello word”''&lt;br /&gt;
&lt;br /&gt;
== PRINT ==&lt;br /&gt;
: è una funzione, è seguito da una stringa (una cosa tra 2 virgolete).La stringa deve essere tra virgolette in tutti i comandi, i numeri interi invece no.&lt;br /&gt;
Il punto e virgola in molti dei linguaggi di porgrammazione si mette alla fine di ogi riga, in Python si può ma un buon pitonista in genere non lo fa mai.&lt;br /&gt;
PRINT stampa l'oggetto che viene dopo.&lt;br /&gt;
Se scrivo:&lt;br /&gt;
    ''print 3''&lt;br /&gt;
se si esegue questo stampa 3&lt;br /&gt;
se scrivo&lt;br /&gt;
    '' print “3”''&lt;br /&gt;
stampa lo stesso ma in questo caso l'oggetto che si passsa è una stringa&lt;br /&gt;
se scrivo&lt;br /&gt;
    ''print 3+2''&lt;br /&gt;
scrive&lt;br /&gt;
    '' 5''&lt;br /&gt;
se scrivo&lt;br /&gt;
    ''print “3+2”''&lt;br /&gt;
lui mi dà&lt;br /&gt;
    ''3+2''&lt;br /&gt;
&lt;br /&gt;
Le variabili non importa dichiararle, basta scrivere ad un certo punto&lt;br /&gt;
    ''messaggio=”hello world”''&lt;br /&gt;
    ''print messaggio''&lt;br /&gt;
se questo programma viene eseguito il risultatato sarà:&lt;br /&gt;
''hello world''&lt;br /&gt;
l'interprete va a vedere cosa c'è dentro la variabile messaggio e stampa hello world&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== ECCEZIONE ==&lt;br /&gt;
:se io commento la definizione di messaggio (es: ''# messaggio = &amp;quot; hello world &amp;quot;'' ) il programma non sa cos'è messaggio e se scrivo:&lt;br /&gt;
    ''print &amp;quot;messaggio&amp;quot;''&lt;br /&gt;
il risultato sarà:name error, che, viene chiamato eccezione.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== LE STRINGHE ==&lt;br /&gt;
supportano molti metodi perchè sono oggetti (che è un altro nome per variabile).le stringhe sono immutabili.&lt;br /&gt;
Se una stringa viene dichiarata la seconda volta, diversamente dalla prima, quella precedente viene buttata.&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
     messaggio=”ciao mondo”&lt;br /&gt;
    print “messaggio”''&lt;br /&gt;
lui scrive&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
In Python non si possono sommare cose diverse, o meglio, lo posso fare ma mi converte il numero in stringa.per esempio &lt;br /&gt;
    ''print messaggio*2'' &lt;br /&gt;
l'esecuzione darà&lt;br /&gt;
    ''messaggio messaggio&lt;br /&gt;
''&lt;br /&gt;
esempio:&lt;br /&gt;
     ''Print “ciao”+”mondo”''&lt;br /&gt;
lo eseguo e mi darà:&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
Se si scrive python da riga di comando parte l'interprete se scriviamo roba lui l'esegue e si usa per provare le cose.per uscire premere ctrl+d.&lt;br /&gt;
&lt;br /&gt;
LE STRINGHE SONO IMMUTABILI.&lt;br /&gt;
&lt;br /&gt;
== '''Funzione DIR''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
    dir(messaggio)''&lt;br /&gt;
a questo punto il programma da una serie di caratteri incomprensibili.&lt;br /&gt;
Praticamente dà i '''metodi''' che suporta la stringa messaggio.&lt;br /&gt;
&lt;br /&gt;
== I '''metodi''' ==&lt;br /&gt;
 sono operazioni che si possono applicare alla stringa.&lt;br /&gt;
quelli che iniziano con '''__'''spesso vengono usati per scoraggiare la gente ad usarli,in quanto qui non esistono i permessi e ognuno può modificare ciò che vuole.&lt;br /&gt;
&lt;br /&gt;
Quando il metodo inizia con '''AD''' richiama l'operatore dell'addizione&lt;br /&gt;
&lt;br /&gt;
'''__ doc__''' ce l'hanno tutti gli oggetti (stringhe, interi...)&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
metodo '''IS''':&lt;br /&gt;
tutti I metodi che iniziano per is danno come risultato o vero o falso.&lt;br /&gt;
es: &lt;br /&gt;
    ''messaggio.isalpha()''&lt;br /&gt;
mi dice se messaggio è o meno alfanumerico.&lt;br /&gt;
isalpha è un oggetto quindi ha le proprietà doc .&lt;br /&gt;
se io scrivo&lt;br /&gt;
    ''messaggio.isalpa.__doc__''&lt;br /&gt;
mi dice che fa.&lt;br /&gt;
&lt;br /&gt;
Importante metto tra “ solo se è una stringa.&lt;br /&gt;
Se io definisco un oggetto con un altro oggetto con una funzione non metto “.&lt;br /&gt;
es:&lt;br /&gt;
    '' messaggio=”gigio”&lt;br /&gt;
    messaggio2= messaggio.upper()''&lt;br /&gt;
&lt;br /&gt;
es:&lt;br /&gt;
''TYPE(3)''&lt;br /&gt;
mi dice che variabile  è.se è intero o stringa.&lt;br /&gt;
Se io scrivo ''DIR(3)''&lt;br /&gt;
mi da lo stesso pappie di roba di prima.&lt;br /&gt;
'''&lt;br /&gt;
I TIPI DELLA LIBREARIA STANDARD''':sono le variabili, ci sono anche le LISTE&lt;br /&gt;
&lt;br /&gt;
Esistono stringhe, interi, float (numeri con virgola)buleano (che ha due valori, vero o falso, True e false)e i  CONTENITORI:&lt;br /&gt;
&lt;br /&gt;
== '''LE LISTE''' ==&lt;br /&gt;
&lt;br /&gt;
es. lo scaffale ha I pc, I pc sono oggetti (pc1,pc2...).Se voglio uno scaffale di pc senza dare I nomi a tutti gli oggetti, definisco lo scaffale.&lt;br /&gt;
Lo scaffale si chiama''' Lista'''  .si usano le parentesi quadre con oggetti separati da virgola&lt;br /&gt;
es.    '' a = [ “pc1” , “schermo rotto” , 2]&lt;br /&gt;
dir (scaffale)''&lt;br /&gt;
da la lista dei metodi, da qui si capisce che la lista è un oggetto.&lt;br /&gt;
Se io faccio&lt;br /&gt;
    ''b = dir (a)''&lt;br /&gt;
o&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a il 4.&lt;br /&gt;
'''la lista MUTA!'''&lt;br /&gt;
Se faccio     ''print (“a”)''&lt;br /&gt;
mi da la lista degli oggetti più il 4.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''TUPLE''' ==&lt;br /&gt;
&lt;br /&gt;
è una lista non mutabile.&lt;br /&gt;
La tupla è molto piu veloce rispetto alla lista.&lt;br /&gt;
Con tuple si usano le parentesi tonde.&lt;br /&gt;
&lt;br /&gt;
== '''DIZIONARI''' ==&lt;br /&gt;
&lt;br /&gt;
il dizionario si definisce con le parentesi graffe {chiave:valore, chiave:valore}&lt;br /&gt;
a{chiave}&lt;br /&gt;
da il valore associato alla chiave.&lt;br /&gt;
&lt;br /&gt;
Dizionari liste e tuple sono dele sequenze e sono iterable e si possono scorrere.&lt;br /&gt;
&lt;br /&gt;
== '''If elif else''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
if condizione :&lt;br /&gt;
&lt;br /&gt;
indentato roba da fare se vero.&lt;br /&gt;
&lt;br /&gt;
Python supporta o tab o spazio, si decide quanti tab o spazi alla prima indentazione.&lt;br /&gt;
Meglio lo spazio perchè in futuro I tab verranno lasciati.&lt;br /&gt;
Di solito si usa 4 spazi.&lt;br /&gt;
Non c'è la graffa in pyton o I begin o gli end, si chiude e si apre la riga solo se si indenta.&lt;br /&gt;
&lt;br /&gt;
Esempio:&lt;br /&gt;
    ''a=3&lt;br /&gt;
    b=1''&lt;br /&gt;
&lt;br /&gt;
    ''if a &amp;gt;b:&lt;br /&gt;
      print (“ a è maggiore di b”)&lt;br /&gt;
    elif a==b:&lt;br /&gt;
      print (“ a è uguale a b”)&lt;br /&gt;
    else:&lt;br /&gt;
       print(“b è maggiore di a”)''&lt;br /&gt;
&lt;br /&gt;
in questo programma definisco due valori, a e b.&lt;br /&gt;
Chiedo al programma se aè maggiore di b di scrivere : a è maggiore di b, se a è uguale a b di scrivere che a è uguale a b e in tutte le altre condizioni (else) di scrivere che a è minore di b.&lt;br /&gt;
&lt;br /&gt;
	'''2.is, is not or, and,!='''&lt;br /&gt;
    ''if a is 1:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
    elif a is not 1:&lt;br /&gt;
      print (“no”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 and b is 3:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 or b is 3:&lt;br /&gt;
      print (“okkei”)&lt;br /&gt;
''&lt;br /&gt;
&lt;br /&gt;
'''!= è il diverso.'''&lt;br /&gt;
&lt;br /&gt;
== '''append, insert''' ==&lt;br /&gt;
&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a il 4.&lt;br /&gt;
Se faccio print (“a”)&lt;br /&gt;
mi da la lista degli oggetti più il 4.&lt;br /&gt;
&lt;br /&gt;
con '''insert''' devo inserire anche la posizione&lt;br /&gt;
    ''a.insert(2,34)''&lt;br /&gt;
mette il 34 in posizione 2&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''for''' ==&lt;br /&gt;
&lt;br /&gt;
specifica un ciclo, fa le cose tante volte fino ad una condizione.&lt;br /&gt;
For variabile in una sequenza di qualche tipo.&lt;br /&gt;
Es:     ''for elemento in a:&lt;br /&gt;
               print elemento''&lt;br /&gt;
&lt;br /&gt;
es b è una tupla.&lt;br /&gt;
Allora posso scrivere:&lt;br /&gt;
    ''for elem in b&lt;br /&gt;
         print “altro elemento”&lt;br /&gt;
         “print elem”''&lt;br /&gt;
&lt;br /&gt;
elem o qualsiasi altro nome gli dia è ogni elemento dentro la tupla o lista o dizionario.&lt;br /&gt;
&lt;br /&gt;
Se io voglio sia la chiave sia il valore in un dizionario (se metto elem mi mette solo la chiave) posso fare:&lt;br /&gt;
for chiave in a:&lt;br /&gt;
	    ''print “chiave: “ + chiave&lt;br /&gt;
	    print “valore: “ + a[chiave]''&lt;br /&gt;
&lt;br /&gt;
'''DOPO I DUE PUNTI METTO SEMPRE IL TAB.'''&lt;br /&gt;
&lt;br /&gt;
== '''xrange''' ==&lt;br /&gt;
&lt;br /&gt;
xrange è un iterable di dieci elementi con il primo valore uguale a 0 .E' una lista ma non ha le proprietà di una lista.&lt;br /&gt;
se io voglio fare un for da uno a dieci (cioè la somma da uno a 10)&lt;br /&gt;
&lt;br /&gt;
es:     ''for I xrange(10)&lt;br /&gt;
               print I''&lt;br /&gt;
lui stampa&lt;br /&gt;
''1&lt;br /&gt;
2&lt;br /&gt;
3&lt;br /&gt;
4&lt;br /&gt;
5&lt;br /&gt;
6&lt;br /&gt;
7&lt;br /&gt;
8&lt;br /&gt;
9&lt;br /&gt;
10''&lt;br /&gt;
xrange vale solo per for.&lt;br /&gt;
&lt;br /&gt;
== '''range''' ==&lt;br /&gt;
&lt;br /&gt;
è una lista.se io scrivo:&lt;br /&gt;
    ''print range(10)''&lt;br /&gt;
lui mi da     ''[0,1,2,3,4,5,6,7,8,9].''&lt;br /&gt;
è più lento di xrange e poi sta morendo&lt;br /&gt;
&lt;br /&gt;
== '''len''' ==&lt;br /&gt;
&lt;br /&gt;
    ''len (a)''&lt;br /&gt;
da la lunghezza della stringa&lt;br /&gt;
&lt;br /&gt;
== '''enumerate''' ==&lt;br /&gt;
&lt;br /&gt;
se io ho una lista di tre elmenti&lt;br /&gt;
''a=[“ciao”,”bel”, “mondo”]''&lt;br /&gt;
&lt;br /&gt;
''for I, elem in enumerate(a):&lt;br /&gt;
     print str(I) + “:” + elem&lt;br /&gt;
''&lt;br /&gt;
da la posizione corrente di ogni elemento.&lt;br /&gt;
''0:ciao&lt;br /&gt;
1:bel&lt;br /&gt;
2:mondo''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''raw_input''' ==&lt;br /&gt;
&lt;br /&gt;
dai il valore.&lt;br /&gt;
''Base= raw_input (“inserisce la base:”)&lt;br /&gt;
esponente=raw_input (“inserisci l'/ esponente”)''&lt;br /&gt;
&lt;br /&gt;
ti chiede il valore di base ed esponente.&lt;br /&gt;
&lt;br /&gt;
== '''Int''' ==&lt;br /&gt;
&lt;br /&gt;
forza il fatto che quel valore sia un intero.&lt;br /&gt;
''&lt;br /&gt;
Es:base=int(base)&lt;br /&gt;
  result=int(result)''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''UPPER,LOWER,CAPITALIZE''' ==&lt;br /&gt;
&lt;br /&gt;
'''capitalize''' è un comando che sulla la stringa su cui viene applicato ,prende la prima lettera dopo gli spazi e ci mette la maiuscola&lt;br /&gt;
&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.capitalize()''&lt;br /&gt;
    ''Ciao mondo''&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.title()&lt;br /&gt;
    Ciao Mondo''&lt;br /&gt;
&lt;br /&gt;
'''LOWER:''' prende la striga e emette tutto minuscolo&lt;br /&gt;
'''UPPER:''' il contrario di lower&lt;br /&gt;
&lt;br /&gt;
== '''ESEMPIO DELLA SERATA:''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Calcolo di una potenza.&lt;br /&gt;
&lt;br /&gt;
    ''Base= raw_input (“inserisce la base:”)&lt;br /&gt;
    esponente=raw_input (“inserisci l'/ esponente”)&lt;br /&gt;
&lt;br /&gt;
    base=int(base)&lt;br /&gt;
    result=int(result)&lt;br /&gt;
&lt;br /&gt;
    result=1&lt;br /&gt;
    for i in xrange(esponente):&lt;br /&gt;
    result = result * base&lt;br /&gt;
    print result''&lt;br /&gt;
&lt;br /&gt;
l'operatore int forza il fatto che l'operatore deve essere un intero, lo dobbiamo scrivere, altrimenti non funziona perchè lui lo vede come stringa&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3720</id>
		<title>Python Lezione 4 Giugno 2008</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Python_Lezione_4_Giugno_2008&amp;diff=3720"/>
		<updated>2008-06-06T07:54:48Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: /* Python */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Python ==&lt;br /&gt;
[http://www.python.org/ Python] è un linguaggio di programmazione [http://it.wikipedia.org/wiki/Interprete_(informatica) interpretato].&lt;br /&gt;
Il linuaggio interpretato è simile agli altri linguaggi in circolazione ma, invece di essere trasformato direttamente in codice binario dal meccanismo automatico, viene interpretato da questo e poi mandato all'hardware.&lt;br /&gt;
È meglio di quelli compilati perchè si adatta ai vari hardware.&lt;br /&gt;
Python è un ottimo linguaggio di prorammaziobe ma è un pò più lento, diversamente da quello in c.&lt;br /&gt;
Python ha 4 interpreti:generamlmente si usa cpython (classic python, scritto in c) in tutte le distribuzioni python, ma c'è anche pypy e jython (scritto in java per python).&lt;br /&gt;
&lt;br /&gt;
La prima riga di ogni script python deve iniziare con #!usr/bin/env/python&lt;br /&gt;
&lt;br /&gt;
il #! del file fa capire al sistema operativo che quello non è un file di testo ma un eseguibile.&lt;br /&gt;
&lt;br /&gt;
== COMMENTI ==&lt;br /&gt;
&lt;br /&gt;
: sono righe che l'interprete salta e non legge &lt;br /&gt;
es: &lt;br /&gt;
    ''# stampa:”hello word”''&lt;br /&gt;
&lt;br /&gt;
== PRINT ==&lt;br /&gt;
: è una funzione, è seguito da una stringa (una cosa tra 2 virgolete).La stringa deve essere tra virgolette in tutti i comandi, i numeri interi invece no.&lt;br /&gt;
Il punto e virgola in molti dei linguaggi di porgrammazione si mette alla fine di ogi riga, in Python si può ma un buon pitonista in genere non lo fa mai.&lt;br /&gt;
PRINT stampa l'oggetto che viene dopo.&lt;br /&gt;
Se scrivo:&lt;br /&gt;
    ''print 3''&lt;br /&gt;
se si esegue questo stampa 3&lt;br /&gt;
se scrivo&lt;br /&gt;
    '' print “3”''&lt;br /&gt;
stampa lo stesso ma in questo caso l'oggetto che si passsa è una stringa&lt;br /&gt;
se scrivo&lt;br /&gt;
    ''print 3+2''&lt;br /&gt;
scrive&lt;br /&gt;
    '' 5''&lt;br /&gt;
se scrivo&lt;br /&gt;
    ''print “3+2”''&lt;br /&gt;
lui mi dà&lt;br /&gt;
    ''3+2''&lt;br /&gt;
&lt;br /&gt;
Le variabili non importa dichiararle, basta scrivere ad un certo punto&lt;br /&gt;
    ''messaggio=”hello world”''&lt;br /&gt;
    ''print messaggio''&lt;br /&gt;
se questo programma viene eseguito il risultatato sarà:&lt;br /&gt;
''hello world''&lt;br /&gt;
l'interprete va a vedere cosa c'è dentro la variabile messaggio e stampa hello world&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== ECCEZIONE ==&lt;br /&gt;
:se io commento la definizione di messaggio (es: ''# messaggio = &amp;quot; hello world &amp;quot;'' ) il programma non sa cos'è messaggio e se scrivo:&lt;br /&gt;
    ''print &amp;quot;messaggio&amp;quot;''&lt;br /&gt;
il risultato sarà:name error, che, viene chiamato eccezione.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== LE STRINGHE ==&lt;br /&gt;
supportano molti metodi perchè sono oggetti (che è un altro nome per variabile).le stringhe sono immutabili.&lt;br /&gt;
Se una stringa viene dichiarata la seconda volta, diversamente dalla prima, quella precedente viene buttata.&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
     messaggio=”ciao mondo”&lt;br /&gt;
    print “messaggio”''&lt;br /&gt;
lui scrive&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
In Python non si possono sommare cose diverse, o meglio, lo posso fare ma mi converte il numero in stringa.per esempio &lt;br /&gt;
    ''print messaggio*2'' &lt;br /&gt;
l'esecuzione darà&lt;br /&gt;
    ''messaggio messaggio&lt;br /&gt;
''&lt;br /&gt;
esempio:&lt;br /&gt;
     ''Print “ciao”+”mondo”''&lt;br /&gt;
lo eseguo e mi darà:&lt;br /&gt;
    '' ciao mondo''&lt;br /&gt;
&lt;br /&gt;
Se si scrive python da riga di comando parte l'interprete se scriviamo roba lui l'esegue e si usa per provare le cose.per uscire premere ctrl+d.&lt;br /&gt;
&lt;br /&gt;
LE STRINGHE SONO IMMUTABILI.&lt;br /&gt;
&lt;br /&gt;
== '''Funzione DIR''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
    ''messaggio=”ciao”&lt;br /&gt;
    dir(messaggio)''&lt;br /&gt;
a questo punto il programma da una serie di caratteri incomprensibili.&lt;br /&gt;
Praticamente dà i '''metodi''' che suporta la stringa messaggio.&lt;br /&gt;
&lt;br /&gt;
== I '''metodi''' ==&lt;br /&gt;
 sono operazioni che si possono applicare alla stringa.&lt;br /&gt;
quelli che iniziano con '''__'''spesso vengono usati per scoraggiare la gente ad usarli,in quanto qui non esistono i permessi e ognuno può modificare ciò che vuole.&lt;br /&gt;
&lt;br /&gt;
Quando il metodo inizia con '''AD''' richiama l'operatore dell'addizione&lt;br /&gt;
&lt;br /&gt;
'''__ doc__''' ce l'hanno tutti gli oggetti (stringhe, interi...)&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
metodo '''IS''':&lt;br /&gt;
tutti I metodi che iniziano per is danno come risultato o vero o falso.&lt;br /&gt;
es: &lt;br /&gt;
    ''messaggio.isalpha()''&lt;br /&gt;
mi dice se messaggio è o meno alfanumerico.&lt;br /&gt;
isalpha è un oggetto quindi ha le proprietà doc .&lt;br /&gt;
se io scrivo&lt;br /&gt;
    ''messaggio.isalpa.__doc__''&lt;br /&gt;
mi dice che fa.&lt;br /&gt;
&lt;br /&gt;
Importante metto tra “ solo se è una stringa.&lt;br /&gt;
Se io definisco un oggetto con un altro oggetto con una funzione non metto “.&lt;br /&gt;
es:&lt;br /&gt;
    '' messaggio=”gigio”&lt;br /&gt;
    messaggio2= messaggio.upper()''&lt;br /&gt;
&lt;br /&gt;
es:&lt;br /&gt;
''TYPE(3)''&lt;br /&gt;
mi dice che variabile  è.se è intero o stringa.&lt;br /&gt;
Se io scrivo ''DIR(3)''&lt;br /&gt;
mi da lo stesso pappie di roba di prima.&lt;br /&gt;
'''&lt;br /&gt;
I TIPI DELLA LIBREARIA STANDARD''':sono le variabili, ci sono anche le LISTE&lt;br /&gt;
&lt;br /&gt;
Esistono stringhe, interi, float (numeri con virgola)buleano (che ha due valori, vero o falso, True e false)e i  CONTENITORI:&lt;br /&gt;
&lt;br /&gt;
== '''LE LISTE''' ==&lt;br /&gt;
&lt;br /&gt;
es. lo scaffale ha I pc, I pc sono oggetti (pc1,pc2...).Se voglio uno scaffale di pc senza dare I nomi a tutti gli oggetti, definisco lo scaffale.&lt;br /&gt;
Lo scaffale si chiama''' Lista'''  .si usano le parentesi quadre con oggetti separati da virgola&lt;br /&gt;
es.    '' a = [ “pc1” , “schermo rotto” , 2]&lt;br /&gt;
dir (scaffale)''&lt;br /&gt;
da la lista dei metodi, da qui si capisce che la lista è un oggetto.&lt;br /&gt;
Se io faccio&lt;br /&gt;
    ''b = dir (a)''&lt;br /&gt;
o&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a il 4.&lt;br /&gt;
'''la lista MUTA!'''&lt;br /&gt;
Se faccio     ''print (“a”)''&lt;br /&gt;
mi da la lista degli oggetti più il 4.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''TUPLE''' ==&lt;br /&gt;
&lt;br /&gt;
è una lista non mutabile.&lt;br /&gt;
La tupla è molto piu veloce rispetto alla lista.&lt;br /&gt;
Con tuple si usano le parentesi tonde.&lt;br /&gt;
&lt;br /&gt;
== '''DIZIONARI''' ==&lt;br /&gt;
&lt;br /&gt;
il dizionario si definisce con le parentesi graffe {chiave:valore, chiave:valore}&lt;br /&gt;
a{chiave}&lt;br /&gt;
da il valore associato alla chiave.&lt;br /&gt;
&lt;br /&gt;
Dizionari liste e tuple sono dele sequenze e sono iterable e si possono scorrere.&lt;br /&gt;
&lt;br /&gt;
== '''If elif else''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
if condizione :&lt;br /&gt;
&lt;br /&gt;
indentato roba da fare se vero.&lt;br /&gt;
&lt;br /&gt;
Python supporta o tab o spazio, si decide quanti tab o spazi alla prima indentazione.&lt;br /&gt;
Meglio lo spazio perchè in futuro I tab verranno lasciati.&lt;br /&gt;
Di solito si usa 4 spazi.&lt;br /&gt;
Non c'è la graffa in pyton o I begin o gli end, si chiude e si apre la riga solo se si indenta.&lt;br /&gt;
&lt;br /&gt;
Esempio:&lt;br /&gt;
    ''a=3&lt;br /&gt;
    b=1''&lt;br /&gt;
&lt;br /&gt;
    ''if a &amp;gt;b:&lt;br /&gt;
      print (“ a è maggiore di b”)&lt;br /&gt;
    elif a==b:&lt;br /&gt;
      print (“ a è uguale a b”)&lt;br /&gt;
    else:&lt;br /&gt;
       print(“b è maggiore di a”)''&lt;br /&gt;
&lt;br /&gt;
in questo programma definisco due valori, a e b.&lt;br /&gt;
Chiedo al programma se aè maggiore di b di scrivere : a è maggiore di b, se a è uguale a b di scrivere che a è uguale a b e in tutte le altre condizioni (else) di scrivere che a è minore di b.&lt;br /&gt;
&lt;br /&gt;
	'''2.is, is not or, and,!='''&lt;br /&gt;
    ''if a is 1:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
    elif a is not 1:&lt;br /&gt;
      print (“no”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 and b is 3:&lt;br /&gt;
      print (“si”)&lt;br /&gt;
&lt;br /&gt;
    if a is 1 or b is 3:&lt;br /&gt;
      print (“okkei”)&lt;br /&gt;
''&lt;br /&gt;
&lt;br /&gt;
'''!= è il diverso.'''&lt;br /&gt;
&lt;br /&gt;
== '''append, insert''' ==&lt;br /&gt;
&lt;br /&gt;
    ''a.append(“4”)''&lt;br /&gt;
aggiunge alla lista a il 4.&lt;br /&gt;
Se faccio print (“a”)&lt;br /&gt;
mi da la lista degli oggetti più il 4.&lt;br /&gt;
&lt;br /&gt;
con '''insert''' devo inserire anche la posizione&lt;br /&gt;
    ''a.insert(2,34)''&lt;br /&gt;
mette il 34 in posizione 2&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''for''' ==&lt;br /&gt;
&lt;br /&gt;
specifica un ciclo, fa le cose tante volte fino ad una condizione.&lt;br /&gt;
For variabile in una sequenza di qualche tipo.&lt;br /&gt;
Es:     ''for elemento in a:&lt;br /&gt;
               print elemento''&lt;br /&gt;
&lt;br /&gt;
es b è una tupla.&lt;br /&gt;
Allora posso scrivere:&lt;br /&gt;
    ''for elem in b&lt;br /&gt;
         print “altro elemento”&lt;br /&gt;
         “print elem”''&lt;br /&gt;
&lt;br /&gt;
elem o qualsiasi altro nome gli dia è ogni elemento dentro la tupla o lista o dizionario.&lt;br /&gt;
&lt;br /&gt;
Se io voglio sia la chiave sia il valore in un dizionario (se metto elem mi mette solo la chiave) posso fare:&lt;br /&gt;
for chiave in a:&lt;br /&gt;
	    ''print “chiave: “ + chiave&lt;br /&gt;
	    print “valore: “ + a[chiave]''&lt;br /&gt;
&lt;br /&gt;
'''DOPO I DUE PUNTI METTO SEMPRE IL TAB.'''&lt;br /&gt;
&lt;br /&gt;
== '''xrange''' ==&lt;br /&gt;
&lt;br /&gt;
xrange è un iterable di dieci elementi con il primo valore uguale a 0 .E' una lista ma non ha le proprietà di una lista.&lt;br /&gt;
se io voglio fare un for da uno a dieci (cioè la somma da uno a 10)&lt;br /&gt;
&lt;br /&gt;
es:     ''for I xrange(10)&lt;br /&gt;
               print I''&lt;br /&gt;
lui stampa&lt;br /&gt;
''1&lt;br /&gt;
2&lt;br /&gt;
3&lt;br /&gt;
4&lt;br /&gt;
5&lt;br /&gt;
6&lt;br /&gt;
7&lt;br /&gt;
8&lt;br /&gt;
9&lt;br /&gt;
10''&lt;br /&gt;
xrange vale solo per for.&lt;br /&gt;
&lt;br /&gt;
== '''range''' ==&lt;br /&gt;
&lt;br /&gt;
è una lista.se io scrivo:&lt;br /&gt;
    ''print range(10)''&lt;br /&gt;
lui mi da     ''[0,1,2,3,4,5,6,7,8,9].''&lt;br /&gt;
è più lento di xrange e poi sta morendo&lt;br /&gt;
&lt;br /&gt;
== '''len''' ==&lt;br /&gt;
&lt;br /&gt;
    ''len (a)''&lt;br /&gt;
da la lunghezza della stringa&lt;br /&gt;
&lt;br /&gt;
== '''enumerate''' ==&lt;br /&gt;
&lt;br /&gt;
se io ho una lista di tre elmenti&lt;br /&gt;
''a=[“ciao”,”bel”, “mondo”]''&lt;br /&gt;
&lt;br /&gt;
''for I, elem in enumerate(a):&lt;br /&gt;
     print str(I) + “:” + elem&lt;br /&gt;
''&lt;br /&gt;
da la posizione corrente di ogni elemento.&lt;br /&gt;
''0:ciao&lt;br /&gt;
1:bel&lt;br /&gt;
2:mondo''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''raw_input''' ==&lt;br /&gt;
&lt;br /&gt;
dai il valore.&lt;br /&gt;
''Base= raw_input (“inserisce la base:”)&lt;br /&gt;
esponente=raw_input (“inserisci l'/ esponente”)''&lt;br /&gt;
&lt;br /&gt;
ti chiede il valore di base ed esponente.&lt;br /&gt;
&lt;br /&gt;
== '''Int''' ==&lt;br /&gt;
&lt;br /&gt;
forza il fatto che quel valore sia un intero.&lt;br /&gt;
''&lt;br /&gt;
Es:base=int(base)&lt;br /&gt;
  result=int(result)''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== '''UPPER,LOWER,CAPITALIZE''' ==&lt;br /&gt;
&lt;br /&gt;
'''capitalize''' è un comando che sulla la stringa su cui viene applicato ,prende la prima lettera dopo gli spazi e ci mette la maiuscola&lt;br /&gt;
&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.capitalize()''&lt;br /&gt;
    ''Ciao mondo''&lt;br /&gt;
es: &lt;br /&gt;
    ''print “ciao mondo”.title()&lt;br /&gt;
    Ciao Mondo''&lt;br /&gt;
&lt;br /&gt;
'''LOWER:''' prende la striga e emette tutto minuscolo&lt;br /&gt;
'''UPPER:''' il contrario di lower&lt;br /&gt;
&lt;br /&gt;
== '''ESEMPIO DELLA SERATA:''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Calcolo di una potenza.&lt;br /&gt;
&lt;br /&gt;
    ''Base= raw_input (“inserisce la base:”)&lt;br /&gt;
    esponente=raw_input (“inserisci l'/ esponente”)&lt;br /&gt;
&lt;br /&gt;
    base=int(base)&lt;br /&gt;
    result=int(result)&lt;br /&gt;
&lt;br /&gt;
    result=1&lt;br /&gt;
    for i in xrange(esponente):&lt;br /&gt;
    result = result * base&lt;br /&gt;
    print result''&lt;br /&gt;
&lt;br /&gt;
l'operatore int forza il fatto che l'operatore deve essere un intero, lo dobbiamo scrivere, altrimenti non funziona perchè lui lo vede come stringa&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Tessere&amp;diff=3061</id>
		<title>Tessere</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Tessere&amp;diff=3061"/>
		<updated>2007-01-12T16:53:53Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Ecco le bozze per le nuove tessere!&lt;br /&gt;
&lt;br /&gt;
Mano a mano che vengono modificate verranno aggiunte qui:&lt;br /&gt;
&lt;br /&gt;
Fronte:&lt;br /&gt;
&lt;br /&gt;
[[Immagine:Tessera-front.jpg|200px]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Retro&lt;br /&gt;
&lt;br /&gt;
[[Immagine:Tessera-back-r1.jpg|200px]]&lt;br /&gt;
&lt;br /&gt;
Modifiche attualmente da fare:&lt;br /&gt;
#edit 12/01/2007 ho uppato la nuova versione. Giacomo&lt;br /&gt;
&lt;br /&gt;
- (FATTO) scambiare l'ordine dei campi da compilare, da come e' ora (anno-numero-cognome-nome) a anno-nome-cognome-numero (partendo dall'alto si intende)&lt;br /&gt;
&lt;br /&gt;
- (NON CREDO SI FARA') uno sfondo per il davanti? (a me piace anche cosi -giacomo)&lt;br /&gt;
&lt;br /&gt;
- (FATTO) link a ILS FSF e trashware? si era pensato di metterle sotto al simboletti degli animaletti... in particolare questi: http://trashware.linux.it | http://www.fsf.org | http://www.linux.it&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=File:Tessera-back-2007.jpg&amp;diff=3060</id>
		<title>File:Tessera-back-2007.jpg</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=File:Tessera-back-2007.jpg&amp;diff=3060"/>
		<updated>2007-01-12T16:51:49Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: Revisione due, aggiunti i link e spostati i vari campi&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Revisione due, aggiunti i link e spostati i vari campi&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=GOLEM&amp;diff=3044</id>
		<title>GOLEM</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=GOLEM&amp;diff=3044"/>
		<updated>2006-12-20T13:11:55Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Benvenuto nel sito web del GOLEM - Gruppo Operativo Linux Empoli'''&lt;br /&gt;
&amp;lt;table&amp;gt;&lt;br /&gt;
&amp;lt;tr&amp;gt;&lt;br /&gt;
&amp;lt;td&amp;gt;[[Immagine:Tanks.jpg]]&amp;lt;/td&amp;gt;&lt;br /&gt;
&amp;lt;td&amp;gt;&lt;br /&gt;
 La libertà è un fatto dell'intelligenza:&lt;br /&gt;
 ed è quella che dipende da questa,&lt;br /&gt;
 non l'intelligenza dalla libertà.&lt;br /&gt;
 Dirò che, nel concetto dei toscani,&lt;br /&gt;
 chi non è un uomo libero è un uomo grullo.&lt;br /&gt;
 &lt;br /&gt;
 Curzio Malaparte - «''Maledetti toscani''»&lt;br /&gt;
&amp;lt;/td&amp;gt;&lt;br /&gt;
&amp;lt;td&amp;gt;[[Immagine:Logob-w.png|100px]]&amp;lt;/td&amp;gt;&lt;br /&gt;
&amp;lt;/tr&amp;gt;&lt;br /&gt;
&amp;lt;/table&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Cos'è il GOLEM ==&lt;br /&gt;
&lt;br /&gt;
Il GOLEM è un '''Linux User Group''' (LUG), il Gruppo Operativo Linux di EMpoli. Ci sono molti LUG in [http://www.linux.it/LUG/index.phtml Italia] e nel [http://lugww.counter.li.org/groups.cms mondo]. Per anni, come molti altri LUG, è stato un gruppo informale. Dal 2004 è invece un''''associazione di promozione sociale'''.&lt;br /&gt;
&lt;br /&gt;
I soci si riuniscono (più o meno) ogni '''martedì''' sera, a partire dalle 21:30, presso la sede operativa dell'associazione, che noi chiamiamo &amp;quot;[[Officina Informatica]]&amp;quot; o semplicemente '''OI'''.&lt;br /&gt;
&lt;br /&gt;
L'indirizzo dell'[[Officina Informatica |OI]] è [[Dov'e` il GOLEM ? | via Magolo 34/P]] località Avane, '''Empoli''' (FI), all'interno dell'area ex-mercato ortofrutticolo. I soci, i volontari ed i simpatizzanti del GOLEM si tengono in contatto tramite [[mailing lists del GOLEM | mailing lists]] (o liste di discussione) ...iscriviti anche tu!&lt;br /&gt;
&lt;br /&gt;
Se intanto vuoi '''contattare''' il GOLEM invia un messaggio di posta elettronica all'indirizzo [mailto:golem@golem.linux.it golem_AT_golem_DOT_linux_DOT_it] (sostituire AT con &amp;quot;@&amp;quot; e DOT con &amp;quot;.&amp;quot;)&lt;br /&gt;
&lt;br /&gt;
Nella pagina dei [[documenti del GOLEM| documenti]] è possibile trovare molto di quello che ci riguarda, dai '''documenti ufficiali''' dell'associazione ...fino ai deliri, informatici e non, di [[Visioni]].&lt;br /&gt;
&lt;br /&gt;
Nella pagina [[Soci del GOLEM | '''SOCI''']] c'è la possibilità di contattare e conoscere alcuni dei [[Soci del GOLEM | soci]] del GOLEM&lt;br /&gt;
&lt;br /&gt;
'''Dicono di noi''': [[Giornali]] e [[TV]]&lt;br /&gt;
&lt;br /&gt;
== Sito web: modifica e aggiornamento ==&lt;br /&gt;
&lt;br /&gt;
Questo è il sito web ufficiale del GOLEM. È realizzato con un software che si chiama '''wiki''' (in particolare si chiama [http://www.mediawiki.org/wiki/MediaWiki MediaWiKi]) e permette la modifica del sito da parte di qualsiasi visitatore, che si sia prima registrato creandosi una propria identità.&lt;br /&gt;
&lt;br /&gt;
 Crea la tua identità sul wiki: [[Special:Userlogin|log in]]&lt;br /&gt;
 &lt;br /&gt;
 '''Consulta''' il [http://meta.wikimedia.org/wiki/Aiuto:Sommario manuale di MediaWiki] prima di procedere alle modifiche!&lt;br /&gt;
 &lt;br /&gt;
 Per l'aiuto '''veloce''' clicca su [[Wikipedia:Aiuto|Aiuto]] nel menù di sinistra.&lt;br /&gt;
&lt;br /&gt;
== Attività del GOLEM ==&lt;br /&gt;
&lt;br /&gt;
* '''Corsi di alfabetizzazione su GNU/Linux ed il Software Libero per la cittadinanza'''&lt;br /&gt;
&lt;br /&gt;
In queste pagina potrete trovare gli appunti delle lezioni dei corsi del GOLEM: [[Corso Base 2006]], [[Corso Intermedio 2006]]&lt;br /&gt;
&lt;br /&gt;
* '''Non c'è progresso se non è per tutti: il trashware'''&lt;br /&gt;
&lt;br /&gt;
Il GOLEM da tempo è impegnato nell'attività di [[Trashaware GOLEM | recupero di materiale informatico dismesso]] anche se ancora funzionante per impigarlo in progetti di vario tipo e natura.&lt;br /&gt;
&lt;br /&gt;
Questa attività, che chiamiamo [http://trashware.linux.it trashware], ha prodotto già diversi risultati di cui potete leggere i dettagli [[trashaware GOLEM | qui]]&lt;br /&gt;
&lt;br /&gt;
Ecco intanto qualche [http://moloko.itc.it/paoloblog/photos/Trashware_computer_waste_images/ foto scioccante] sulla fine che fa l'hardware che noi &amp;quot;buttiamo&amp;quot;.&lt;br /&gt;
&lt;br /&gt;
* '''La trash!Art, la faccia creativa del trashware'''&lt;br /&gt;
&lt;br /&gt;
Appendice del trashware ma con una dignità tutta sua la [[trash!Art]] ci insegna che l'informatica non merita qull'aura di &amp;quot;divinità&amp;quot; che chi ci spilla centinaia di euro ogni 6 mesi per venderci un PC nuovo vorrebbe farci credere... &lt;br /&gt;
&lt;br /&gt;
Ma prendendo qualche componente rotto di PC a martellate, o decorando un CD-ROM ormai inutile con della carta riciclata si possono ottenere [[trash!Art | tante cose]] utili e bellissime!&lt;br /&gt;
&lt;br /&gt;
* '''Campagna contro i Brevetti Software in Europa (...e nel Mondo!)'''&lt;br /&gt;
&lt;br /&gt;
Se introdotta normativamente la brevettabilità del software, oltre che economicamente svantaggiosa, soprattutto per aziende e professionisti europei, sancirebbe l''''assurdo principio della &amp;quot;brevettabilità delle idee&amp;quot;!!&lt;br /&gt;
&lt;br /&gt;
Il GOLEM è impegnato a [http://www.nosoftwarepatents.com/it/m/intro/index.html combattere] l'introduzione di tali provvedimenti negli stati dell'Unione Europea ed affianca e sostiene le iniziative di [http://www.ffii.org/ Foundation for a Free Information Infrastructure (FFII)] in proposito... Collabora anche tu a difendere la libertà di pensiero e di innovazione!&lt;br /&gt;
&lt;br /&gt;
* '''Diffondiamo l'uso degli standard aperti'''&lt;br /&gt;
&lt;br /&gt;
L'utilizzo e la massima diffusione degli standard aperti è fondamentale in informatica, perché rende possibile l'interoperabilità e, contemporaneamente, la reale concorrenza fra programmi e strumenti software diversi, per questo, ad esempio:&lt;br /&gt;
&lt;br /&gt;
=&amp;gt; non usare e non inviare documenti in formati proprietari con specifiche chiuse come, ad esempio il [http://www.gnu.org/philosophy/no-word-attachments.it.html .doc], utilizza piuttosto l'[http://it.wikipedia.org/wiki/Open_document Open Document Format (ODF)]&lt;br /&gt;
&lt;br /&gt;
=&amp;gt; Se utilizzi la tecnologia VoIP per comunicare fallo con programmi che supportino i protocolli standard H.323 (vecchio) o SIP (nuovo!), come [http://www.ekiga.org ekiga] o [http://www.openwengo.com/index.php/homepage WengoPhone], '''non''' con quelli che supportano solo protocolli proprietari come Skype&lt;br /&gt;
&lt;br /&gt;
== Foto del GOLEM ==&lt;br /&gt;
&lt;br /&gt;
Le [[Foto del GOLEM | '''foto''']] delle numerose '''attività''' del GOLEM e degli '''eventi passati'''.&lt;br /&gt;
&lt;br /&gt;
Le foto dell'[[Officina Informatica]]&lt;br /&gt;
&lt;br /&gt;
Le foto della [[Trash!Art]] del GOLEM&lt;br /&gt;
&lt;br /&gt;
Le foto del GOLEM su [http://www.flickr.com/photos/gruppo_operativo_linux_empoli '''flickr''']&lt;br /&gt;
&lt;br /&gt;
== Nuova maglia del GOLEM ==&lt;br /&gt;
&lt;br /&gt;
[[Maglietta del GOLEM | Inserite le vostre proposte]] per una nuova maglietta del GOLEM&lt;br /&gt;
&lt;br /&gt;
mmm&lt;br /&gt;
&lt;br /&gt;
== EventImminenti ==&lt;br /&gt;
&lt;br /&gt;
* Ogni Martedì il GOLEM si riunisce all'[[Dov'e` il GOLEM ? | officina informatica]]&lt;br /&gt;
&lt;br /&gt;
== I link del GOLEM ==&lt;br /&gt;
&lt;br /&gt;
* Prima di tutto i [[collegamenti faziosi]] (accessibili anche dalla pagina [[Visioni]])&lt;br /&gt;
&lt;br /&gt;
* [[Un altro mondo e` possibile]]&lt;br /&gt;
&lt;br /&gt;
* [[toscana.linux.it]]: le pagine dove si organizza il lavoro fatto in comune dai LUG toscani&lt;br /&gt;
&lt;br /&gt;
* altri link a prestissimo...&lt;br /&gt;
&lt;br /&gt;
== English Version ==&lt;br /&gt;
&lt;br /&gt;
Our [[English version]] is under construction now.&lt;br /&gt;
Also a very few days and all our English pages will be online !!!&lt;br /&gt;
&lt;br /&gt;
Please, read the link for more information about us.&lt;br /&gt;
&lt;br /&gt;
Thank you.&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Tessere&amp;diff=3043</id>
		<title>Tessere</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Tessere&amp;diff=3043"/>
		<updated>2006-12-20T13:06:18Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Ecco le bozze per le nuove tessere!&lt;br /&gt;
&lt;br /&gt;
Mano a mano che vengono modificate verranno aggiunte qui:&lt;br /&gt;
&lt;br /&gt;
Fronte:&lt;br /&gt;
&lt;br /&gt;
[[Immagine:Tessera-front.jpg|200px]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Retro&lt;br /&gt;
&lt;br /&gt;
[[Immagine:Tessera-back.jpg|200px]]&lt;br /&gt;
&lt;br /&gt;
Modifiche attualmente da fare:&lt;br /&gt;
&lt;br /&gt;
- scambiare l'ordine dei campi da compilare, da come e' ora (anno-numero-cognome-nome) a anno-nome-cognome-numero (partendo dall'alto si intende)&lt;br /&gt;
&lt;br /&gt;
- uno sfondo per il davanti? (a me piace anche cosi -giacomo)&lt;br /&gt;
&lt;br /&gt;
- link a ILS FSF e trashware? si era pensato di metterle sotto al simboletti degli animaletti... in particolare questi: http://trashware.linux.it | http://www.fsf.org | http://www.linux.it&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Tessere&amp;diff=3042</id>
		<title>Tessere</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Tessere&amp;diff=3042"/>
		<updated>2006-12-20T13:05:48Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Ecco le bozze per le nuove tessere!&lt;br /&gt;
&lt;br /&gt;
Mano a mano che vengono modificate verranno aggiunte qui:&lt;br /&gt;
&lt;br /&gt;
Fronte:&lt;br /&gt;
&lt;br /&gt;
[[Immagine:Tessera-front.jpg|200px]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Retro&lt;br /&gt;
&lt;br /&gt;
[[Immagine:Tessera-back.jpg|200px]]&lt;br /&gt;
&lt;br /&gt;
Modifiche attualmente da fare:&lt;br /&gt;
&lt;br /&gt;
- scambiare l'ordine dei campi da compilare, da come e' ora (anno-numero-cognome-nome) a anno-nome-cognome-numero (partendo dall'alto si intende)&lt;br /&gt;
&lt;br /&gt;
- uno sfondo per il davanti? (a me piace anche cosi -giacomo)&lt;br /&gt;
&lt;br /&gt;
- link a ILS FSF e trashware? si era pensato di metterle sotto al simboletti degli animaletti... qualcosa tipo: http://trashware.linux.it | http://www.fsf.org | http://www.linux.it&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Tessere&amp;diff=3041</id>
		<title>Tessere</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Tessere&amp;diff=3041"/>
		<updated>2006-12-20T13:05:37Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Ecco le bozze per le nuove tessere!&lt;br /&gt;
&lt;br /&gt;
Mano a mano che vengono modificate verranno aggiunte qui:&lt;br /&gt;
&lt;br /&gt;
Fronte:&lt;br /&gt;
&lt;br /&gt;
[[Immagine:Tessera-front.jpg|200px]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Retro&lt;br /&gt;
&lt;br /&gt;
[[Immagine:Tessera-back.jpg|200px]]&lt;br /&gt;
&lt;br /&gt;
Modifiche attualmente da fare:&lt;br /&gt;
&lt;br /&gt;
- scambiare l'ordine dei campi da compilare, da come e' ora (anno-numero-cognome-nome) a anno-nome-cognome-numero (partendo dall'alto si intende)&lt;br /&gt;
- uno sfondo per il davanti? (a me piace anche cosi -giacomo)&lt;br /&gt;
- link a ILS FSF e trashware? si era pensato di metterle sotto al simboletti degli animaletti... qualcosa tipo: http://trashware.linux.it | http://www.fsf.org | http://www.linux.it&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Tessere&amp;diff=3040</id>
		<title>Tessere</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Tessere&amp;diff=3040"/>
		<updated>2006-12-20T13:05:28Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Ecco le bozze per le nuove tessere!&lt;br /&gt;
&lt;br /&gt;
Mano a mano che vengono modificate verranno aggiunte qui:&lt;br /&gt;
&lt;br /&gt;
Fronte:&lt;br /&gt;
&lt;br /&gt;
[[Immagine:Tessera-front.jpg|200px]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Retro&lt;br /&gt;
&lt;br /&gt;
[[Immagine:Tessera-back.jpg|200px]]&lt;br /&gt;
&lt;br /&gt;
Modifiche attualmente da fare:&lt;br /&gt;
&lt;br /&gt;
- scambiare l'ordine dei campi da compilare, da come e' ora (anno-numero-cognome-nome) a anno-nome-cognome-numero (partendo dall'alto si intende)&lt;br /&gt;
- uno sfondo per il davanti? (a me piace anche cosi -giacomo)&lt;br /&gt;
- link a ILS FSF e trashware? si era pensato di metterle sotto al simboletti degli animaletti... qualcosa tipo: http://trashware.linux.it | http://www.fsf.org | http://www.linux.it&lt;br /&gt;
&lt;br /&gt;
Giacomo&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Tessere&amp;diff=3039</id>
		<title>Tessere</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Tessere&amp;diff=3039"/>
		<updated>2006-12-20T13:02:18Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Ecco le bozze per le nuove tessere!&lt;br /&gt;
&lt;br /&gt;
Mano a mano che vengono modificate verranno aggiunte qui:&lt;br /&gt;
&lt;br /&gt;
Fronte:&lt;br /&gt;
&lt;br /&gt;
[[Immagine:Tessera-front.jpg|200px]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Retro&lt;br /&gt;
&lt;br /&gt;
[[Immagine:Tessera-back.jpg|200px]]&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=File:Tessera-front-2007.jpg&amp;diff=3037</id>
		<title>File:Tessera-front-2007.jpg</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=File:Tessera-front-2007.jpg&amp;diff=3037"/>
		<updated>2006-12-20T13:00:43Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: Fronte-tessera versione 1

create da
http://www.gp-visualdesign.com/&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Fronte-tessera versione 1&lt;br /&gt;
&lt;br /&gt;
create da&lt;br /&gt;
http://www.gp-visualdesign.com/&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Logo_del_GOLEM&amp;diff=3036</id>
		<title>Logo del GOLEM</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Logo_del_GOLEM&amp;diff=3036"/>
		<updated>2006-12-20T12:51:39Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Proposte per un nuovo logo del GOLEM&lt;br /&gt;
&lt;br /&gt;
----&lt;br /&gt;
&lt;br /&gt;
Ecco una bozza proposta da Hal, da rifare con opportuni programmi di grafica vettoriale.&lt;br /&gt;
&lt;br /&gt;
[[Immagine:logo1_golem.jpg]]&lt;br /&gt;
&lt;br /&gt;
Si tratta di una scritta in cui ogni lettera è scritta in un modulo di 2x3 quadretti. Il risultato è «roccioso» se la linea è irregolare, ma va benissimo anche con linea liscia.&lt;br /&gt;
&lt;br /&gt;
----&lt;br /&gt;
&lt;br /&gt;
Elisa ha provato a rifarlo con Sodipodi, questo e' il risultato esportato in png:&lt;br /&gt;
&lt;br /&gt;
[[Immagine:Logo_golem.png]]&lt;br /&gt;
&lt;br /&gt;
Se puo' andare bene, Elisa invia il file .svg originale!&lt;br /&gt;
&lt;br /&gt;
----&lt;br /&gt;
&lt;br /&gt;
Che ne dite di questa versione?&lt;br /&gt;
&lt;br /&gt;
[[Immagine:Logo_golem_occhi.png]]&lt;br /&gt;
&lt;br /&gt;
«Occhiacci di legno, perché mi guardate?»&lt;br /&gt;
&lt;br /&gt;
----&lt;br /&gt;
&lt;br /&gt;
Logo in versione '''ricorsiva'''   :o)&lt;br /&gt;
&lt;br /&gt;
[[Immagine:Logo_golem_occhi_ricors.png]]&lt;br /&gt;
&lt;br /&gt;
----&lt;br /&gt;
&lt;br /&gt;
Finalmente un &amp;quot;logo&amp;quot; e non una &amp;quot;scritta&amp;quot;.&lt;br /&gt;
&lt;br /&gt;
[[Immagine:logo_zero.png]]&lt;br /&gt;
&lt;br /&gt;
Senza bocca &amp;quot;ricorsiva&amp;quot; si capisce che il logo è la &amp;quot;O&amp;quot; di GOLEM?&lt;br /&gt;
&lt;br /&gt;
Qualcuno sa realizzarlo un po' meglio di me? Forse con la bocca più piccola.&lt;br /&gt;
&lt;br /&gt;
----&lt;br /&gt;
&lt;br /&gt;
Ecce Logo&lt;br /&gt;
&lt;br /&gt;
[[Immagine:Logovero.jpg]]&lt;br /&gt;
&lt;br /&gt;
Questa soluzione è quella che mi piace di più: si capisce che il faccione-logo deriva pari pari dal font usato per la scritta GOLEM.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
--- &lt;br /&gt;
&lt;br /&gt;
inserito da Giacomo il 13/12/2006&lt;br /&gt;
&lt;br /&gt;
Proposte per il logo (creato da Giuliano Panaroni http://www.gp-visualdesign.com/) per le nuove tessere (ma non solo)&lt;br /&gt;
&lt;br /&gt;
[[Immagine:Logog-b.png|200px]] [[Immagine:Logob-w.png|200px]] [[Immagine:Logor-b.png|200px]]&lt;br /&gt;
&lt;br /&gt;
stesso soggetto in svariati colori: lo trovate qua: http://golem.linux.it/index.php/Immagine:Logo-multicolor.png&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=File:Logog-b.png&amp;diff=3035</id>
		<title>File:Logog-b.png</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=File:Logog-b.png&amp;diff=3035"/>
		<updated>2006-12-20T12:50:54Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: Logo scelto per le tessere&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Logo scelto per le tessere&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Logo_del_GOLEM&amp;diff=3032</id>
		<title>Logo del GOLEM</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Logo_del_GOLEM&amp;diff=3032"/>
		<updated>2006-12-13T19:31:24Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Proposte per un nuovo logo del GOLEM&lt;br /&gt;
&lt;br /&gt;
----&lt;br /&gt;
&lt;br /&gt;
Ecco una bozza proposta da Hal, da rifare con opportuni programmi di grafica vettoriale.&lt;br /&gt;
&lt;br /&gt;
[[Immagine:logo1_golem.jpg]]&lt;br /&gt;
&lt;br /&gt;
Si tratta di una scritta in cui ogni lettera è scritta in un modulo di 2x3 quadretti. Il risultato è «roccioso» se la linea è irregolare, ma va benissimo anche con linea liscia.&lt;br /&gt;
&lt;br /&gt;
----&lt;br /&gt;
&lt;br /&gt;
Elisa ha provato a rifarlo con Sodipodi, questo e' il risultato esportato in png:&lt;br /&gt;
&lt;br /&gt;
[[Immagine:Logo_golem.png]]&lt;br /&gt;
&lt;br /&gt;
Se puo' andare bene, Elisa invia il file .svg originale!&lt;br /&gt;
&lt;br /&gt;
----&lt;br /&gt;
&lt;br /&gt;
Che ne dite di questa versione?&lt;br /&gt;
&lt;br /&gt;
[[Immagine:Logo_golem_occhi.png]]&lt;br /&gt;
&lt;br /&gt;
«Occhiacci di legno, perché mi guardate?»&lt;br /&gt;
&lt;br /&gt;
----&lt;br /&gt;
&lt;br /&gt;
Logo in versione '''ricorsiva'''   :o)&lt;br /&gt;
&lt;br /&gt;
[[Immagine:Logo_golem_occhi_ricors.png]]&lt;br /&gt;
&lt;br /&gt;
----&lt;br /&gt;
&lt;br /&gt;
Finalmente un &amp;quot;logo&amp;quot; e non una &amp;quot;scritta&amp;quot;.&lt;br /&gt;
&lt;br /&gt;
[[Immagine:logo_zero.png]]&lt;br /&gt;
&lt;br /&gt;
Senza bocca &amp;quot;ricorsiva&amp;quot; si capisce che il logo è la &amp;quot;O&amp;quot; di GOLEM?&lt;br /&gt;
&lt;br /&gt;
Qualcuno sa realizzarlo un po' meglio di me? Forse con la bocca più piccola.&lt;br /&gt;
&lt;br /&gt;
----&lt;br /&gt;
&lt;br /&gt;
Ecce Logo&lt;br /&gt;
&lt;br /&gt;
[[Immagine:Logovero.jpg]]&lt;br /&gt;
&lt;br /&gt;
Questa soluzione è quella che mi piace di più: si capisce che il faccione-logo deriva pari pari dal font usato per la scritta GOLEM.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
--- &lt;br /&gt;
&lt;br /&gt;
inserito da Giacomo il 13/12/2006&lt;br /&gt;
&lt;br /&gt;
Proposte per il logo (creato da Giuliano Panaroni http://www.gp-visualdesign.com/) per le nuove tessere (ma non solo)&lt;br /&gt;
&lt;br /&gt;
[[Immagine:Logob-w.png|200px]] [[Immagine:Logor-b.png|200px]]&lt;br /&gt;
&lt;br /&gt;
stesso soggetto in svariati colori: lo trovate qua: http://golem.linux.it/index.php/Immagine:Logo-multicolor.png&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Logo_del_GOLEM&amp;diff=3031</id>
		<title>Logo del GOLEM</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Logo_del_GOLEM&amp;diff=3031"/>
		<updated>2006-12-13T19:29:55Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Proposte per un nuovo logo del GOLEM&lt;br /&gt;
&lt;br /&gt;
----&lt;br /&gt;
&lt;br /&gt;
Ecco una bozza proposta da Hal, da rifare con opportuni programmi di grafica vettoriale.&lt;br /&gt;
&lt;br /&gt;
[[Immagine:logo1_golem.jpg]]&lt;br /&gt;
&lt;br /&gt;
Si tratta di una scritta in cui ogni lettera è scritta in un modulo di 2x3 quadretti. Il risultato è «roccioso» se la linea è irregolare, ma va benissimo anche con linea liscia.&lt;br /&gt;
&lt;br /&gt;
----&lt;br /&gt;
&lt;br /&gt;
Elisa ha provato a rifarlo con Sodipodi, questo e' il risultato esportato in png:&lt;br /&gt;
&lt;br /&gt;
[[Immagine:Logo_golem.png]]&lt;br /&gt;
&lt;br /&gt;
Se puo' andare bene, Elisa invia il file .svg originale!&lt;br /&gt;
&lt;br /&gt;
----&lt;br /&gt;
&lt;br /&gt;
Che ne dite di questa versione?&lt;br /&gt;
&lt;br /&gt;
[[Immagine:Logo_golem_occhi.png]]&lt;br /&gt;
&lt;br /&gt;
«Occhiacci di legno, perché mi guardate?»&lt;br /&gt;
&lt;br /&gt;
----&lt;br /&gt;
&lt;br /&gt;
Logo in versione '''ricorsiva'''   :o)&lt;br /&gt;
&lt;br /&gt;
[[Immagine:Logo_golem_occhi_ricors.png]]&lt;br /&gt;
&lt;br /&gt;
----&lt;br /&gt;
&lt;br /&gt;
Finalmente un &amp;quot;logo&amp;quot; e non una &amp;quot;scritta&amp;quot;.&lt;br /&gt;
&lt;br /&gt;
[[Immagine:logo_zero.png]]&lt;br /&gt;
&lt;br /&gt;
Senza bocca &amp;quot;ricorsiva&amp;quot; si capisce che il logo è la &amp;quot;O&amp;quot; di GOLEM?&lt;br /&gt;
&lt;br /&gt;
Qualcuno sa realizzarlo un po' meglio di me? Forse con la bocca più piccola.&lt;br /&gt;
&lt;br /&gt;
----&lt;br /&gt;
&lt;br /&gt;
Ecce Logo&lt;br /&gt;
&lt;br /&gt;
[[Immagine:Logovero.jpg]]&lt;br /&gt;
&lt;br /&gt;
Questa soluzione è quella che mi piace di più: si capisce che il faccione-logo deriva pari pari dal font usato per la scritta GOLEM.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
--- &lt;br /&gt;
&lt;br /&gt;
inserito da Giacomo il 13/12/2006&lt;br /&gt;
&lt;br /&gt;
Proposte per il logo (creato da Giuliano Panaroni http://www.gp-visualdesign.com/) per le nuove tessere (ma non solo)&lt;br /&gt;
&lt;br /&gt;
[[Immagine:Logo-multicolor.png|200px]] [[Immagine:Logob-w.png|200px]] [[Immagine:Logor-b.png|200px]]&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Logo_del_GOLEM&amp;diff=3030</id>
		<title>Logo del GOLEM</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Logo_del_GOLEM&amp;diff=3030"/>
		<updated>2006-12-13T19:28:19Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Proposte per un nuovo logo del GOLEM&lt;br /&gt;
&lt;br /&gt;
----&lt;br /&gt;
&lt;br /&gt;
Ecco una bozza proposta da Hal, da rifare con opportuni programmi di grafica vettoriale.&lt;br /&gt;
&lt;br /&gt;
[[Immagine:logo1_golem.jpg]]&lt;br /&gt;
&lt;br /&gt;
Si tratta di una scritta in cui ogni lettera è scritta in un modulo di 2x3 quadretti. Il risultato è «roccioso» se la linea è irregolare, ma va benissimo anche con linea liscia.&lt;br /&gt;
&lt;br /&gt;
----&lt;br /&gt;
&lt;br /&gt;
Elisa ha provato a rifarlo con Sodipodi, questo e' il risultato esportato in png:&lt;br /&gt;
&lt;br /&gt;
[[Immagine:Logo_golem.png]]&lt;br /&gt;
&lt;br /&gt;
Se puo' andare bene, Elisa invia il file .svg originale!&lt;br /&gt;
&lt;br /&gt;
----&lt;br /&gt;
&lt;br /&gt;
Che ne dite di questa versione?&lt;br /&gt;
&lt;br /&gt;
[[Immagine:Logo_golem_occhi.png]]&lt;br /&gt;
&lt;br /&gt;
«Occhiacci di legno, perché mi guardate?»&lt;br /&gt;
&lt;br /&gt;
----&lt;br /&gt;
&lt;br /&gt;
Logo in versione '''ricorsiva'''   :o)&lt;br /&gt;
&lt;br /&gt;
[[Immagine:Logo_golem_occhi_ricors.png]]&lt;br /&gt;
&lt;br /&gt;
----&lt;br /&gt;
&lt;br /&gt;
Finalmente un &amp;quot;logo&amp;quot; e non una &amp;quot;scritta&amp;quot;.&lt;br /&gt;
&lt;br /&gt;
[[Immagine:logo_zero.png]]&lt;br /&gt;
&lt;br /&gt;
Senza bocca &amp;quot;ricorsiva&amp;quot; si capisce che il logo è la &amp;quot;O&amp;quot; di GOLEM?&lt;br /&gt;
&lt;br /&gt;
Qualcuno sa realizzarlo un po' meglio di me? Forse con la bocca più piccola.&lt;br /&gt;
&lt;br /&gt;
----&lt;br /&gt;
&lt;br /&gt;
Ecce Logo&lt;br /&gt;
&lt;br /&gt;
[[Immagine:Logovero.jpg]]&lt;br /&gt;
&lt;br /&gt;
Questa soluzione è quella che mi piace di più: si capisce che il faccione-logo deriva pari pari dal font usato per la scritta GOLEM.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
--- &lt;br /&gt;
inserito da Giacomo il 13/12/2006&lt;br /&gt;
Bozze di logo (creato da Giuliano Panaroni http://www.gp-visualdesign.com/) per le nuove tessere (ma non solo)&lt;br /&gt;
&lt;br /&gt;
[[Immagine:Logo-multicolor.png|200px]] [[Immagine:Logob-w.png|200px]] [[Immagine:Logor-b.png|200px]]&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Logo_del_GOLEM&amp;diff=3029</id>
		<title>Logo del GOLEM</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Logo_del_GOLEM&amp;diff=3029"/>
		<updated>2006-12-13T19:27:31Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Proposte per un nuovo logo del GOLEM&lt;br /&gt;
&lt;br /&gt;
----&lt;br /&gt;
&lt;br /&gt;
Ecco una bozza proposta da Hal, da rifare con opportuni programmi di grafica vettoriale.&lt;br /&gt;
&lt;br /&gt;
[[Immagine:logo1_golem.jpg]]&lt;br /&gt;
&lt;br /&gt;
Si tratta di una scritta in cui ogni lettera è scritta in un modulo di 2x3 quadretti. Il risultato è «roccioso» se la linea è irregolare, ma va benissimo anche con linea liscia.&lt;br /&gt;
&lt;br /&gt;
----&lt;br /&gt;
&lt;br /&gt;
Elisa ha provato a rifarlo con Sodipodi, questo e' il risultato esportato in png:&lt;br /&gt;
&lt;br /&gt;
[[Immagine:Logo_golem.png]]&lt;br /&gt;
&lt;br /&gt;
Se puo' andare bene, Elisa invia il file .svg originale!&lt;br /&gt;
&lt;br /&gt;
----&lt;br /&gt;
&lt;br /&gt;
Che ne dite di questa versione?&lt;br /&gt;
&lt;br /&gt;
[[Immagine:Logo_golem_occhi.png]]&lt;br /&gt;
&lt;br /&gt;
«Occhiacci di legno, perché mi guardate?»&lt;br /&gt;
&lt;br /&gt;
----&lt;br /&gt;
&lt;br /&gt;
Logo in versione '''ricorsiva'''   :o)&lt;br /&gt;
&lt;br /&gt;
[[Immagine:Logo_golem_occhi_ricors.png]]&lt;br /&gt;
&lt;br /&gt;
----&lt;br /&gt;
&lt;br /&gt;
Finalmente un &amp;quot;logo&amp;quot; e non una &amp;quot;scritta&amp;quot;.&lt;br /&gt;
&lt;br /&gt;
[[Immagine:logo_zero.png]]&lt;br /&gt;
&lt;br /&gt;
Senza bocca &amp;quot;ricorsiva&amp;quot; si capisce che il logo è la &amp;quot;O&amp;quot; di GOLEM?&lt;br /&gt;
&lt;br /&gt;
Qualcuno sa realizzarlo un po' meglio di me? Forse con la bocca più piccola.&lt;br /&gt;
&lt;br /&gt;
----&lt;br /&gt;
&lt;br /&gt;
Ecce Logo&lt;br /&gt;
&lt;br /&gt;
[[Immagine:Logovero.jpg]]&lt;br /&gt;
&lt;br /&gt;
Questa soluzione è quella che mi piace di più: si capisce che il faccione-logo deriva pari pari dal font usato per la scritta GOLEM.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
--- &lt;br /&gt;
inserito da Giacomo il 13/12/2006&lt;br /&gt;
Bozze di logo (creato da Giuliano Panaroni http://www.gp-visualdesign.com/) per le nuove tessere (ma non solo)&lt;br /&gt;
[[Immagine:Logo-multicolor.png|200px]] [[Immagine:Logob-w.png|200px]] [[Immagine:Logor-b.png|200px]]&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=File:Logor-b.png&amp;diff=3028</id>
		<title>File:Logor-b.png</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=File:Logor-b.png&amp;diff=3028"/>
		<updated>2006-12-13T19:24:07Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: bozza logo nuovo in rosso e nero
creato da Giuliano Panaroni http://www.gp-visualdesign.com/&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;bozza logo nuovo in rosso e nero&lt;br /&gt;
creato da Giuliano Panaroni http://www.gp-visualdesign.com/&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=File:Logob-w.png&amp;diff=3027</id>
		<title>File:Logob-w.png</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=File:Logob-w.png&amp;diff=3027"/>
		<updated>2006-12-13T19:23:22Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: bozza nuovo logo in bianco e nero
creato da Giuliano Panaroni http://www.gp-visualdesign.com/&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;bozza nuovo logo in bianco e nero&lt;br /&gt;
creato da Giuliano Panaroni http://www.gp-visualdesign.com/&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=File:Logo-multicolor.png&amp;diff=3026</id>
		<title>File:Logo-multicolor.png</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=File:Logo-multicolor.png&amp;diff=3026"/>
		<updated>2006-12-13T19:22:30Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: bozza del nuovo logo... in 4 colori
creato da Giuliano Panaroni http://www.gp-visualdesign.com/&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;bozza del nuovo logo... in 4 colori&lt;br /&gt;
creato da Giuliano Panaroni http://www.gp-visualdesign.com/&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Utente:Jdoe&amp;diff=2948</id>
		<title>Utente:Jdoe</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Utente:Jdoe&amp;diff=2948"/>
		<updated>2006-10-30T12:19:26Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''John Doe'''&lt;br /&gt;
&lt;br /&gt;
[[Immagine:Giacomo-profile.JPG|250px]]&lt;br /&gt;
&lt;br /&gt;
[http://jdoe.netsons.org/ Giacomo Bagnoli]&lt;br /&gt;
&lt;br /&gt;
e-mail = giacomo.bagnoli_AT_portalis_it&lt;br /&gt;
&lt;br /&gt;
SIP Account sip = johndoe@ekiga.net&lt;br /&gt;
Jabber Account = john_doe@jabber.linux.it/PcTuner&lt;br /&gt;
&lt;br /&gt;
GPG Key ID = E0AA9501&lt;br /&gt;
&lt;br /&gt;
GPG Key fingerprint = 3E53 EBED 02D8 3F87 FF5D 128F D48B C17B E0AA 9501&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=File:Giacomo-profile.JPG&amp;diff=2947</id>
		<title>File:Giacomo-profile.JPG</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=File:Giacomo-profile.JPG&amp;diff=2947"/>
		<updated>2006-10-30T12:18:58Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: Giacomo (john doe)&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Giacomo (john doe)&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Utente:Jdoe&amp;diff=2946</id>
		<title>Utente:Jdoe</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Utente:Jdoe&amp;diff=2946"/>
		<updated>2006-10-30T12:12:13Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''John Doe'''&lt;br /&gt;
&lt;br /&gt;
[http://jdoe.netsons.org/ Giacomo Bagnoli]&lt;br /&gt;
&lt;br /&gt;
e-mail = giacomo.bagnoli_AT_portalis_it&lt;br /&gt;
&lt;br /&gt;
SIP Account sip = johndoe@ekiga.net&lt;br /&gt;
Jabber Account = john_doe@jabber.linux.it/PcTuner&lt;br /&gt;
&lt;br /&gt;
GPG Key ID = E0AA9501&lt;br /&gt;
&lt;br /&gt;
GPG Key fingerprint = 3E53 EBED 02D8 3F87 FF5D 128F D48B C17B E0AA 9501&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
	<entry>
		<id>https://wiki.golem.linux.it/index.php?title=Utente:Jdoe&amp;diff=2945</id>
		<title>Utente:Jdoe</title>
		<link rel="alternate" type="text/html" href="https://wiki.golem.linux.it/index.php?title=Utente:Jdoe&amp;diff=2945"/>
		<updated>2006-10-30T12:11:38Z</updated>

		<summary type="html">&lt;p&gt;Jdoe: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''John Doe'''&lt;br /&gt;
&lt;br /&gt;
[http://golem.linux.it/index.php?title=Utente:Jdoe Giacomo Bagnoli]&lt;br /&gt;
&lt;br /&gt;
e-mail = giacomo.bagnoli_AT_portalis_it&lt;br /&gt;
&lt;br /&gt;
SIP Account sip = johndoe@ekiga.net&lt;br /&gt;
Jabber Account = john_doe@jabber.linux.it/PcTuner&lt;br /&gt;
&lt;br /&gt;
GPG Key ID = E0AA9501&lt;br /&gt;
&lt;br /&gt;
GPG Key fingerprint = 3E53 EBED 02D8 3F87 FF5D 128F D48B C17B E0AA 9501&lt;/div&gt;</summary>
		<author><name>Jdoe</name></author>
	</entry>
</feed>