martedì 18 Giugno 2019

Download in corso

Grazie per aver scaricato da Softwareone.it

Introduzione a Python

Python è un linguaggio di programmazione potente e di facile apprendimento. Utilizza efficienti strutture dati di alto livello e un semplice ma efficace approccio alla programmazione orientata agli oggetti.

L’interprete Python e l’ampia libreria standard sono liberamente disponibili, in file sorgenti o binari, per tutte le principali piattaforme sul sito web di Python, http://www.python.org/, e possono essere liberamente distribuiti. Lo stesso sito contiene anche, oltre alle distribuzioni, puntatori a molti moduli Python liberi e gratuiti di terzi, interi programmi, strumenti di sviluppo e documentazione addizionale. 
L’interprete Python è facilmente estendibile con nuove funzioni o tipi di dato implementati in C o C++

Per una descrizione degli oggetti e dei moduli standard, si veda il documento La libreria di riferimento di Python. Il manuale di riferimento di Python fornisce una definizione più formale del linguaggio. Se s’intendono scrivere estensioni in C o C++, si legga Extending and Embedding the Python Interpreter e Python/C API Reference. Ci sono anche numerosi libri che si occupano in modo approfondito di Python.

Python è un linguaggio interpretato, e questo può far risparmiare molto tempo durante lo sviluppo del programma, poiché non sono necessari compilazione e linking. L’interprete può essere utilizzato interattivamente, il che rende semplice fare esperimenti con le funzionalità del linguaggio, scrivere programmi usa­e­getta o testare funzioni durante lo sviluppo bottom­up di programmi. È anche un’utile calcolatrice.

Python consente di scrivere programmi molto compatti e di facile lettura. Tipicamente i programmi scritti in Python sono molto più brevi degli equivalenti in C o C++, per numerose ragioni:i tipi di dati di alto livello consentono di esprimere operazioni complesse in una singola istruzione;le istruzioni vengono raggruppate tramite indentazione invece che con parentesi di inizio/fine;non è necessario dichiarare variabili e argomenti.

Python è estendibile: se sapete programmare in C è facile aggiungere all’interprete nuove funzioni o moduli built­in, per eseguire operazioni critiche alla massima velocità o per creare link a programmi Python delle librerie che possono essere disponibili solo in forma di file binari (ad esempio librerie grafiche proprietarie). 
L’origine del nome deriva dallo show televisivo della BBC “Monty Python’s Flying Circus” e non ha niente a che fare con i pericolosi rettili omonimi.

L’interprete Python

L’interprete Python sulle macchine UNIX sulle quali è disponibile di solito è installato in /usr/local/bin/; aggiungendo /usr/local/bin al percorso di ricerca della shell è possibile farlo partire digitando il comando:

Python dalla shell.

Un secondo modo di lanciare l’interprete è tramite “python ‐c comando [arg] …”, che esegue la/e istruzione/i contenuta/e in comando, analogamente a quanto succede per l’opzione c della shell. Dato che spesso le istruzioni Python contengono spazi o altri caratteri che la shell considera speciali, è molto meglio racchiudere integralmente comando tra doppie virgolette.

Modo interattivo

Quando i comandi vengono letti da un terminale, si dice che l’interprete è in modalità interattiva. In questa modalità esso presenta, in attesa del prossimo comando, un prompt primario, composto di solito da tre segni consecutivi di maggiore (“>>> “); per le righe di continuazione il prompt predefinito è quello secondario, tre punti consecutivi (“… “). L’interprete stampa a video un messaggio di benvenuto in cui compare il numero di versione e un avviso di copyright prima del prompt iniziale, p.e.:

