Differenze tra le versioni 73 e 74

Indice

Introduzione
Versioni Python 2 e 3
Shell python
Script
Esempi di script
Guide per principianti
Ulteriori risorse

Problemi in questa pagina? Segnalali in questa discussione

Introduzione

Python è un linguaggio di programmazione ad alto livello che ha raggiunto una grandissima popolarità ed è utilizzato in molti ambiti, dall'utilizzo di semplici script personali fino alla creazione di progetti altamente professionali.

L'utilizzo di una sintassi pulita e ordinata legate a una certa facilità di utilizzo, hanno fatto si che col tempo Python si sia rivelato ottimale come primo linguaggio da imparare per chi è interessato ad affacciarsi al mondo della programmazione.

La seguente pagina intende solo mostrare come utilizzare gli strumenti basilari su Ubuntu. Per approfondire l'utilizzo di Python si rimanda alla copiosa documentazione presente sul web. Nel capitolo Guide per principianti sono presenti alcune delle più apprezzate guide per muovere i primi passi.

Versioni Python 2 e 3

Su Ubuntu vengono preinstallate 2 differenti versioni: Python 2 e Python 3.
La nascita della versione 3 ha determinato un punto di rottura con il passato, tanto che le due versioni sono incompatibili fra loro. La versione 2, più precisamente Python 2.7 sarà supportata fino al 2020. Nel frattempo non verrà ulteriormente sviluppata, ricevendo solo aggiornamenti di sicurezza.

Questo ha generato una lenta situazione di transizione, dove lo sviluppo di nuove funzionalità è incentrato su Python 3 ma una mole considerevole di progetti si basano ancora su Python 2.

Situazione su Ubuntu

Desktop: con il pacchetto di installazione python, così come il comando da terminale, si intende la versione 2.7. Il pacchetto python3 e il relativo comando da terminale fanno riferimento, a seconda della versione di Ubuntu utilizzata, alla versione 3.4, 3.5, ecc..
Pertanto col generico python sul desktop Ubuntu si intende ancora la versione 2.
Mobile: su Ubuntu Phone è installata in modo predefinito la sola versione 3, nominata python3.

Shell python

Come consuetudine per la realizzazione di programmi si utilizzano file di testo sui quali scrivere il codice sorgente (vedere relativo capitolo). Tuttavia è possibile avviare all'interno del terminale una shell python interattiva sulla quale poter testare porzioni di codice.

Python 3: il comando:
```
python3
```
avvierà la versione 3 predefinita sul proprio sistema, ad es. la 3.4 su Ubuntu 14.04:
```
Python 3.4.3 (default, Nov 17 2016, 01:08:31) 
[GCC 4.8.4] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>
```
Se sono state installate versioni successive, ad es. la 3.5 e la si vuole utilizzare, sarà sufficiente specificarlo nel comando:
```
python3.5
```

Avviare il terminale.

Python 2: il comando:
```
python2
```
oppure semplicemente:
```
python
```

avvierà la versione 2.7. Oltre al prompt dei comandi verrà visualizzata l'intestazione:

Python 2.7.6 (default, Oct 26 2016, 20:30:19) 
[GCC 4.8.4] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>

Esempi in Python 3

Per testare i seguenti esempi è sufficiente digitare i comandi che appaiono accanto alla tripla freccia del prompt (>>>) e quindi premere Invio.

Alcune semplici istruzioni da passare al prompt per stampare scritte e per effettuare calcoli aritmetici. Le stringhe devono essere inserite in mezzo alle virgolette " ", mentre i numeri vengono digitati così come sono:
```
>>> print("Hello World!")
Hello World!
>>> print(2+3)
5
>>> print("2 + 3 = ",  2+3)
2 + 3 = 5
```

Per indicare i blocchi di codice si usa l'indentazione creata tramite il tasto TAB (Tab ⇆). In Python non è solo una buona abitudine del programmatore ma è obbligatoria. Per esempio il codice appartenente a un ciclo deve essere indentato:

>>> i = 0
>>> while i < 4:
...     i += 1
...     print("il doppio di", i, " e' ", i*2)
...
il doppio di 1  e'  2
il doppio di 2  e'  4
il doppio di 3  e'  6
il doppio di 4  e'  8

Altrimenti succede questo:

>>> i = 0
>>> while i < 4:
... i += 1
  File "<stdin>", line 2
    i += 1
    ^
