==================== Python: Fondamentali ==================== Interprete ---------- Python si riferisce a: - il **linguaggio** Python, un insieme di regole sintattiche e semantiche che definiscono il comportamento di un programma scritto in Python. - l'**interprete** ``python``, un comando eseguibile dalla shell che permette di eseguire codice scritto nel linguaggio Python. Per far partire l'interprete, da una shell scrivete:: python Vi apparira' una schermata di testo simile a questa:: Python 2.7.10+ (default, Oct 10 2015, 09:11:24) [GCC 5.2.1 20151003] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>> Per eseguire codice python, scrivetelo nell'interprete e date invio, ad esempio:: print "hello, world!" Per chiudere l'interprete, premete ``Control-d`` in una riga vuota. .. hint:: Oltre all'interpreter ``python``, che e' il default, esistono altri interpreti Python piu' usabili, ad esempio ``ipython``: https://ipython.org/ L'interprete ``ipython`` funziona *esattamente* come ``python``, ma dispone di funzionalita' avanzate, come ad esempio la **colorazione della sintassi** (syntax highlighting), che possono facilitare la stesura del codice. | Moduli ------ Un'alternativa all'eseguire codice nell'interprete e' scrivere un *modulo*: un file di testo con estensione ``.py`` in cui scrivete il codice da eseguire. .. warning:: L'estensione ``.py`` e' obbligatoria! Per eseguire un modulo, diciamo il file ``eseguibile.py``, scrivo dalla shell:: python eseguibile.py Per utilizzare le funzioni definite in un modulo all'interno di un altro, uso ``import``. Ad esempio, se in ``eseguibile.py`` voglio usare la funzione ``ordina_proteine()`` precedentemente definita nel modulo ``util.py``, scrivo all'inizio di ``eseguibile.py``:: import util .. warning:: Quando importate un modulo, omettete l'estensione ``.py``. A questo punto posso usare ``ordina_proteine()`` cosi':: util.ordina_proteine() .. warning:: I contenuti di un modulo importato vengono prefissati col nome del modulo: qui abbiamo invocato ``util.ordina_proteine``, non ``ordina_protein`` liscio. | Oggetti ------- Un oggetto rappresenta dei dati di qualche tipo (un intero, una stringa, una lista, *etc.*) sui cui operiamo in qualche modo. Ogni oggetto ha: - un *tipo*, che specifica che cosa l'oggetto rappresenta. - un *valore*. I tipi fondamentali sono: =========== =========== ===================================== ======== Tipo Significato Valori Mutabile =========== =========== ===================================== ======== ``bool`` Condizioni ``True``, ``False`` No ``int`` Interi :math:`\{-2^{-31},\ldots,2^{31}-1\}` No ``long`` Interi :math:`\mathbb{N}` No ``float`` Razionali :math:`\mathbb{Q}` No ``str`` Testo Testo No ``list`` Sequenze Eterogenei **Si'** ``tuple`` Sequenze Eterogenei No ``dict`` Mappe Eterogenei **Si'** =========== =========== ===================================== ======== | Variabili --------- Le variabili sono contenitori di *riferimenti* ad oggetti. Possono essere viste come *nomi* per gli oggetti a cui si riferiscono. Un oggetto viene *assegnato* ad una variabile con ``=``:: pi = 3.1415926536 Qui la variabile di nome ``pi`` si *riferisce* all'oggetto ``3.1415926536`` di tipo ``float``. In sostanza abbiamo deciso che ``pi`` e' un nome per l'oggetto ``3.1415926536``. .. warning:: Il nome della variabile e' arbitrario! Lo decidiamo noi in modo che sia conveniente: breve, descrittivo degli oggetti a cui si riferisce, indicativo del ruolo che la variabile svolge nel nostro codice, *etc.* Il tipo di una variabile e' il tipo dell'oggetto a cui si riferisce. Ne segue che il tipo di ``pi`` e' ``float``. .. warning:: La variabile non contiene l'oggetto, ma un *riferimento* a quell'oggetto. Per stampare il *valore* di una variabile, uso la funzione ``print``:: variabile = "sono una esempio" print variabile Per stampare il *tipo* di una variabile, uso la funzione ``type``:: variabile = "sono un esempio" print type(variabile) **Esempio**. Creo una nuova variabile ``var``:: var = 123 Il nome di ``var`` e' ``var``, il suo valore e' ``123``, il suo tipo e' ``int``. **Esempio**. Una variabile puo' essere assignata piu' volte:: var = 1 var = "MANLFKLGAENIFLGRKAATKEEAIRF" var = 3.1415926536 Il nome della variabile resta sempre lo stesso, ma tipo e valore cambiano ad ogni passaggio: controlla con ``print var`` e ``print type(var)``. **Esempio**. L'assegnamento funziona anche tra variabili:: a = "sono un esempio" print a b = a print b Qui l'oggetto riferito da ``a`` viene assegnato a ``b``, quindi sia ``a`` che ``b`` si riferiscono allo stesso oggetto. Posso anche scrivere:: a = "sono un esempio" b = "sono un esempio" L'effetto e' diverso: qui ``a`` e ``b`` si riferiscono a due oggetti diversi con lo stesso valore! | Funzioni e Metodi ----------------- Python mette a disposizione un'ampia gamma di funzioni e metodi, ad esempio ``print``, che stampa il valore di una espressione a schermo, e ``help``, che visualizza l'aiuto. - Una funzione esegue un'operazione sui suoi *argomenti*, e puo' restituire un *risultato*. Una funzione e' invocata cosi':: risultato = funzione(argomento1, ..., argomentoN) Qui ``risultato`` e' una variabile arbitraria. - Un metodo e' una funzione associata ad un tipo: ci sono i metodi degli interi, delle stringhe, delle liste, *etc.* L'invocazione dei metodi somiglia a quella delle funzioni:: risultato = oggetto_o_variabile.metodo(argomento1, ..., argomentoN) C'e' un'analogia con le funzioni matematiche: .. math:: y = f(x_1, \ldots, x_n) Con delle importanti differenze: - Non tutte le funzioni (e metodi) Python richiedono argomenti, o ritornano un risultato. - Le funzioni matematiche possono operare solo sui loro inputs :math:`x_1,\ldots,x_n` e dall'esterno possiamo osservare solo il loro risultato :math:`y`. Al contrario, le funzioni Python possono avere *side-effects*, ad esempio stampare informazioni a schermo, o modificare variabili che non sono i loro argomenti. - La variabile ``risultato`` e' una variabile Python (di nome arbitrario, lo decidiamo noi!) in cui viene messo il risultato della funzione. .. warning:: Non dimenticate le parentesi attorno agli argomenti! Tecnicamente ``print`` non e' una funzione in Python 2.x; e' per questo che non sono necessarie parentesi attorno ai suoi argomenti. | Documentazione -------------- Per visualizzare l'aiuto di un tipo/oggetto/variabile, usa la funzione ``help``, ad esempio:: help(123) visualizza l'aiuto degli interi, cioe' del tipo dell'oggetto ``123``. Avrei ottenuto lo stesso risultato con:: x = 123 help(x) o:: help(int) L'aiuto si usa come il manuale della shell: posso navigare l'aiuto con le frecce, cercare un termine con ``/``, e chiudere l'aiuto con ``q``. Posso visualizzare l'aiuto di un metodo di interesse, ad esempio il metodo ``split`` delle stringhe, cosi':: help("una stringa".split) | Esercizi -------- #. Dati l'intero ``1`` ed il razionale ``1.0``, quali sono i metodi messi a disposizione dai tipi dei due oggetti? #. Data la stringa ``x = 'testo'``, visualizza l'aiuto del metodo ``replace`` delle stringhe. #. Data la lista ``x = []``, visualizza l'aiuto del metodo ``remove`` delle liste. #. Dato il dizionario ``x = {}``, visualizza l'aiuto del metodo ``items`` dei dizionari. #. Visualizza l'aiuto di ``dir`` e di ``help``. #. Usando un editor di testo a tua scelta (ad esempio ``nano`` o ``gedit``), scrivi un modulo che stampi a schermo, usando ``print``, la stringa ``'Hello, world!'``. Il modulo deve chiamarsi ``hello.py``. Esegui il modulo dal terminale per verificare che funzioni.