python Python 1.5.2b2 (#1, Feb 28 1999, 00:02:06) [GCC 2.8.1] on sunos5 Copyright 1991‐1995 Stichting Mathematisch Centrum, Amsterdam >>>

Quando sopravviene un errore, l’interprete stampa un messaggio di errore e una traccia dello stack. Se si trova in modalità interattiva ritorna poi al prompt primario; se l’input proveniva da un file, esce con uno stato diverso da zero dopo aver stampato la traccia dello stack.

Alcuni errori sono incondizionatamente fatali e provocano un’uscita con uno stato diverso da zero; ciò accade quando si tratta di problemi interni dell’interprete e di alcuni casi di esaurimento della memoria.

Digitando il carattere di interruzione (di solito Ctrl­C o CANC) al prompt primario o secondario si cancella l’input e si ritorna al prompt primario.

Usare Python come una calcolatrice

Proviamo con qualche semplice comando Python. Avviate l’interprete e si attendete il prompt primario, “>>> “. Non dovrebbe metterci molto.

L’interprete si comporta come una semplice calcolatrice: si può digitare un’espressione ed esso fornirà il valore risultante. La sintassi delle espressioni è chiara: gli operatori +, ‐, * e / funzionano come nella maggior parte degli altri linguaggi (p.e. Pascal o C); le parentesi possono essere usate per raggruppare operatori e operandi. Ad esempio:

>>> 2+2
4
>>> # Questo è un commento
... 2+2
4
>>> 2+2	# e un commento sulla stessa riga del codice 4
>>> (50‐5*6)/4 5
>>> # Una divisione tra interi restituisce solo il quoziente:
... 7/3 2
>>> 7/‐3
‐3

Come in C, il segno di uguale (“=”) è usato per assegnare un valore ad una variabile.Il valore di un assegnamento non viene stampato.

Un valore può essere assegnato simultaneamente a variabili diverse:

>>> x = y = z = 0	# Zero x, y e z
>>> x 0
>>> y 0
>>> z 0

Le operazioni in virgola mobile sono pienamente supportate; in presenza di operandi di tipo misto gli interi vengono convertiti in virgola mobile:

>>> 3 * 3.75 / 1.5
7.5
>>> 7.0 / 2
3.5

I numeri complessi vengono sempre rappresentati come due numeri in virgola mobile, la parte reale e quella immaginaria. Per estrarre queste parti da un numero complesso z si usino z.real e z.imag.

>>> a=1.5+0.5j
>>> a.real 1.5
>>> a.imag 0.5

Le funzioni di conversione in virgola mobile e intero (float(), int() e long()) non funzionano con i numeri complessi: non c’è alcun modo corretto per convertire un numero complesso in numero reale. Usate abs(z) per ottenere la sua grandezza (in virgola mobila) o z.real per ottenere la sua parte reale.

>>> a=3.0+4.0j
>>> float(a)
Traceback (most recent call last):
File "stdin>", line 1, in ?
TypeError: can't convert complex to float; use abs(z)
>>> a.real 3.0
>>> a.imag 4.0
>>> abs(a)	# sqrt(a.real**2 + a.imag**2) 5.0
>>>

In modo interattivo, l’ultima espressione stampata è assegnata alla variabile _. Questo facilita i calcoli in successione quando si sta usando Python come calcolatrice da tavolo, ad esempio:

>>> tassa = 12.5 / 100
>>> prezzo = 100.50
>>> prezzo * tassa 12.5625
>>> prezzo + _ 113.0625
>>> round(_, 2)
113.06
>>>

Questa variabile dev’essere trattata dall’utente come di sola lettura. Non le si deve assegnare esplicitamente un valore, si creerebbe una variabile locale indipendente con lo stesso nome che maschererebbe la variabile built­in ed il suo comportamento particolare.

Stringhe

Oltre ai numeri, Python può anche manipolare stringhe, che possono essere espresse in diversi modi. Possono essere racchiuse tra apici singoli o virgolette:

>>> 'spam eggs' 'spam eggs'
>>> 'doesn\'t' "doesn't"
>>> "doesn't" "doesn't"
>>> '"Yes," he said.'
'"Yes," he said.'
>>> "\"Yes,\" he said." '"Yes," he said.'
>>> '"Isn\'t," she said.'
'"Isn\'t," she said.'

Le stringhe costanti possono estendersi su più righe in modi diversi. Si possono scrivere lunghe righe usando le barre oblique inverse (NdT: il cosiddetto “escape”) come ultimo carattere di riga, questo indicherà che la riga successiva sarà in realtà la logica continuazione della precedente:


ciao = “Questa è una stringa abbastanza lunga che contiene\n\ parecchie righe di testo proprio come si farebbe in C.\n\ Si noti che gli spazi bianchi all’inizio della riga sono\ significativi.”

print ciao

Si noti che il carattere di fine riga deve sempre essere inserito in una stringa usando \n; il carattere di fine riga successivo, composto dalla barra obliqua inversa viene ignorato. L’esempio verrà quindi stampato così:

Questa è una stringa abbastanza lunga che contiene parecchie righe di testo proprio come si farebbe in C. Si noti che gli spazi bianchi all’inizio della riga sono significativi.


Se si volesse comporre una stringa letterale “raw”, comunque, la sequenza \n non verrebbe convertita nel fine riga e, insieme alla barra obliqua inversa alla fine della riga del sorgente, si ritroverebbero entrambe le sequenze come nella stringa data. Quindi, l’esempio:

ciao = r”Questa è una stringa abbastanza lunga che contiene\n\ parecchie righe di testo proprio come si farebbe in C.” 

print ciao

stamperebbe:

Questa è una stringa abbastanza lunga che contiene\n\ parecchie righe di testo proprio come si farebbe in C.

Oppure le stringhe possono essere circondate da un paio di virgolette o apici tripli corrispondenti: “”” o ”’. Non è necessario proteggere i caratteri di fine riga quando si usano le triple virgolette, questi verranno inclusi nella stringa.

print “””
Uso: comando [OPZIONI]
‐h Visualizza questo messaggio
‐H hostname Hostname per connettersi a 
“””

produrrà il seguente output:

Uso: comando [OPZIONI]
‐h Visualizza questo messaggio
‐H hostname Hostname per connettersi a

L’interprete stampa il risultato delle operazioni sulle stringhe nello stesso modo in cui vengono inserite in input: tra virgolette, con virgolette interne ed altri caratteri particolari protetti da barre oblique inverse (NdT: ‘backslash’), per mostrare il loro esatto valore.

Le stringhe possono essere concatenate (incollate assieme) tramite l’operatore + e ripetute tramite *:

>>> parola = 'Aiuto' + 'A'
>>> parola 'AiutoA'
>>> '' + <parola*5 + '>' '<AiutoAAiutoAAiutoAAiutoAAiutoA>'

Due stringhe letterali consecutive vengono concatenate automaticamente; la prima riga dell’esempio precedente poteva anche essere scritta come “parola = ‘Aiuto’ ‘A'”; questo funziona solo con due stringhe di testo, non con espressioni arbitrarie che comprendano stringhe:

>>> 'str' 'ing'	#	<‐Questo è ok 'string'
>>> 'str'.strip() + 'ing'	#	<‐Questo è ok 'string'
>>> 'str'.strip() 'ing'	#	<‐Questo non è valido File "<stdin>", line 1, in ?
'str'.strip() 'ing'
^ SyntaxError: invalid syntax

Le stringhe possono essere indicizzate come in C, il primo carattere di una stringa ha indice 0. Non c’è alcun tipo associato al carattere di separazione; un carattere è semplicemente una stringa di lunghezza uno. Come in Icon, possono essere specificate sottostringhe con la notazione a fette (NdT: ‘slice’): due indici separati dal carattere due punti.

>>> parola[4] 'o'
>>> parola[0:2] 'Ai'
>>> parola[2:4] 'ut'

A differenza di quanto avviene in C, le stringhe Python non possono essere modificate. Un’assegnazione effettuata su un indice di una stringa costituisce un errore:

>>> parola[0] = 'x' Traceback (most recent call last): File "<stdin>", line 1, in ?
TypeError: object doesn't support item assignment
>>> parola[:1] = 'Lavagna' Traceback (most recent call last):
File "", line 1, in ?
TypeError: object doesn't support slice assignment

Comunque, creare una nuova stringa combinando i contenuti è semplice ed efficiente:

>>> 'x' + parola[1:] 'xiutoA'
>>> 'Lavagna' + parola[5] 'LavagnaA'

Ecco un’utile variante delle operazioni di affettamento: s[:i] + s[i:] equivale a s.

>>> parola[:2] + parola[2:] 'AiutoA'
>>> parola[:3] + parola[3:] 'AiutoA'

Gli indici possono essere numeri negativi, per iniziare il conteggio da destra. Ad esempio:

>>> parola[‐1]	# L'ultimo carattere 'A'
>>> parola[‐2]	# Il penultimo carattere 'o'
>>> parola[‐2:]	# Gli ultimi due caratteri 'oA'
>>> parola[:‐2]	# Tutta la stringa eccetto i due ultimi caratteri 'Aiut'

Si noti però che ­0 è la stessa cosa di 0, quindi non si conta dall’estremità destra!

La funzione built­in len() restituisce la lunghezza di una stringa:

>>> s = 'supercalifragicospiristicalidoso'
>>> len(s) 32

A partire da Python 2.0 il programmatore ha a sua disposizione un nuovo tipo di dato testo: l’oggetto Unicode. Può essere utilizzato per immagazzinare e manipolare dati Unicode (si veda http://www.unicode.org/

Creare stringhe Unicode in Python è semplice quanto creare stringhe normali:

>>> u’Ciao mondo !’
u’Ciao mondo !’

Il carattere “u” minuscolo davanti agli apici indica che si vuole creare una stringa Unicode. Se si desidera includere nella stringa caratteri speciali, lo si può fare usando la codifica Python Unicode­ Escape. Il seguente esempio mostra come fare:

>>> u’Ciao\u0020mondo !’
u’Ciao mondo !’

La sequenza di escape \u0020 inserisce il carattere Unicode con ordinale esadecimale 0x0020 (il carattere di spazio) nella posizione indicata.

Per gli esperti, c’è anche una modalità raw, proprio come per le stringhe normali. Si deve prefissare una ‘ur’ minuscola alla stringa per far sì che Python usi la codifica Raw­Unicode­Escape. Non farà altro che applicare la conversione \uXXXX di cui sopra nel caso ci sia un numero dispari di barre oblique inverse davanti alla ‘u’ minuscola.

>>> ur’Ciao\u0020mondo !’ u’Ciao mondo !’
>>> ur’Ciao\\u0020mondo !’ u’Ciao\\\\u0020mondo !’

La modalità raw è utile perlopiù quando si devono introdurre un sacco di barre oblique inverse, p.e. nelle espressioni regolari.
La funzione built­in unicode()permette l’accesso a tutti i codec (COdificatori e DECodificatori) Unicode ufficiali. Alcune delle codifiche più note nelle quali tali codec possono effettuare la conversione sono: Latin­1, ASCII, UTF­8 e UTF­16. Le ultime due sono codifiche a lunghezza variabile che permettono di memorizzare caratteri Unicode in uno o più byte. La codifica predefinita è normalmente impostata ad ASCII, che permette tutti i caratteri nell’intervallo da 0 a 127 e scarta tutti gli altri emettendo un errore. Quando si stampa una stringa Unicode, scrivendola in un file o convertendola con str(), viene usata la codifica predefinita.

>>> u"abc" u'abc'
>>> str(u"abc") 'abc'
>>> u"äöü" u'\xe4\xf6\xfc'
>>> str(u"äöü")
Traceback (most recent call last): File "<stdin>", line 1, in ?
UnicodeEncodeError: 'ascii' codec can't encode characters in position 0‐2: ordinal not in range(128)

Per convertire una stringa Unicode in una 8­bit si usa una specifica codifica, gli oggetti Unicode forniscono il metodo encode() che prende un argomento, il nome della codifica. Per le codifiche sono preferiti i nomi in minuscolo.

>>> u”äöü”.encode(‘utf‐8’) 
‘\xc3\xa4\xc3\xb6\xc3\xbc’

Se si hanno dei dati in una codifica specifica e si vuole produrre una stringa Unicode corrispondente, si può usare la funzione unicode(), con il nome della codifica come secondo argomento.

>>> unicode(‘\xc3\xa4\xc3\xb6\xc3\xbc’, ‘utf‐8’)
u’\xe4\xf6\xfc’

Liste

Python riconosce una certa quantità di tipi di dati composti, usati per raggruppare insieme altri valori. Il più versatile è il tipo lista, che può essere scritto come una lista, compresa tra parentesi quadre, di valori (gli elementi della lista) separati da virgole. Gli elementi della lista non devono essere necessariamente tutti dello stesso tipo.

>>> a = [‘spam’, ‘eggs’, 100, 1234]

>>> a
[‘spam’, ‘eggs’, 100, 1234]

Come per gli indici delle stringhe, gli indici delle liste iniziano da 0, e anche le liste possono essere affettate, concatenate e così via:

>>> a[0]
'spam'
>>> a[3] 1234
>>> a[‐2] 100
>>> a[1:‐1]
['eggs', 100]
>>> a[:2] + ['bacon', 2*2]
['spam', 'eggs', 'bacon', 4]
>>> 3*a[:3] + ['Boe!']
['spam', 'eggs', 100, 'spam', 'eggs', 100, 'spam', 'eggs', 100, 'Boe!']

Al contrario delle stringhe, che sono immutabili, è possibile modificare gli elementi individuali di una lista:

>>> a
['spam', 'eggs', 100, 1234]
>>> a[2] = a[2] + 23
>>> a
['spam', 'eggs', 123, 1234]

È anche possibile assegnare valori alle fette, e questo può pure modificare le dimensioni della lista:

>>> # Rimpiazza alcuni elementi:
... a[0:2] = [1, 12]
>>> a
[1, 12, 123, 1234]
>>> # Rimuove alcuni elementi:
... a[0:2] = []
>>> a
[123, 1234]
>>> # Inserisce alcuni elementi:
... a[1:1] = ['bletch', 'xyzzy']
>>> a
[123, 'bletch', 'xyzzy', 1234]
>>> a[:0] = a	# Inserisce (una copia di) se stesso all'inizio
>>> a
[123, 'bletch', 'xyzzy', 1234, 123, 'bletch', 'xyzzy', 1234]

La funzione built­in len() si applica anche alle liste:

>>> len(a)
8

È possibile avere delle liste annidate (contenenti cioè altre liste), ad esempio:

>>> q = [2, 3]
>>> p = [1, q, 4]
>>> len(p) 3
>>> p[1] [2, 3]
>>> p[1][0] 2
>>> p[1].append('xtra')	# Si veda la sezione 5.1
>>> p
[1, [2, 3, 'xtra'], 4]
>>> q
[2, 3, 'xtra']

L’istruzione print stampa a video il valore dell’espressione, o delle espressioni, che le viene passata. 
Le stringhe vengono stampate senza virgolette, e viene inserito uno spazio tra gli elementi, quindi si possono formattare elegantemente i risultati, come in questo esempio:

>>> i = 256*256
>>> print ‘Il valore di i è’, i
Il valore di i è 65536

E’ possibile scaricare Python da qui