IndentationError: expected an indented block

Uscire dall'interprete premendo Ctrl+D, oppure digitando il comando:
```
>>> exit()
```

Script

Come esempio pratico verrà creato un file con del codice Python 3 al suo interno che potrà essere richiamato dal terminale per essere eseguito.

Primo metodo

Aprire un editor di testo e inserire le seguenti righe:
```
print("Ciao mondo!")
```
Salvare nella propria Home il file come ciao.py.
Da terminale digitare:
```
python3 ciao.py
```
Verrà restituita la scritta:
```
Ciao mondo!
```

Secondo metodo

Nel comando del primo metodo python3 ciao.py può essere evitata la digitazione del termine python3, inserendo all'inizio dello script la direttiva:

#!/usr/bin/env python3

In alternativa è comune trovare la forma #!/usr/bin/python3.

Modificare il contenuto dello script in modo che risulti:
```
#!/usr/bin/env python3

print("Ciao mondo!")
```
Rendere lo script eseguibile con il comando:
```
chmod u+x ciao.py
```
Lanciare quindi lo script con il comando:
```
./ciao.py
```
che restituirà la scritta:
```
Ciao mondo!
```

Alcune differenze con Python 2

Partendo dallo script iniziale in Python 3 si nota già una differenza fondamentale nella sintassi. L'istruzione print è stata sostituita con la funzione print(). In Python 2 il comando nello script diviene:
```
print "Ciao mondo!"
```
Il comando di avvio del primo metodo deve essere adattato alla versione 2 di Python, pertanto diviene:
```
python2 ciao.py
```
oppure semplicemente:
```
python ciao.py
```
Andando a inserire la direttiva #!/usr/bin/env python3 come nel secondo metodo, anch'essa dovrà essere rapportata a Python 2, quindi:
```
#!/usr/bin/env python2
```
oppure semplicemente:
```
#!/usr/bin/env python
```

Esempi di script

Nelle pagine a seguire, sono presenti diversi script esemplificativi a difficoltà crescente:

Listati: esempi di alcuni programmi scritti in Python a difficoltà crescente.
Interfacce grafiche: esempi di alcuni programmi scritti in Python con semplice interfaccia grafica.

Guide per principianti

I seguenti testi sono indicati per chiunque si voglia avvicinare per la prima volta a un linguaggio di programmazione.

In italiano

Python 2: Pensare da informatico di Allen B. Downey, Jeffrey Elkner e Chris Meyers.
Python 2: Imparare a programmare di Alan Gauld.

In inglese

Python 3: How to think like a computer scientist riadattata da Brad Miller and David Ranum.
Python 3: Non-Programmer's Tutorial for Python 3 di Josh Cogliati.
Python 2: Learn Python the hard way di Zed A. Shaw.

Ulteriori risorse

CategoryProgrammazione

-  ⇤ ← Versione 73 del 03/01/2017 01.16.41 → 
  Dimensione: 8714
  Autore: jeremie2
  Commento:
+   ← Versione 74 del 19/01/2017 18.10.07 → ⇥
  Dimensione: 8604
  Autore: jeremie2
  Commento: Precedenza a python 3
-Le cancellazioni sono segnalate in questo modo.
+Le aggiunte sono segnalate in questo modo.
 Linea 33:
-Avviare il [[AmministrazioneSistema/RigaDiComando|terminale]].
 * '''Python 2''': il comando:{{{
python
}}}avvierà la versione 2.7. Oltre al prompt dei comandi verrà visualizzata l'intestazione:{{{
Python 2.7.6 (default, Oct 26 2016, 20:30:19) 
[GCC 4.8.4] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> 
}}}
-Linea 52:
+Linea 43:
+Avviare il [[AmministrazioneSistema/RigaDiComando|terminale]].
 * '''Python 2''': il comando:{{{
python2
}}}oppure semplicemente:{{{
python
}}}
avvierà la versione 2.7. Oltre al prompt dei comandi verrà visualizzata l'intestazione:{{{
Python 2.7.6 (default, Oct 26 2016, 20:30:19) 
[GCC 4.8.4] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> 
}}}
-Linea 53:
+Linea 56:
-== Esempi in Python 2 ==
+== Esempi in Python 3 ==
-Linea 58:
+Linea 61:
->>> print  "Hello World!"
+>>> print("Hello World!")
-Linea 60:
+Linea 63:
->>> print  2+3
+>>> print(2+3)
-Linea 62:
+Linea 65:
->>> print  "2 + 3 = ",  2+3
+>>> print("2 + 3 = ",  2+3)
-Linea 67:
+Linea 70:
->>> i=0
>>> while i<4:
...     i+=1
...     print "il doppio di", i, " e' ", i*2
+>>> i = 0
>>> while i < 4:
...     i += 1
...     print("il doppio di", i, " e' ", i*2)
-Linea 76:
+Linea 79:
->>>
-Linea 78:
+Linea 80:
->>> i=0
>>> while i < 10:
... i=i+1
+>>> i = 0
>>> while i < 4:
... i += 1
-Linea 82:
+Linea 84:
-    i=i+1
+    i += 1
-Linea 85:
+Linea 87:
->>>
-Linea 94:
+Linea 95:
-Come esempio pratico verrà creato un file con del codice ('''Python 2''') al suo interno che potrà essere richiamato dal terminale per essere eseguito.
+Come esempio pratico verrà creato un file con del codice '''Python 3''' al suo interno che potrà essere richiamato dal terminale per essere eseguito.
-Linea 100:
+Linea 101:
-print  "Ciao mondo!"
+print("Ciao mondo!")
-Linea 104:
+Linea 105:
-python ciao.py
+python3 ciao.py
-Linea 113:
+Linea 114:
-Nel comando del [[#primo|primo metodo]] `python ciao.py` può essere evitata la digitazione del termine `python`, inserendo all'inizio dello script la direttiva:{{{
#!/usr/bin/env python
#!/usr/bin/env python
}}}In alternativa è comune trovare la forma `#!/usr/bin/python`.
+Nel comando del [[#primo|primo metodo]] `python3 ciao.py` può essere evitata la digitazione del termine `python3`, inserendo all'inizio dello script la direttiva:{{{
#!/usr/bin/env python3
#!/usr/bin/env python3
}}}In alternativa è comune trovare la forma `#!/usr/bin/python3`.
-Linea 119:
+Linea 120:
-#!/usr/bin/env python
#!/usr/bin/env python
print  "Ciao mondo!"
+#!/usr/bin/env python3
#!/usr/bin/env python3

print("Ciao mondo!")
-Linea 132:
+Linea 134:
-== Alcune differenze con Python3 ==
+== Alcune differenze con Python 2 ==
-Linea 134:
+Linea 136:
- * Partendo dallo script [[#primo|iniziale]] in '''Python 3''' si nota già una differenza fondamentale nella sintassi. L'istruzione `print` è stata sostituita con la funzione `print()`. Pertanto il comando nello script diviene:{{{
print("Ciao mondo!")
+ * Partendo dallo script [[#primo|iniziale]] in '''Python 3''' si nota già una differenza fondamentale nella sintassi. L'istruzione `print` è stata sostituita con la funzione `print()`. In '''Python 2''' il comando nello script diviene:{{{
print "Ciao mondo!"
-Linea 137:
+Linea 139:
- * Il comando di avvio del primo metodo deve essere adattato alla versione '''3''' di '''Python''', pertanto diviene:{{{
python3 ciao.py
}}}oppure specificando una versione in particolare, ad es. la 3.5, il comando diviene:{{{
python3.5 ciao.py
+ * Il comando di avvio del primo metodo deve essere adattato alla versione '''2''' di '''Python''', pertanto diviene:{{{
python2 ciao.py
}}}oppure semplicemente:{{{
python ciao.py
-Linea 142:
+Linea 144:
- * Andando a inserire la direttiva `#!/usr/bin/env python` come nel [[#secondo|secondo metodo]], anch'essa dovrà essere rapportata alla versione di '''Python''' desiderata, quindi:{{{
#!/usr/bin/env python3
#!/usr/bin/env python3
}}}oppure specificandone una versione particolare per un determinato utilizzo. Ad es. per la 3.5:{{{
#!/usr/bin/env python3.5
#!/usr/bin/env python3.5
+ * Andando a inserire la direttiva `#!/usr/bin/env python3` come nel [[#secondo|secondo metodo]], anch'essa dovrà essere rapportata a '''Python 2''', quindi:{{{
#!/usr/bin/env python2
#!/usr/bin/env python2
}}}oppure semplicemente:{{{
#!/usr/bin/env python
#!/usr/bin/env python