Definizioni:

Le Istruzioni
- Sono dei comandi che si vuole impartire alla macchina
Il Terminale
- O comunemente chiamata shell
   e' il client che ci permette di comunicare i nostri comandi alla macchina
Lo script
- E' una sequenza di comandi salvati in un file che verra' poi mandato in esecuzione
   intese come gestione della macchina (piccolo programma che serve al sistemista)
Il Programma
- E' una sequenza di istruzioni che l'elaboratore deve eseguire
   intese come elaborazione dati (applicativo che serve all'utente finale)

Linguaggio:

Interpretato

- Compilazione istantanea
- Interattivo
quando siamo su una shell e impartendo dei comandi abbiamo i risultati in tempo reale

Pro:

- Velocita' di apprendimento
- Visualizzazione immediata dei risultati
- Efficenza di sviluppo
Contro:
- Velocita' di esecuzione

Compilato

- Compilazione Differita
si deve creare un file poi si deve compilarlo
per ottenere il file eseguibile
Pro:
- Velocita' di esecuzione
Contro:
- Elaborazione dei risultati differita

Le Assegnazioni:

# questo e' un commento (il commento viene precedeuto dalla chiave #)

# questa e' una assegnazione semplice (la variabile mia conterra' l'indirizzo di dove e' definita la stringa)
mia = “ciao”
# una riassegnazione (la variabile mia conterra' l'indirizzo di dove e' definita l'altra stringa )
mia = “adesso contengo un'altra cosa”
# assegnazione multipla
mia, tua = 1, 2
# assegnazione multipla con scambio dei contenuti
mia, tua = tua, mia

Le Condizioni:

if mia > 20:                    # condizione
mia = 10                    # eseguita se VERA
pass                           # istruzione che non fa nulla
else:                              # questo e' facoltativo
mia = 30                    # eseguita se la precedente era FALSA

if mia > 20: mia = 10     # condizione e operazione sulla stessa riga
elif mia < 50: mia = 5    # testata solo se la precedente non e' soddisfatta

Test di condizione

== is                        # uguale
!= <> is not                  # non uguale
<                                  # minore
>                                  # maggiore
<=                              # minore o uguale
>=                                # maggiore o uguale
5 < x < 7                      # x compreso

Boolean

False # 0, ””,None (attenzione che sono tre cose diverse!!!)
True # tutti gli altri casi

Una particolare attenzione si deve portare nelle operazioni di tipo boolean:

- In una espressione AND viene calcolata la 2a parte solo se, il valore della 1a parte e' VERO.
- In una espressione OR viene calcolata la 2a parte solo se, il valore della 1a parte e' FALSO.

I Numeri:

int(num) # intero (normamente 32bit)

long(num)                     # long            (illimitato)
float(num)                     # floating       (normalmente 64bit, IEEE)
complex(rea,ima)          # complesso (due float [parte reale, parte

Funzioni Base

x + y                            # somma
x – y                            # sottrazione
x * y                            # moltiplicazione
x / y                             # divisione
x % y                           # resto divisione
x ** y                          # x alla potenza di

Funzioni sui Bit

x | y                             # x or y
x ^ y                            # x xor y
x & y                           # x and y
x << y                         # shift a Sx di y bit
x >> y                         # shift a Dx di y bit
~x                               # negato

Operazioni Unitarie

+x # incremento
-x # decremento
Moduli matematici
math, cmath, operator, ecc

I Cicli:

while

while mia > 20:                    # condizione
mia -= 1                           # eseguita finche' la condizione e' VERA
for
for i in 1,2,4:                        # condizione (finche' esistono elementi)
   print i ** 2                         # eseguita finche' la condizione e' VERA
for xrange
for i in xrange (0,6,2):           # condizione (da 0 a 6 a step di 2)
   print i ** 2                         # eseguita finche' la condizione e' VERA
for item enumerate
a = ['Mary', 'had', 'a', 'little', 'lamb']
for i, item in enumerate (a)    # itera sugli indici della sequenza
   print i, item                         # stampa indice ed elemento

All'interno dei corpi possono esistere le istruzioni:

break                                  # interrompi il ciclo
continue                              # cicla senza eseguire le istr. seguenti del corpo
return                                  # esce dalla funzione o dal metodo

Alla fine del corpo puo' esistere l'istruzione:

else

Nota:

xrange(0,6,2) # crea una sequenza immutabile (questo e' un oggetto iteratore)
range(0,6,2) # crea una sequenza mutabile (questa e' una lista)

Le Stringe:

singola

str = “questa e' una stringa”                    # assegnazione con i doppi apici
str = 'questa e\' una stringa'                    # assegnazione con gli apici singoli
str = r“questa e' una stringa raw\n”         # raw (non considera le sequenze di escape)
str = u“questa e' una stringa unicode”     # unicode (codice universale 16bit)
multipla
str = “questa e' una stringa \                   # la barra retroversa indica la continuazione della linea
        con piu' lineee”
str = “””questa e' una stringa                  # i triplici apici indicano una possibile continuazione della linea
        con piu' lineee”””                            # usata molto per la documentazione (doc String)

Le stringhe sono sequenze immutabili! (alcune istruzioni)

for i in str :print i
print len(str), str[:2], str[::-1], 'ci'+'ao'
Alcuni Metodi
s.capitalize()                                # ritorna una copia con il primo carattere Maiuscolo
s.center(width)                            # ritorna una copia di lunghezza passata e centrata
s.count(sub[,start[,end]])             # ritorna il numero di occorrenze della sottostringa
s.encode([encoding[,errors]])    # ritorna la codifica dell'errore
s.endswith(suffix[,start[,end]])    # ritorna vero se la stringa finisce col suffisso specificato
s.expandtabs([tabsize])               # ritorna una copia della con tutti i tab espansi usando ' '
s.find(sub[,start[,end]])               # ritorna l'indice piu' basso della sottostringa altrimenti -1
s.index(sub[,start[,end]])            # uguale al prec. ma solleva una ecc. se non la trova
s.isalnum()                                 # ritorna vero se tutti i caratteri sono alfanumerici
s.isalpha()                                  # ritorna vero se tutti i caratteri sono alfabetici
s.isdigit()                                    # ritorna vero se tutti i caratteri sono numerici
s.isupper()                                 # ritorna vero se tutti i caratteri sono maiuscoli
s.join(seq)                                 # rit. una strin. concatenata della seq. separata dal contenuto di s
s.ljust(width)                             # rit. una stringa di lungh. passata e giustificata a sinitra
s.lower()                                   # ritorna una copia con tutti i caratteri minuscoli
s.lstrip()                                    # ritorna una copia eliminando tutti gli spazi a inizio stringa
s.replace(old, new[, maxsplit]) # rit. una copia sostit. la sottostringa old con quella new
s.upper()                                  # ritorna una copia con tutti i caratteri maiuscoli
Formattazione

Usa il codice della libreria C printf (il prefisso % indica la variabile)

a = 12.5; b= “ciao”; c= 100
”%f e' un floating %03d e' un decimale formattato %s e' una stringa” % (a,c,b)

Flag

“%-5d”                                    # Indica di formattare allineando a sinistra un decimale a 5 cifre
“%5d”                                     # Indica di formattare allineando a destra un decimale a 5 cifre
“%+5d”                                   # come prima ma aggiunge il segno al decimale
“%05d”                                 # come prima ma se mancano cifre aggiunge degli 0
“%5.1f”                                   # Indica di formattare un frazionario con 5 caratteri in totale
                                                (compresa la virgola!!!) di cui 1 dopo la virgola

Codice del Formato

d,i                                          # intero decimale con segno
o                                            # ottale senza segno
u                                            # decimale senza segno
x,X                                         # esadecimale senza segno (lowercase, uppercase).
e,E                                         # formato esponenziale floating point (lowercase, uppercase).
f,F                                          # formato decimale floating point (lowercase, uppercase).
g,G                                         # come "e" ma meno preciso
c                                         # singolo carattere
r,s                                         # stringa (conversione ottenuta usando repr(), str()).
%%                                       # usato per ottenere “%”

Liste e Tuple:

Liste (mutabili)
l = ['questa', 'e\'', 'una', 'lista'] # le parentesi quadre definiscono la lista
l [0] = “modifico il primo elemento”
Tuple (immutabili)
t = ('questa', 'e\'', 'una', 'lista') # le parentesi tonde o assenza definiscono la tupla

sono vettori eterogenei: t = “vettore eterogeneo”, 1, 'ciao', 20

sono sequenze con indice e slice t[1] ; t [2:3]
si possono impachettate e spachettate

x = 1,3,6,9 # packing
a,b,c,d = x # unpacking

si possono generare in automatico con assegnazione

ROSSO, GIALLO, VERDE = range(3) # come enum in C
Operazioni eseguibili su Liste, Tuple e Stringhe
x in s                                                       # vero se l'elemento in s e' uguale a x
x not in s                                                 # falso se l'elemento in s e' uguale a x
s + t                                                        # concatenamento di s e t
s * n, n*s                                                # concatena n copie di s
s[i]                                                          # ennesimo elemento di s, origine = 0
s[i:j]                                                        # ritaglio di s da i (incluso) a j (escluso)
len(s)                                                      # lunghezza di s
min(s)                                                     # il piu' piccolo elemento di s
max(s)                                                    # il piu' grande elemento di s
Operazioni eseguibili su sequenze mutabili Liste
as[i] =x                                                  # sostituzione di un elemento
s[i:j] = t                                                  # sostituzione di una parte di elementi
del s[i:j]                                                  # eliminazione di una parte
    equivale a s[i:j] = []
s.append(x)                                           # aggiunta di un elemento alla fine
    equivale a s[len(s) : len(s)] = [x]
s.extend(x)                                             # aggiunta di N elementi alla fine
    equivale a s[len(s):len(s)]= x
s.count(x)                                              # ritorna il num. delle Occorrenze
s.index(x)                                              # ritorna la prima Occorrenza
s.insert(i, x)                                           # aggiunge un elem. nella posizione (i)
    equivale a s[i:i] = [x] if i >= 0
s.remove(x)                                          # rimuove il primo elemento
    equivale a del s[s.index(x)]
s.pop([i])                                             # estrae un elemento di indice (i)
    equivale a x = s[i]; del s[i]; return x
s.reverse()                                           # inverte l'ordine della sequenza
s.sort()                                                # sistema l'ordine della sequenza
s.set(x)                                                # ritorna un insieme di elem. univoci

Attenzione se volete una copia non copiate il riferimento

copia = lista, y = x

ma richiedetela esplicitamente

y = list(x) o x[:] o x*1 o copy.copy(x)

Dizionari:

I Dizionari sono mappe non sono sequenze!

d = {1:2, 'mio':10, 2:[2,'i',5]}           # questo e' un dizionario (chiave, elemento)
                                                        # la chiave di solito e' immutabile!!
d[ [1,2] ] = ...                                # una Lista non puo' essere una chiave
d[ {1,2} ] = ...                                 # un Dizionario non puo' essere una chiave
d[ (1,2) ] = ...                                 # una Tupla puo' essere una chiave

pero' un dizionario puo' essere iterato

for k in d: print d[k]
Operazioni sui Dizionari
len(d)                                              # numero di elementi in d
d[k], d.get(k)                                # elemento in d con chiave k
d[k] = x , d.setdefault(x)                 # modifico l'elemento con chiave k
del d[k]                                          # elimino l'elemento con chiave k
d.clear()                                         # elimino tutti gli elementi di d
d.copy()                                         # faccio una copia del dizionario
d.has_key(k)                                  # ritorna 1 se esiste la chiave k
d.items()                                         # creo una lista con le coppie (chiave,elemento)
d.keys()                                         # creo una lista con le chiavi
d.values()                                       # creo una lista con gli elementi
d1.update(d2)                                # aggiorna il dizionario d1 con d2
    equivale a     for k, v in d2.items(): d1[k] = v