Python: differenze tra le versioni
Contenuto cancellato Contenuto aggiunto
m intestazioni |
Funzionalità collegamenti suggeriti: 2 collegamenti inseriti. Etichette: Modifica visuale Modifica da mobile Modifica da web per mobile Attività per i nuovi utenti Suggerito: aggiungi collegamenti |
||
| (680 versioni intermedie di oltre 100 utenti non mostrate) | |||
Riga 1:
{{nota disambigua}}
{{Linguaggio di programmazione
|nome = Python
|immagine =
|didascalia =
|autore =
|data =
|versione =
|utilizzo = general-purpose, [[linguaggio di scripting|scripting]]
|paradigmi =
|tipizzazione = [[Tipizzazione dinamica|dinamica]]
|specifiche =
|estensione =
|influenzato_da =
|ha_influenzato = [[Boo (linguaggio)|Boo]], [[Cobra (linguaggio di programmazione)|Cobra]], [[CoffeeScript]], [[D (linguaggio di programmazione)|D]], [[F Sharp|F#]], [[Go (linguaggio di programmazione)|Go]], [[Groovy]], [[JavaScript]], [[Julia (linguaggio di programmazione)|Julia]], [[Ruby (linguaggio di programmazione)|Ruby]], [[Swift (linguaggio di programmazione)|Swift]]
|implementazione_riferimento =
|sistema_operativo = [[Multipiattaforma]]
|lingua =
|licenza =
|sito_web =
}}
'''Python''' è un [[linguaggio di programmazione ad alto livello]], [[programmazione orientata agli oggetti|orientato a oggetti]], adatto, tra gli altri usi, a sviluppare [[applicazione (informatica)|applicazioni]] distribuite, [[scripting]], [[Calcolo (matematica)|computazione numerica]] e [[Testing#Il collaudo di sistema|system testing]].
Ideato dall'[[Paesi Bassi|olandese]] [[Guido van Rossum]] all'inizio degli [[Anni 1990|anni novanta]], è spesso paragonato a [[Ruby (linguaggio di programmazione)|Ruby]], [[Tcl]], [[Perl]], [[JavaScript]], [[Visual Basic]] o [[Scheme]]<ref>Dal file ''README'' della distribuzione 2.6.4: "''What is Python anyway? Python is an interpreted, interactive object-oriented programming language suitable (amongst other uses) for distributed application development, scripting, numeric computing and system testing. Python is often compared to Tcl, Perl, Java, JavaScript, Visual Basic or Scheme.''"</ref>. Il nome fu scelto per la passione dello stesso inventore verso i [[Monty Python]] e per la loro serie televisiva ''[[Monty Python's Flying Circus]]''<ref>Fonte: {{cita web |url=https://www.python.org/search/hypermail/python-1992/0001.html |titolo=Copia archiviata |accesso=27 ottobre 2009 |urlmorto=sì |urlarchivio=https://web.archive.org/web/20091217210327/http://www.python.org/search/hypermail/python-1992/0001.html |dataarchivio=17 dicembre 2009 }}</ref>.
Spesso è tra i primi [[Linguaggio di programmazione|linguaggi di programmazione]] a essere studiati dai neofiti, per la sua somiglianza a uno [[Pseudocodice|pseudo-codice]], e di frequente viene usato per simulare la creazione di software grazie alla flessibilità di sperimentazione consentita, che permette al programmatore di organizzare le idee durante lo sviluppo, come per esempio il creare un gioco tramite [[Pygame]] oppure il [[back-end]] di un sito web tramite [[Flask (informatica)|Flask]] o [[Django (informatica)|Django]].
Python dispone anche di una sezione grafica, il modulo Python Turtle Graphics, che permette di applicare le righe di codici alla grafica.
== Descrizione ==
È un linguaggio che ha tra i principali obiettivi: [[tipizzazione dinamica|dinamicità]], {{chiarire|semplicità e flessibilità. Python è un linguaggio semplice, che è stato progettato appositamente per essere facilmente comprensibile, la cui sintassi si avvicina estremamente al linguaggio naturale (incorporandone alcuni aspetti). Inoltre la potenza di Python è sicuramente il fatto di essere altamente flessibile, prestandosi ad un ampio spettro di utilizzi grazie alle sue numerose librerie. }}.
Supporta multipli [[paradigma di programmazione|paradigmi di programmazione]], tra cui quello [[programmazione orientata agli oggetti|a oggetti]] e quello [[programmazione funzionale|funzionale]].
Le caratteristiche più immediatamente riconoscibili di Python sono le [[variabile (informatica)|variabili]] non tipizzate e l'uso dell'[[indentazione]] per la sintassi delle specifiche, al posto delle più comuni parentesi.
Altre caratteristiche distintive sono l'[[overloading]] di operatori e funzioni tramite [[delegation|delegati]], la presenza di un ricco assortimento di tipi e funzioni di base e librerie standard, sintassi avanzate quali ''slicing'' e ''list comprehension''.
Il controllo dei tipi è [[Tipizzazione forte|forte]] (''strong typing'') e viene eseguito a ''[[run-time]]'' (''dynamic typing''): una variabile è un contenitore a cui viene associata un'etichetta (il nome) che può essere associata a diversi contenitori anche di tipo diverso durante il suo tempo di vita. Fa parte di Python un sistema ''[[garbage collector]]'' per la liberazione e il recupero automatici della memoria con cui si lavora.
Python ha qualche somiglianza con [[Perl]], ma i suoi progettisti hanno scelto una sintassi più essenziale e uniforme con l'obiettivo di migliorare la leggibilità del codice. Analogamente a [[Perl]] è classificato spesso come [[Linguaggio di scripting|linguaggio di ''scripting'']], ma pur essendo utile per scrivere [[script]] di sistema, in alternativa per esempio a [[bash]], la grande quantità di librerie disponibili e la facilità con cui il linguaggio permette di scrivere software [[Modularità (informatica)|modulare]] favoriscono anche lo sviluppo di applicazioni molto complesse.
=== Altre caratteristiche ===
[[File:esempio Python.png|miniatura|destra|[[Codice sorgente]] di un programma scritto in Python]]
[[File:Python_add5_syntax.svg|miniatura|destra|Esempio di codice sorgente scritto in Python]]
Sebbene Python venga in genere considerato e presentato come un [[linguaggio interpretato]], in realtà il [[codice sorgente]] non viene convertito direttamente in [[linguaggio macchina]], ma passa prima da una fase di pre-compilazione in ''[[bytecode]]'', che viene quasi sempre riutilizzato dopo la prima esecuzione del programma, evitando così di dover reinterpretare ogni volta il sorgente e migliorando le prestazioni. Inoltre è possibile distribuire programmi Python direttamente in bytecode, saltando totalmente la fase di interpretazione da parte dell'utilizzatore finale e ottenendo programmi Python a sorgente chiuso<ref>{{Cita web|url=http://effbot.org/pyfaq/how-do-i-create-a-pyc-file.htm|titolo=How do I create a .pyc file?|sito=effbot.org|accesso=2020-05-28|dataarchivio=3 giugno 2020|urlarchivio=https://web.archive.org/web/20200603024428/http://effbot.org/pyfaq/how-do-i-create-a-pyc-file.htm|urlmorto=sì}}</ref>.
[[File:Run Module Python.png|miniatura|408x408px|[[Menù a tendina]] dal quale si può eseguire il programma cliccando su "Run Module" o con lo shortcut F5 da [[windows 10]] in poi.]]
Come il linguaggio [[Lisp]] e a differenza del Perl, l'[[Interprete (informatica)|interprete]] Python supporta anche un modo d'uso interattivo ([[Read–eval–print loop|REPL]]) attraverso cui è possibile inserire codice direttamente da un terminale, visualizzando immediatamente il risultato.
[[File:Screenshot schermata Python.png|miniatura|Esempio di alcuni [[Codice sorgente|codici sorgente]] scritti con l'[https://www.html.it/pag/15610/linterprete-python-e-lidle/ IDLE] di Python 3.8.5]]
Inoltre l'interprete Python è contenuto nella libreria standard, perciò come in molti altri linguaggi interpretati è possibile far valutare stringhe arbitrarie nel contesto corrente. È possibile passare all'interprete anche un contesto completamente diverso, sotto forma di liste che contengono l'elenco dei simboli definiti.
Python dispone anche di un ''[[framework]]'' per lo ''[[unit testing]]'' che supporta lo sviluppo di test unitari automatici.
=== Prestazioni ===
Se paragonato ai linguaggi compilati ''statically typed'', come ad esempio il [[C (linguaggio)|C]], la velocità di esecuzione non è uno dei punti di forza di Python<ref>{{Cita web|url=https://benchmarksgame-team.pages.debian.net/benchmarksgame/fastest/python3-gcc.html|titolo=Python 3 vs C gcc - Which programs are fastest? {{!}} Computer Language Benchmarks Game|sito=benchmarksgame-team.pages.debian.net|accesso=2020-05-28}}</ref>, specie nel calcolo matematico. Inoltre, il programma si basa unicamente su un core, e il ''[[multithreading]]'' è presente al solo livello astratto. Esisteva un'estensione, [[Psyco (software)|Psyco]] <ref>{{Cita web|url=http://psyco.sourceforge.net/|titolo=Psyco - Home Page|sito=psyco.sourceforge.net|accesso=2020-05-28}}</ref>, il cui sviluppo è terminato nel 2012, che era una sorta di [[compilatore JIT]], in grado di velocizzare in modo notevole alcuni tipi di codice, specialmente l'implementazione di algoritmi, a scapito dell'aumento di memoria utilizzata. Un progetto attuale e attivamente sviluppato per migliorare le prestazioni del codice Python grazie a un compilatore JIT è [[PyPy]]<ref>{{Cita web|url=https://www.pypy.org/|titolo=PyPy|autore=The PyPy Team|sito=PyPy|data=2019-12-28|lingua=en|accesso=2020-05-28}}</ref>.
Python permette di aggirare in modo facile l'ostacolo delle performance pure: è infatti relativamente semplice scrivere un'estensione in C o [[C++]] e poi utilizzarla all'interno di Python, sfruttando così l'elevata velocità di un linguaggio compilato solo nelle parti in cui effettivamente serve e sfruttando invece la potenza e versatilità di Python per tutto il resto del software<ref>{{Cita web|url=https://realpython.com/python-bindings-overview/|titolo=Python Bindings: Calling C or C++ From Python – Real Python|autore=Real Python|sito=realpython.com|lingua=en|accesso=2020-05-28}}</ref>.
=== Implementazioni ===
* [[CPython]]: è l'implementazione di riferimento del linguaggio Python. Scritto in [[C (linguaggio di programmazione)|C]] e Python, è l'implementazione più usata in assoluto;<ref>{{cita web|url=https://github.com/python/cpython|titolo=CPython|lingua=en|accesso=2024-10-05}}</ref>
* [[Jython]]: implementazione basata su [[Java (linguaggio di programmazione)|Java]];<ref>[http://www.jython.org/ Jython: Python for the Java Platform]</ref>
* [[IronPython]]: implementazione [[C sharp|C#]] pensata per l'integrazione con l'ecosistema [[Microsoft .NET|.NET]];<ref>[http://ironpython.net/ IronPython: the Python programming language for the .NET Framework]</ref>
* PyS60: implementazione per [[Symbian OS]];<ref>[https://sourceforge.net/projects/pys60/ The Python programming language for S60 mobile phones]</ref>
* PyPy: scritto in Python stesso. Ha tra i principali obiettivi la semplificazione dello sviluppo del linguaggio e la sua ottimizzazione in termini prestazionali<ref>[http://codespeak.net/pypy/dist/pypy/doc/ PyPy] {{webarchive|url=https://web.archive.org/web/20070113051048/http://codespeak.net/pypy/dist/pypy/doc/ |data=13 gennaio 2007 }}</ref>;
== Sintassi ==
Python è stato progettato in modo da risultare facilmente leggibile e scrivibile. Visivamente si presenta in modo lineare e pulito, con pochi costrutti sintattici rispetto ad altri linguaggi strutturati come per esempio [[C (linguaggio)|C]], [[Perl]] o [[Pascal (linguaggio di programmazione)|Pascal]].
Per esempio, Python ha solo due forme di ciclo: {{Codice|codice=for|linguaggio=Python}} che itera sugli elementi di una lista o su un iteratore (equivalente al <code>foreach</code> di Perl o PHP) e {{Codice|codice=while|linguaggio=Python}}, che itera fintanto che l'[[espressione booleana]] specificata risulterà vera. In sostanza gli mancano i cicli in stile C come il {{Codice|codice=for|linguaggio=C}}, il {{Codice|codice=do...while|linguaggio=C}} e come l'{{Codice|codice=until|linguaggio=Pascal}} del Pascal, ma tutti questi possono essere espressi con dei semplici equivalenti. Allo stesso modo ha solamente il costrutto {{Codice|codice=if...elif...else|linguaggio=Python}} per le scelte condizionate e non possiede né <code>switch</code> né <code>goto</code>.
=== Indentazione ===
Un aspetto inusuale di Python è il metodo che usa per delimitare i blocchi di programma, che lo rende unico fra i linguaggi più diffusi.
Nei linguaggi derivati dall'[[ALGOL]]. come Pascal, C e Perl, i blocchi di codice sono indicati con parentesi oppure con parole chiave; per esempio il C e il Perl usano <code>{}</code> mentre il [[Pascal (linguaggio di programmazione)|Pascal]] usa {{Codice|codice=begin|linguaggio=Pascal}} e {{Codice|codice=end|linguaggio=Pascal}}. In questi linguaggi è solo una pura convenzione degli sviluppatori [[Indentazione|indentare]] (ovvero spostare verso destra rispetto al margine sinistro della pagina) il codice sorgente interno a un blocco, per migliorare la leggibilità del codice e chiarire la struttura del flusso di esecuzione.
Python, invece, deriva il suo sistema di indentazione dal meno noto linguaggio di programmazione [[Occam (linguaggio di programmazione)|Occam]]: invece di usare parentesi o parole chiave, usa l'indentazione stessa per indicare i blocchi nidificati, in congiunzione col carattere "due punti" (<code>:</code>). L'indentazione si può ottenere sia con il [[Tabulatore|carattere di tabulazione]] sia con un numero arbitrario di spazi, purché si operi in modo congruente con la sintassi del linguaggio. L'esempio che segue chiarisce questo aspetto, mostrando la versione in C e in Python di funzioni per il calcolo del fattoriale di un numero intero.
=== Fattoriale in C ===
<syntaxhighlight lang="c" line="1" copy=1>
int fattoriale(int x) {
if (x == 0)
return 1;
else
return x * fattoriale(x-1);
}
</syntaxhighlight>
=== Fattoriale in Python ===
<syntaxhighlight lang="python" line="1" copy=1>
def fattoriale(x):
if x == 0:
return 1
else:
return x * fattoriale(x-1)
</syntaxhighlight>
All'inizio questo modo di indicare i blocchi e esprimere la sintassi può confondere le idee a chi viene da altri linguaggi, ma poi si rivela molto vantaggioso, perché risulta conciso e obbliga a scrivere sorgenti indentati correttamente, aumentando così la leggibilità del codice.
Lo svantaggio è che la gestione degli spazi e dei caratteri di tabulazione può essere diversa da un [[editor di testo]] all'altro, il che costringe a prestare attenzione nell'indentare il codice oppure ad affidarsi alle funzioni di indentazione automatica, ormai presenti nella maggior parte degli editor di programmi. Può anche capitare di lavorare con editor di codice sorgente diversi, su vari computer, e ritrovarsi così con codice sorgente che usa in modo misto tabulazioni e spazi, accorgendosi dell'errore solo in fase di esecuzione.
Python permette anche alcune scorciatoie per scrivere una maggiore quantità di codice sulla stessa riga. Se i due punti (<code>:</code>) danno il via a un blocco indentato di una sola istruzione, esso può essere scritto anche sulla stessa riga, preceduto da uno spazio. <syntaxhighlight lang="python">
if b > a: print("b is greater than a")
</syntaxhighlight>
Sebbene decisamente poco apprezzabile per i puristi del linguaggio Python, è comunque possibile usare il "[[punto e virgola]]" (<code>;</code>), come in grande parte dei linguaggi di programmazione, per indicare che un'istruzione è conclusa e cominciarne un'altra sulla stessa riga.<syntaxhighlight lang="python">
a = b + 10; print("Hello world"); b = 243 - 23;
</syntaxhighlight>
== Tipi di dati e strutture ==
[[File:Python 3.13 Standrd Type Hierarchy-en.svg|miniatura|Gerarchia dei tipi in Python 3|428x428px]]
Essendo Python a [[tipizzazione dinamica]], tutte le variabili sono, in realtà, [[Puntatore (programmazione)|puntatori]] a [[Oggetto (informatica)|oggetto]]. Per esempio, se a una variabile è assegnato un valore numerico intero, subito dopo può essere assegnata una stringa o una lista. Gli oggetti sono invece dotati di tipo.
Python prevede un moderato controllo dei tipi al momento dell'esecuzione, ovvero ''[[run-time]]''. I tipi numerici godono di conversione implicita, perciò è possibile, per esempio, moltiplicare un [[numero complesso]] per un intero. Non esiste invece conversione implicita tra numeri e stringhe alfanumeriche, perciò un numero è un argomento non valido per le operazioni su stringhe, a differenza di quanto avviene per esempio in linguaggio [[PHP]].
Python dispone di vari modelli/librerie da utilizzare per fornire funzionalità senza dovere scrivere codice, come per esempio il modulo <code>turtle graphics</code><ref>{{Cita web|url=https://docs.python.org/3.3/library/turtle.html?highlight=turtle|titolo=24.1. turtle — Turtle graphics — Python 3.3.7 documentation|sito=docs.python.org|accesso=2020-05-28}}</ref> (per disegnare), <code>copy</code><ref>{{Cita web|url=https://docs.python.org/2/library/copy.html|titolo=8.17. copy — Shallow and deep copy operations — Python 2.7.18 documentation|sito=docs.python.org|accesso=2020-05-28}}</ref> (per creare copie di [[Oggetto (informatica)|oggetti]]), <code>random</code><ref>{{Cita web|url=https://docs.python.org/3/library/random.html|titolo=random — Generate pseudo-random numbers — Python 3.8.3 documentation|sito=docs.python.org|accesso=2020-05-28}}</ref> (per generare numeri casuali), <code>sys</code><ref>{{Cita web|url=https://docs.python.org/2/library/sys.html|titolo=28.1. sys — System-specific parameters and functions — Python 2.7.18 documentation|sito=docs.python.org|accesso=2020-05-28}}</ref> (per interagire da riga di comandi con l'interprete) e <code>time</code> (per operare con unità di tempo e date).
Python mette a disposizione un gran numero di [[Tipo di dato|tipi base]], essenzialmente numerici e contenitori. Caratteristica distintiva è il supporto nativo, oltre che ai classici tipi quali [[Numero intero|interi]], [[numeri in virgola mobile]] e [[Stringa (informatica)|stringhe]] alfanumeriche, anche a tipi più evoluti quali interi a grandezza arbitraria, [[numeri complessi]], liste, [[Set (informatica)|insiemi]] e dizionari. Non è invece previsto un tipo specifico per i caratteri.
Molti altri tipi sono importabili da librerie standard e nuovi tipi possono essere creati attraverso le [[Classe (informatica)|classi]].
=== Tipi numerici ===
I tipi [[Numero intero (informatica)|interi]] ({{Codice|codice=int|linguaggio=Python}}) e ''floating point'' ({{Codice|codice=float|linguaggio=Python}}) hanno una dimensione dipendente dall'hardware e dall'implementazione dell'interprete, in genere 32 e 64 [[bit]]. Sono previsti, in modo nativo, numeri interi arbitrariamente grandi (<code>long</code>, che diventano l'opzione di default per gli interi a partire da Python 3.0) e numeri complessi ({{Codice|codice=complex|linguaggio=Python}}).
Python prevede tutti i principali operatori logici e aritmetici fra numeri, compreso l'elevamento a potenza. Il tipo booleano ({{Codice|codice=bool|linguaggio=Python}}) appartiene anch'esso alla categoria dei numeri.
Dalla versione 2.4 di Python sono disponibili come libreria<ref>{{Cita web|url=https://docs.python.org/2/library/decimal.html|titolo=9.4. decimal — Decimal fixed point and floating point arithmetic — Python 2.7.18 documentation|sito=docs.python.org|accesso=2020-05-28}}</ref> anche i numeri decimali ({{Codice|codice=decimal|linguaggio=Python}}), ossia numeri in virgola mobile con precisione illimitata, come quelli disponibili in [[REXX]] o in [[Cobol]], che non soffrono di problemi di arrotondamento e stabilità tipici dei numeri ''floating point'' classici.
==
Python considera in generale come contenitori gli oggetti che prevedono la possibilità di iterare su un insieme di elementi, perciò utilizzabili all'interno di contesti quali il ciclo {{Codice|codice=for|linguaggio=Python}} e funzioni quali somma, ricerca e ordinamento. I contenitori in genere permettono di contenere dati di tipo eterogeneo.
Per quanto riguarda i contenitori standard propriamente detti, sono classificabili come sequenze, insiemi e dizionari. I contenitori seguono una filosofia comune e condividono gran parte dei [[Metodo (programmazione)|metodi]].
Le sequenze sono contenitori ordinati, che condividono metodi basati sull'ordinamento, l'indicizzazione intera e la creazione di sottosequenze tramite ''slicing''.
Le liste ({{Codice|codice=list|linguaggio=Python}}) sono sequenze estendibili, mentre le [[tupla|tuple]] ({{Codice|codice=tuple|linguaggio=Python}}) sono sequenze immutabili. Anche le [[Stringa (informatica)|stringhe]] alfanumeriche ({{Codice|codice=str|linguaggio=Python}} e <code>unicode</code>) sono considerate sequenze. A partire da Python 3.0, i tipi {{Codice|codice=str|linguaggio=Python}} e <code>unicode</code> sono unificati e compare il tipo <code>byte</code>, equivalente grosso modo a una stringa binaria.
Sono previste tutte le operazioni classiche sulle stringhe come concatenamento, formattazione, ricerca, sostituzione e così via. Le stringhe in Python sono sequenze immutabili, cosicché qualsiasi operazione che in qualche modo potrebbe alterare una stringa, per esempio la sostituzione di un carattere, restituisce in effetti una nuova stringa, come avviene in Java e in [[C sharp|C#.]]
Altri contenitori sono i dizionari ({{Codice|codice=dict|linguaggio=Python}}), conosciuti in altri contesti con il nome di ''[[hash table]]'' oppure [[array associativo|array associativi]]. Esiste una sintassi per la creazione di dizionari, i cui elementi sono specificati da una coppia di dati separati da due punti <code>:</code>. Il primo elemento della coppia rappresenta l'indice, detto "chiave", e il secondo è il suo valore corrispondente. Infatti ogni elemento di un dizionario è detto anche ''coppia chiave-valore''.
Per esempio l'istruzione seguente crea un dizionario identificato come <code>diz</code> composto da due elementi le cui chiavi sono <code>wikipedia</code> e <code>wikiquote</code>'','' rispettivamente e con associati i valori interi <code>40</code> e <code>60</code>: <syntaxhighlight lang="python">diz = {'wikipedia': 40, 'wikiquote': 60}</syntaxhighlight>
Le chiavi in un dizionario sono immutabili, mentre il valore corrispondente a ciascuna chiave è alterabile tramite un'assegnazione. La seguente istruzione modifica il valore corrispondente a <code>wikipedia</code>, portandolo a 4500: <syntaxhighlight lang="python">diz['wikipedia'] = 4500</syntaxhighlight>
A partire dalla versione 2.7 di Python<ref>{{Cita web|url=https://docs.python.org/2.7/library/stdtypes.html|titolo=5. Built-in Types — Python 2.7.18 documentation|sito=docs.python.org|accesso=2020-05-28}}</ref> sono supportati anche gli insiemi ({{Codice|codice=set|linguaggio=Python}} e {{Codice|codice=frozenset|linguaggio=Python}}), ovvero insiemi non ordinati di oggetti ''hashable''.
=== Organizzazione a oggetti ===
Il [[sistema dei tipi]] Python è ben integrato con il sistema delle [[Classe (informatica)|classi]]. Anche se i tipi base non sono formalmente classi, come per esempio in [[C sharp|C#]], una classe può comunque ereditare da essi. In questo modo è possibile estendere stringhe, dizionari e perfino gli interi. È inoltre supportata l'[[ereditarietà multipla]].<ref>{{Cita web|url=https://pythonitalia.github.io/python-abc/Pyllole/85_Inheritance_Multiple.html|titolo=Ereditarietà multipla|sito=Python ABC|lingua=en|accesso=2020-05-28}}</ref>
Vengono supportate anche funzionalità estensive di [[Riflessione (informatica)|introspezione]] sui tipi e sulle classi. I tipi e le classi sono a loro volta oggetti che possono essere esplorati e confrontati. Gli [[Attributo (programmazione)|attributi]] sono gestiti in un dizionario.
== Programmazione funzionale e sintassi avanzate ==
{{C|Troppe cose e poco chiare. Perché la sintassi avanzata deve stare qui? |informatica|marzo 2013}}
Un altro punto di forza di Python è la disponibilità di elementi che facilitano la [[programmazione funzionale]]. Le funzioni sono considerate degli oggetti e sono dunque utilizzabili alla stregua di qualsiasi altro oggetto, per esempio inserendole in collezioni o utilizzandole direttamente come parametri per altre funzioni. Gli elementi di programmazione funzionale, insieme a costrutti specifici per la manipolazione di contenitori, rendono ancora più comodo operare con liste o altri tipi contenitore.
Gli ''slicing'' sono un costrutto simile all'indicizzazione in grado di ottenere sottosequenze specificando gli indici di inizio e di fine e lo 'step'.
<syntaxhighlight lang="python" line="1" copy=1>
numeri = [1, 2, 3, 4, 5]
numeri_pari = numeri[1::2] # esempio di slicing
</syntaxhighlight>
La ''[[list comprehension]]'' è un costrutto preso dal linguaggio funzionale [[Haskell (linguaggio)|Haskell]] e consente il "riempimento" di una lista — usando una sintassi apposita — come possiamo vedere nel seguente esempio in cui vengono calcolate le prime cinque potenze di due:
<syntaxhighlight lang="python" line="1" copy=1>numeri = [1, 2, 3, 4, 5]
potenze_di_due = [2 ** n for n in numeri] # esempio di list comprehension</syntaxhighlight>
I [[Generatore (informatica)|generatori]] sono invece dei particolari oggetti in grado di costruire delle collezioni in maniera dinamica, utili per aumentare l'efficienza in particolare presenza di iterazioni su un gran numero di elementi. Le ''generator expression'', simili alle ''list comprehension'', sono uno strumento rapido ed efficace per creare generatori. La [[parola riservata]] {{Codice|codice=yield|linguaggio=Python}} permette di creare generatori con una sintassi del tutto simile a quella di una funzione.
=== Generator expression ===
<syntaxhighlight lang="python" line="1" copy=1>
numeri = [1, 2, 3, 4, 5]
potenze_di_due = (2 ** n for n in numeri) # generatore
</syntaxhighlight>
Oppure, per avere un maggiore controllo, come una normale funzione, possiamo usare la parola chiave {{Codice|codice=yield|linguaggio=Python}} al posto di {{Codice|codice=return|linguaggio=Python}}, per trasformare la nostra funzione in un generatore. In questo modo la funzione salva il suo stato, per poi riprendere l'esecuzione del codice quando viene richiamato il valore dello {{Codice|codice=yield|linguaggio=Python}} successivo.
<syntaxhighlight lang="python" line="1" copy=1>
numeri = [1, 2, 3, 4, 5]
def potenza_di_due(numeri):
for n in numeri:
yield 2 ** n
gen = potenza_di_due(numeri)
</syntaxhighlight>
L'uso è identico. Si chiama la funzione next che restituisce un nuovo valore ogni volta, riprendendo l'esecuzione del codice dalla parola chiave {{Codice|codice=yield|linguaggio=Python}}. Quando i valori sono finiti, viene sollevata un'eccezione <code>StopIterationError</code>. In ogni caso, non è l'unico modo di interagire con i generatori, e si può risalire ai data passati allo {{Codice|codice=yield|linguaggio=Python}} della funzione in questo modo:
<syntaxhighlight lang="python" line="1" copy=1>
gen = (2 ** n for n in range(1, 6))
for x in gen:
print(x)
</syntaxhighlight>
Per creare una lista da un generatore, si usa semplicemente la chiamata {{Codice|codice=list(gen)|linguaggio=Python}}:
<syntaxhighlight lang="python" line="1" copy=1>
gen = (2 ** n for n in range(1, 6))
print(list(gen))
</syntaxhighlight>
I generatori sono preferiti alle liste in quanto non occupano memoria, dato che i valori sono semplicemente calcolati di volta in volta e non permangono in memoria. Per questo è consigliabile usare, per esempio, {{Codice|codice=xrange|linguaggio=Python2}} (che è un generatore) al posto di {{Codice|codice=range|linguaggio=Python}} (che restituisce una lista) con numeri molto grandi, per garantire una maggiore velocità
È anche possibile scrivere espressioni if...else su una sola riga, cosa che risulta utile in combinazione con le lambda (vedi sotto).
<syntaxhighlight lang="python" line="1" copy=1>
import random
l = [1, 2]
a = random.choice(l)
print('Giusto!' if a == 1 else 'Sbagliato!')
</syntaxhighlight>
Dal momento che Python permette di avere [[Funzione di ordine superiore|funzioni come argomenti]], è anche possibile avere costrutti funzionali più sottili, come per esempio la [[continuazione]].<ref>[http://www.ps.uni-saarland.de/~duchier/python/continuations.html Continuations Made Simple and Illustrated]</ref>
In Python esiste la parola chiave {{Codice|codice=lambda|linguaggio=Python}}, particolarmente utile in contesti dove è necessario svolgere piccole operazioni che probabilmente saranno effettuate solo in quella zona del codice:
<syntaxhighlight lang="python" line="1" copy=1>
>>> l = [1, 2,3,4,5] # oppure range(1,6)
>>> print(map(lambda x: x + 10, l))
[11, 12, 13, 14, 15]
</syntaxhighlight>
Questo uso di ''map'' però è contestato e si preferisce usare le ''list comprehension'':
<syntaxhighlight lang="python" line="1" copy=1>
>>> l = [1, 2, 3, 4, 5] # oppure range(1,6)
>>> print([x + 10 for x in l])
[11, 12, 13, 14, 15]
</syntaxhighlight>
I blocchi {{Codice|codice=lambda|linguaggio=Python}} possono però contenere solo [[espressione (informatica)|espressioni]], non [[statement]]. Non sono quindi il modo più generale per restituire una funzione. Si può usare invece la seguente tecnica che restituisce una funzione il cui nome è definito in uno [[scope]] locale, ovvero una [[Chiusura (informatica)|closure]]:
<syntaxhighlight lang="python" line="1" copy=1>
def multiple_adder(x, y):
def adder(z):
return z + x + y
return(x + y + adder(x + y)) # sarebbe (x + y) * 3
</syntaxhighlight>
=== Decoratori ===
Un decoratore è qualsiasi oggetto di Python invocabile usato per aggiungere codice all'inizio o al termine di una funzione, un metodo o una definizione di classe, senza modificarne internamente il codice. Un decoratore è passato all'oggetto e ritorna l'oggetto modificato.
I decoratori sono ispirati in parte dalla notazione Java, hanno una sintassi simile e sono considerati [[zucchero sintattico]]. Usano <code>@</code> come parola chiave:
<syntaxhighlight lang="python" line="1" copy=1>@viking_chorus
def menu_item():
print("spam")</syntaxhighlight>
I decoratori possono essere a catena posizionandone diversi in linee adiacenti:
<syntaxhighlight lang="python" line="1" copy=1>
@invincible
@favorite_color("Blue")
def black_knight():
pass
</syntaxhighlight>
ed è equivalente a:
<syntaxhighlight lang="python" line="1" copy=1>
def black_knight():
pass
black_knight = invincible(favorite_color("Blue")(black_knight))
</syntaxhighlight>
La struttura standard del decoratore è:
<syntaxhighlight lang="python" line="1" copy=1>
def favorite_color(color):
def decorator(func):
def wrapper():
print(color)
func()
return wrapper
return decorator
</syntaxhighlight>
=== Commenti ===
Analogamente ad altri linguaggi di programmazione, in Python è possibile lasciare dei commenti nelle righe di codice per comprendere e far comprendere meglio ciò che accade eseguendo il programma. In Python i commenti (già a partire dalle primissime versioni del linguaggio di programmazione) si introducono con il simbolo {{Codice|codice=#|linguaggio=Python}}; tutto ciò che è scritto nella stessa riga dopo tale simbolo viene ignorato.<syntaxhighlight lang="python" line="1" copy=1>
print("qualcosa a caso") #questo programma stampa "qualcosa a caso" nella console ignorando tutto ciò che viene scritto dopo il simbolo "#"
print("andando a caporiga l'effetto del cancelletto sparisce e il codice ha effetto sul programma")
</syntaxhighlight>
Spesso i commenti vengono utilizzati per il cosiddetto "[[debugging]]", in quanto è possibile commentare delle specifiche linee di codice per farle saltare all'[[Ambiente di sviluppo integrato|IDE]].
Un esempio pratico sarebbe:
<syntaxhighlight lang="python" line="1" copy=1>
print("Questa riga stampa qualcosa alla console")
# print("Questa invece, non stampa niente.")
</syntaxhighlight>
Questa forma di debugging serve per rimuovere provvisoriamente delle linee di codice, tenendole sotto commento per uso futuro.
=== Gestione delle eccezioni ===
Python supporta e usa estesamente la [[gestione delle eccezioni]] come mezzo per segnalare e controllare eventuali condizioni di errore, incluse le eccezioni generate dagli errori di sintassi.
Le [[Eccezione (informatica)|eccezioni]] permettono un controllo degli errori più conciso e affidabile rispetto a molti altri modi possibili usati in genere per segnalare errori o situazioni anomale. Le eccezioni sono [[Thread safety|thread-safe]]; non sovraccaricano il [[codice sorgente]] come fanno invece i controlli sui valori di errore restituiti e possono facilmente propagarsi verso l'alto nello ''stack'' delle chiamate a funzione quando un errore deve essere segnalato a un livello più alto del programma.
Con la gestione delle eccezioni i controlli preventivi sono sostituiti da un più agevole meccanismo che permette di eseguire direttamente l'azione desiderata e catturare separatamente le eventuali eccezioni che si possono verificare. Oltre che per la gestione degli errori, in alcune occasioni le eccezioni sono usate in Python anche per il controllo di flusso: ad esempio l'operazione di iterazione, e di conseguenza il ciclo <code>for</code>, è basata su una segnalazione tramite eccezione.
=== Libreria standard ===
Python ha una vasta [[Libreria software|libreria standard]], il che lo rende adatto a molti impieghi. Oltre ai moduli della libreria standard se ne possono aggiungere altri scritti in C oppure Python per soddisfare le proprie esigenze particolari. Tra i moduli già disponibili ve ne sono per scrivere [[Applicazione web|applicazioni web]]: sono supportati [[MIME]], [[Hypertext Transfer Protocol|HTTP]] e tutti gli altri standard Internet. Sono anche disponibili moduli per creare applicazioni con [[interfaccia grafica]], per connettersi a [[Relational database management system|database relazionali]], per usare le [[espressione regolare|espressioni regolari]].
La libreria standard è uno dei punti forti di Python, in quanto compatibile con tutte le piattaforme, a eccezione di poche funzioni, segnalate chiaramente nella documentazione come specifiche di una piattaforma particolare.
== Esempi di programma ==
=== Hello, world! ===
Il seguente esempio di programma Python (versione 3.0) stampa il testo "[[Hello world|Hello, world!]]":
<syntaxhighlight lang="python">
print("Hello, world!")
</syntaxhighlight>
Il seguente è lo stesso programma funzionante con la versione 2.7 o precedenti:
<syntaxhighlight lang="python">
print "Hello, world!"
</syntaxhighlight>
=== Creazione di un Socket, invio di richieste e ricevere dati ===
<syntaxhighlight lang="python" line="1" copy=1>
import socket
# creazions socket
s = socket.socket()
# connessione server(google)
s.connect(("www.google.com", 80))
# la richiesta
richiesta = richiesta = "GET / HTTP/1.1\nHost: www.google.com\n\n"
# invio dati codificati
s.send(richiesta.encode())
# ricevi dati (home page di google)
dati = s.recv(2048)
while len(dati) > 0:
print(dati)
dati = s.recv(2048)
</syntaxhighlight>
=== Formattazione delle stringhe e funzione input===
<syntaxhighlight lang="python" line="1" copy=1>
a = input('Name: ')
b = input('Last Name: ')
c = input('Age: ')
print(f"Name = {a}\nLast Name = {b}\nAge={c}")
# Ma puoi anche:
print("Name ={}\nLast Name = {}\n Age = {}".format(a,b,c))
</syntaxhighlight><syntaxhighlight lang="python" line="1" copy=1>
# Programma che simula l'inserimento di una password e la sua convalida
# Il modulo getpass nasconde l'input dell'utente
import getpass
# Convalida della password: se errata l'utente ha in tutto 3 tentativi
tentativi = 3
password_corretta = "MyPa55w0rd!"
while tentativi > 0:
# Input per l'utente con la funzione getpass() del modulo importato
password = getpass.getpass("Inserisci la password: ")
if password == password_corretta:
print("Password corretta. Accesso consentito.")
break
else:
tentativi -= 1
if tentativi == 0:
print("Password errata. Accesso negato.")
else:
print("Password errata. Tentativi rimasti", tentativi)
</syntaxhighlight>
=== RGB binario, RGB esadecimale ===
Il seguente esempio di programma Python (versione 3.8.5<ref>{{Cita web|url=https://www.python.org/downloads/release/python-385/|titolo=rilascio versione 3.8.5|sito=Python.org}}</ref>) converte con i dovuti passaggi delle percentuali di rosso, verde e blu, un [[input]] in un colore codificato in [[RGB]]:<syntaxhighlight lang="python3" line="1" copy=1>
def RGB_bin():
import string
percentage1 = input("red (%dex): ")
percentage2 = input("green (%dex): ")
percentage3 = input("blue (%dex): ")
print("Coding in RGB a color with " + str(percentage1) + "% of red, " + str(percentage2) + "% of green and " + str(percentage3) + "% of blue...")
print(str(percentage1) + " : 100 = X : 256, so X = " + str(percentage1) + " * 256 / 100." )
X = float(int(percentage1) * 256 /100)
print(str(percentage2) + " : 100 = Y : 256, so Y = " + str(percentage2) + " * 256 / 100.")
Y = float(int(percentage2) * 256 /100)
print(str(percentage3) + " : 100 = Z : 256, so Z = " + str(percentage3) + " * 256 / 100.")
Z = float(int(percentage3) * 256 /100)
X = bin(int(X))
Y = bin(int(Y))
Z = bin(int(Z))
binary_colour = (str(X) + " " + str(Y) + " " + str(Z))
print("Colour coded by binary digits: " + str(binary_colour[2:]))
def RGB_hex():
percentage1 = input("red (%dex): ")
percentage2 = input("green (%dex): ")
percentage3 = input("blue (%dex): ")
print("Coding in RGB a color with " + str(percentage1) + "% of red, " + str(percentage2) + "% of green and " + str(percentage3) + "% of blue...")
print(str(percentage1) + " : 100 = X : 256, so X = " + str(percentage1) + " * 256 / 100." )
R = float(int(percentage1) * 256 /100)
print(str(percentage2) + " : 100 = Y : 256, so Y = " + str(percentage2) + " * 256 / 100.")
G = float(int(percentage2) * 256 /100)
print(str(percentage3) + " : 100 = Z : 256, so Z = " + str(percentage3) + " * 256 / 100.")
B = float(int(percentage3) * 256 /100)
R = hex(int(R))
G = hex(int(G))
B = hex(int(B))
hexadecimal_colour = (str(R) + " " + str(G) + " " + str(B))
print("Colour coded by hexadecimal digits: " + str(hexadecimal_colour[2:5]) + str(hexadecimal_colour[7:10]) + str(hexadecimal_colour[12:14]))
</syntaxhighlight>L'[[Output (informatica)|output]] del [[codice sorgente]] sopra è il seguente:<syntaxhighlight lang="python3" line="1" copy=1>
======== RESTART: D:\Python\Python\Python38-32\Python3.8.5 dal pc\RGB.py =======
>>> RGB_bin()
red (%dex): 30
green (%dex): 40
blue (%dex): 20
Coding in RGB a color with 30% of red, 40% of green and 20% of blue...
30 : 100 = X : 256, so X = 30 * 256 / 100.
40 : 100 = Y : 256, so Y = 40 * 256 / 100.
20 : 100 = Z : 256, so Z = 20 * 256 / 100.
Colour coded by binary digits: 1001100 0b1100110 0b110011
</syntaxhighlight>
=== Definizione di una classe ===
In Python è possibile creare classi attraverso un'istruzione specifica ({{Codice|codice=class|linguaggio=Python}}) che rappresenta l'alternativa più semplice, ma non esclusiva, per definire nuovi tipi di dato. Caratteristiche particolari in Python sono la possibilità di eredità multipla, la definizione di attributi tramite inizializzazione e non tramite dichiarazione, la dichiarazione esplicita del parametro riflessivo nei metodi d'istanza e l'[[overloading]] di funzioni e operatori.
Il parametro riflessivo è per convenzione chiamato {{Codice|codice=self|linguaggio=Python}}, ma il linguaggio non impone alcuna restrizione in merito alla scelta. Nessuna restrizione è posta anche alla definizione degli attributi: gli attributi esistono dal momento in cui vengono assegnati e l'assegnazione può avvenire al momento della costruzione (metodo {{Codice|codice=__init__|linguaggio=Python}}, da preferire) oppure all'interno di altri metodi. Inoltre gli attributi possono essere aggiunti esternamente alla classe o direttamente a un oggetto.
Python fa distinzione tra metodi d'istanza, di classe o statici. Gli attributi possono essere invece d'istanza o di classe. Il supporto all'information hiding è parziale, ma integrato dallo strumento delle ''property'' che permettono di definire degli attributi virtuali con le caratteristiche di accesso volute.
Inoltre sono previsti dei metodi "speciali" associati a operatori e funzioni di built-in. Ad esempio, ridefinendo il metodo {{Codice|codice=__add__|linguaggio=Python}} si ridefinisce l'operatore di addizione quando il primo operando sia del tipo definito, mentre {{Codice|codice=__str__|linguaggio=Python}} ridefinisce la conversione a stringa. Non è invece permesso l'overloading dei metodi. Attraverso l'uso della riflessione e delle [[metaclassi]] è inoltre possibile personalizzare ulteriormente la definizione delle classi.
Per esempio una classe <code>Persona</code>, avente solo un semplice costruttore e un metodo che restituisce il nome completo. È caldamente consigliato creare solo classi ''new style'', ovvero classi che ereditano (direttamente o indirettamente) da {{Codice|codice=object|linguaggio=Python}}<ref>{{Cita web |url=http://www.python-it.org/contenuti/10/06/22/un-nuovo-stile-per-le-classi |titolo=Un nuovo stile per le classi {{!}} Python-it.org # il punto di riferimento italiano per gli appassionati di Python<!-- Titolo generato automaticamente --> |accesso=23 giugno 2010 |urlarchivio=https://web.archive.org/web/20100806165525/http://www.python-it.org/contenuti/10/06/22/un-nuovo-stile-per-le-classi |dataarchivio=6 agosto 2010 |urlmorto=sì }}</ref>.
A partire da Python 3.6, è possibile utilizzare una nuova funzione chiamata <code>f-strings</code><ref>{{Cita web|url=https://www.python.org/dev/peps/pep-0498/|titolo=PEP 498 -- Literal String Interpolation|sito=Python.org|lingua=en|accesso=2019-05-23}}</ref>. Anteponendo la lettera {{Codice|codice=f|linguaggio=Python}} prima delle virgolette che aprono la dichiarazione di una stringa, questa funzione viene attivata. Grazie a essa è possibile includere variabili all'interno di una stringa inserendo il loro nome tra parentesi graffe. In questo modo rendiamo il codice molto più leggibile senza dover utilizzare una serie di <code>+</code> per concatenare variabili e stringhe vuote. Inoltre, nel caso in cui volessimo includere una variabile o un oggetto non di tipo stringa, la conversione avverrà in automatico, risparmiando l'eccezione {{Codice|codice=TypeError|linguaggio=Python}}.
<syntaxhighlight lang="python">
class Persona(object):
# Costruttore della classe
def __init__(self, nome, cognome):
self.nome = nome
self.cognome = cognome
def nome_completo(self):
full = f'Sig. {self.cognome} {self.nome}'
return full
persona = Persona('Mario', 'Rossi')
print(persona.nome_completo())
</syntaxhighlight>
L'output presentato sarà il seguente: <code>Sig. Rossi Mario</code>
=== Numeri perfetti fino a n ===
L'output restituisce i [[numeri perfetti]] fino a <code>n</code> (inserito in {{Codice|codice=print|linguaggio=Python}}).
<syntaxhighlight lang="python3" line="1" copy=1>
"""Numeri perfetti"""
def print_perfetti(n):
"""Stampa i numeri perfetti fino ad n"""
for i in range(2, n + 1):
somma = 0
for j in range(1, i // 2 + 1): # Oltre la metà + 1 non ci sono più divisori
if i % j == 0:
somma += j # Aggiungo a somma il divisore trovato
#print(i, j, somma) # Stampa, se serve, i valori intermedi
if somma == i:
print(i, end=" ")
print(print_perfetti())
</syntaxhighlight>
== Note ==
<references/>
== Bibliografia ==
* {{cita libro|autore=Micha Gorelick, Ian Ozsvald|titolo=Python alla massima potenza. Programmazione pratica ad alte prestazioni|anno=2015|editore=Hoepli|città=Milano|p=376|cid=|isbn=9788820367015}}
* {{cita libro|autore=Mark Lutz|titolo=Imparare Python|url=|anno=2011|editore=Tecniche Nuove|città=Milano|p=1097|cid=|isbn=9788848125956}}
* {{cita libro|autore=Luciano Ramalho|titolo=Fluent Python: Clear, Concise, and Effective Programming|url=https://archive.org/details/fluentpython0000rama|anno=2015|editore=O'Reilly Media|città=|lingua=EN|p=792|isbn=9781491946008}}
== Voci correlate ==
* [[Linguaggio di scripting]]
* [[MicroPython]]
* [[PyDev]]
* [[VPython]]
* [[Pandas (software)]]
* [[Elenco dei software Python]]
== Altri progetti ==
{{Interprogetto|b=Python}}
== Collegamenti esterni ==
* {{Collegamenti esterni}}
* {{FOLDOC}}
* {{cita web|https://www.python.org/doc/|Documentazione ufficiale|lingua=en}}
* {{cita web|http://www.python.it/doc/|Documentazione italiana}}
* [http://www.python.it/ Python.it] - Sito italiano dedicato alla programmazione in Python
* [http://www.python.it/doc/Howtothink/Howtothink-html-it/index.htm Pensare da informatico] Introduzione alla programmazione attraverso Python
* {{cita web|http://www.python.it/doc/AGauld/index.html|Guida di Python}}
* {{cita web|http://www.pycon.it|PyCon Italia}} - Sito della conferenza italiana ufficiale su Python
{{Framework per applicazioni web}}
{{Principali linguaggi di programmazione}}
{{FOSS}}
{{Controllo di autorità}}
{{Portale|Software libero}}
[[
| |||