Appunti - Schematizzazione - Laboratorio di bioingegneria informatica

Python

Linguaggio nel quale una istruzione corrisponde ad una riga di codice (one instruction =

one line) la lettura unica è automatica se utilizzate le parentesi tonde , oppure

→

separando mediante \).

Nel dichiarare una variabile si inserisce il nome della variabile e si uguaglia a fianco il

→

dato della variabile corrispondente; il nome logico è sempre associato ad un oggetto (è

simile ad un puntatore per un tipo di oggetto):

Bool Int Float Str NoneType

true,false no limits length min and high characters none

Il tipo della variabile non viene esplicitato quando si inizializza una variabile (questo

significa che di base i valori inizializzati hanno un type()).

Tipologia delle variabili: in genere per questo tipo di linguaggio e molti altri è

→ globali,

possibile definire delle variabili ovvero delle variabili che sono dichiarate (salvate

in un ambiente di visibilità globale) al di fuori di funzioni o del ‘main’ e, che dunque la loro

validità rimane invariata (il valore ad esse assegnato non cambia nel tempo). Per

global:

modificare una variabile globale, bisogna utilizzare l’istruzione [x = 15 → def

Le altre variabili sono invece

function(): → global x → x += 2 → return x]

locali, il cui ambito viene creato ogni volta che una funzione viene richiamata e, viene

distrutto quando la funzione restituisce un tipo di ritorno.

FUNZIONE

Il concetto di è diverso rispetto a come a rontato per altri linguaggi di

→

programmazione: essa riceve degli input (variabili) e tramite una serie di calcoli la cui

struttura non interessa all’utente, restituisce un output.

Per definire una funzione si utilizza la seguente sintassi:

nome_funzione(#passaggio di parametri);

def

in maniera conseguente, poi all’interno della funzione si possono introdurre altre

funzionalità per e ettuare ad esempio certi calcoli con le variabili che vengono chiamate

nella funzione. Per fare il richiamo alla funzione in una parte (ad esempio ‘main’)

→

esterna alla funzione, ci passo il nome della funzione che ho creato e, in automatico

vengono eseguite le istruzioni contenute all’interno di essa.

è possibile anche che una funzione abbia un tipo di ritorno (in maniera simile al

● linguaggio C) in questo modo ad esempio per funzioni che e ettuano calcoli, si

→

può definire un tipo di ritorno che corrisponde ad un'operazione (return). Se il

ritorno è composto da più di un dato allora la tipologia di ritorno è una Tupla.

→

il tipo di ritorno NULLO è definito dalla classe <class ‘None Type’> ad esempio

● →

quando non è specificato il tipo di ritorno per una funzione che viene chiamata

type()

La funzione : inserito il nome della variabile all’interno delle parentesi, riporta il

→

tipo di variabile alla quale abbiamo fatto riferimento. [x=69 type(x) <class ‘int’>; x =

→ →

4.20 type(x) <class ‘float’>].

→ →

isinstance()

La funzione : riceve un oggetto e una type inseriti dall’utente, e stabilisce

→

se l'oggetto è di quella type definita, restituendo True or False. [isinstance(False,

bool)--> True; isinstance(1.0, int)--> False];

print()

La funzione : mostra come output (stampa a video) un argomento di input,

→

semplicemente richiamandolo all’interno della funzione; con più argomenti e, l’istruzione

sep alla fine si può aggiungere un carattere separatore tra più output.

[print(‘John’,’Cleese’,sep=’-’ → John-Cleese]

input()

La funzione : permette l’inserimento di dati dall’utente in fase di esecuzione del

→

programma, specificando anche il tipo di dato che si vuole inserire.

[input(str(‘Inserisci una parola: ’))]

If Else,

Nelle istruzioni di controllo, oltre ai classici and l’unione fra i due, che

→ Elif.

corrisponde alla classica istruzione Else-If è corrisposta l’istruzione Nell’utilizzo di

queste istruzioni, si mettono i due punti dopo la condizione ed è importante la spaziatura

per il riferimento all’istruzione da eseguire, se verifica la condizione. [if expression:

<Block of code>] [In - Not In]

Operatori Logici: object1 in object2 (if is included) / opposite of in

→

❖ - operator:

“TATA” in “ACGTACGCTATAGC” True

“TATA” in “AT” False

1 in 12 Error

‘1’ in ‘12’ True

“TATA” in “ACGTACGCTATAGC” False

“TATA” in “AT” True

L’indicizzazione delle stringhe è fondamentale, per specifici riferimenti all’interno

● di esse:

len(s) ritorna il numero degli elementi contenuti all’interno della stringa

s[i] fa riferimento al carattere nella posizione i

s[i:j] fa riferimento ai caratteri da i fino a quello prima di j (j non compreso)

s[i:] fa riferimento dal carattere i fino alla fine della stringa

s[:j] fa riferimento dall’inizio della stringa fino a quello prima di j

s[:] prende in considerazione tutti gli elementi della stringa

s[i:j:k] prende gli elementi da i fino a quello prima di j, al passo k (saltando k elementi)

s[-i] prende gli -i elementi a partire dalla fine della stringa

Utilizzo dei Cicli :

While: esegue una porzione di codice, finché una determinata condizione rimane

❖ vera; ; allo stesso modo per gli

[while expression: → <Block of code>]

operatori condizionali è fondamentale la spaziatura per riportare la condizione

da eseguire.

Do-While: non esiste in maniera vera e propria questo tipo di ciclo in Python, ma

❖ è possibile creare un loop simile tramite una certa struttura sintattica ad

→

esempio: [while True: → #Do something processing → #update the

quindi viene utilizzato il break per

→

]

condition → if condition: → break;

evitare la creazione di un ciclo infinito e, interrompere l’istruzione dopo la prima

volta.

For: il funzionamento del for è analogo ad altri linguaggi, ma la struttura cambia;

❖ la particolarità consiste nel non dover utilizzare un contatore in quanto il loop

viene eseguito un numero definito di volte → [for variabile in iterable:

<Block of code>] → [for numero in range(11)--> print(numero)]

break:

Istruzione serve a terminare un ciclo in un qualunque momento (ad esempio

→

per bloccare un loop, entrando in un ciclo infinito);

continue:

Istruzione anziché interrompere un ciclo, fa sì che il resto di un codice venga

→

ignorato dal ciclo e, si ritorni all’inizio di esso (ritorna all’inizio di un ciclo);

range():

La funzione permette di impostare un intervallo di esecuzione ampio quanto

→

il numero che viene passato come parametro, dunque la funzione parte da 0 ed inizia a

contare; l’intervallo di range corrisponde dunque al numero di iterazioni che verranno

eseguite, quindi quante volte volte un ciclo for verrà processato. i parametri della

→

funzione range sono: step indica il passo di avanzamento.

range[start,stop,step]→

Dunque quello che e ettua la funzione è creare una lista dove a livello sintattico deve

→

essere aggiunta la funzione list, in questo modo vengono salvati i numeri nell’intervallo

dove gli estremi sono passati come parametro dall’utente: num = list(range(10)) →

crea una lista dove i numeri compresi vanno da 0 a 9.

Standard Library : consiste in un insieme di funzioni integrate (definiti moduli); per

utilizzare le corrispondenti funzioni all’interno del programma bisogna usare il comando

import e passando il nome del modulo. per passare ad una specifica funzione di un

→

modulo, la si chiama dopo il punto → ;

[val = random.randint(#intervallo)]

un’altro procedimento analogo, consiste nel ricercare la funzione dal modulo: [from

se non si vuole riscrivere il modulo ogni volta, alla chiamata della

;

math import sqrt]

funzione, si può utilizzare la seguente sintassi alla chiamata del metodo: [from random

import * → val = randint(#intervallo)]

Metodo nettamente relazionato al concetto precedente, per metodo si intende un

→

tipo specifico di funzione associato ad un oggetto e ad una classe; a di erenza delle

vere e proprie funzioni, il metodo può modificare l’ oggetto stesso. Esempi di metodi:

[x=1+2j→x.conjugate()-->1-2j → s = ‘a usEleSs sTRIng’ → s.lower->’a useless

metodi utils:

string’ → S=s.upper()->’A USELESS STRING’];

s.lower() riporta i caratteri a minuscoli

s.upper() riporta i caratteri a maiuscoli

s.find(substring) riporta la posizione nella stringa di una/insieme di lettere

s.strip(remove_chr) rimuove certi caratteri all’inizio/fine della stringa

s.replace(old, new) ricrea una nuova stringa con certi caratteri sostituiti da altri

s.join(list) crea una stringa con gli elementi sequenziati

s.split(sep) divide una stringa una lista (uso separatori)

Liste sono un tipo di dato in grado di raggruppare più variabili in un unico gruppo

→

(possono essere raggruppate anche tipologie di dati diverse), dove ad ogni variabile è

corrisposto un rispettivo indice; per stampare la lista completa, basta chiamare il nome

di essa (non è necessario il print()). (gli elementi sono separati dalle virgole). Si possono

anche creare liste contenenti altre liste. Gli indici iniziano dall’elemento 0; per fare

riferimento ad uno specifico elemento della lista, si chiama il nome della lista e nell

quadre si riporta il numero dell’indice: {my_list[“biscotto”, 5.45, “SAS”] →

;

my_list[2] → stampa “biscotto”}

Se si utilizzano indici negativi, i riferimenti sono e ettuati dalla fine della stringa. Con i

doppi indici si fanno riferimenti a indici di liste contenute all’interno di altre liste.

List-Slicing: permette di ottenere una sottolista di elementi, partendo da una lista

● di partenza. Con solo i due punti si prende un certo intervallo di elementi, senza

l’ultimo compreso: il nuovo range più essere assegnato ad

my_list[4:10] →

una nuova lista. Se non si inserisce l’ultimo elemento del range, allora sono presi

tutti a partire dal primo indice indicato.

A di erenza delle stringhe (che non si possono modificare), più operazioni di

● modifiche possono essere e ettuate sulle liste (tramite anche appositi metodi);

inoltre le stringhe sono composte da soli caratteri e viene restituito errore se si

prova a modificare un carattere della stringa in un altro.

Indexing:

●

L[i] = x l = [32, 17, 1, 8, 21, 9]

L[i:i] = M

L[i:j] = M l[1] = 18 [32, 18, 1, 8, 21, 9]

→

L[len(L):len(L)] = M l[1:1] = [89,] [32, 89, 18, 1, 8, 21, 9]

→

del L[i] l[1:3] = [17,] [32, 17, 1, 8, 21, 9]

→

del L[i:j] del l[3:5] [32, 17, 1, 9]

→

del L[i:j:k]

List-Method

:

●

name_list.append(x) aggiunge un elemento alla fine della stringa

name_list.extend(M) aggiunge tutti gli elementi ad M alla fine della lista

name_list.insert(i,x) aggiunge l’elemento x nella lista alla posizione i

name_list.remove(x) rimuove la prima occorrenza di x

name_list.pop([i]) restituisce l’elemento rimosso alla posizione i-esima

name_list.index(x) riporta l’indice di un certo valore contenuto dentro la lista

name_list.count(x) conta le occorrenze di x nella stringa

name_list.reverse() inverte l’ordine degli elementi nella stringa

name_list.sort([reverse = riordina la lista in ordine crescente; (decrescente, se il reverse è impostato su

False]) True)

name_list.pop() rimuove l’ultimo elemento di una lista

Anche sulle liste possono essere applicati degli operatori (+,*,in, not int):

● →

+

I. si aggiungono degli elementi all’inizio della lista;

→

*

II. si ripete il contenuto di una lista per il valore alla quale viene

→

moltiplicato;

in / not in

III. serve a verificare se una certa variabile è contenuta

→

all’interno della lista; nel caso fosse presente, il tipo di ritorno è True.

Funzioni per le liste:

● L=[0,1,2,3]

len(L) 4 riporta il numero degli elementi contenuti

min(L) / 0/3 riporta il massimo / minimo

max(L)

sum(L) 6 e ettua la somma degli elementi interni

any(L) True True if any element is True

all(L) False True is all the elements are True

Aliasing

Processo di : consiste ad esempio nel creare un secondo oggetto

● della stessa tipologia di un primo oggetto (in questo caso 2 liste uguali); e

tramite un processo di modifica sulla seconda lista, si va a modificare

anche il contenuto della prima lista come se la seconda lista puntasse

→

alla prima. ex: list1 = [&lsqu