PYTON

“print” sempre in minuscolo

se voglio scrivere qualcosa devo sempre metterlo tra parentesi poi ‘ oppure “
a=2 → istruzione di assegnazione =assegnare un valore ad una variabile definita
per aggiungere un commento vado a destra e scrivo facenolo precedere da #
parola=stringa → va sempre messo tra parentesi e virgolette/apice (privilegiato apice (‘))
per aggiungere un valore assegnato ad una variabile, chiudo le virgolette, metto la virgola, e la variabile
I numeri possono anche stare senza niente

scrivi:
print('*------*','\n','\n','|GIULIA|','\n','\n','+------+')

print(‘quello che vuoi’)

4 tipi di variabili:
1. integer (=numeri interi), indicate con “int”
2. decimali, indicate con “flo” → floating point (se scrivi frazione ti da il umero → se vuoi
che ti dia la frazione devi scrivere: from fractions import Fraction
frazione=Fraction (1,3)
3. stringhe, indicate con “str” → stringa
4. buleane (possono assumere solo 2 valori:true o false), indicate con “bul” (il valore va
scritto con l’iniziale maiuscola)
pyton capisce il tipo in base al valore assegnato
per fare in modo che ti scriva il tipo scrivi: print(type(a))

regole per le variabili:

• c’è differenza tra maiuscole e minuscole
• una variabile può contenere solo lettere, numeri e _
• non può contenere caratteri speciali
• il nome della varibile non può essere un numero
• non si possono usare le keywords di pyton (print, type,…) → per capire quali sono le keywords
scrivi: import keyword
print (keyword.kwlist)

se scrivi a+b (con a e b che sono stringhe), ti scrive le due variabile attaccate per farle spaziate
metti lo spazio dopo a
se scrivi a+b (con a e b che sono numeri), ti fa la somma → ti viene fuori di tipo float
se scrivi a+b (con a che è un numero e b che è una stringa), ti da errore per farle venire
concatenate devi rendere la variaile a una stringa mettendo il valore tra apici

per dare indicazione di input devi scrivere: a = int(input('scrivi un primo numero ')) così ti viene
sotto forma di int (numero)

per scrivere la potenza devo scrivere a**b (a alla b)

per calcolare il resto della divisione a:b devo scrivere a%b
CONVERSIONI NUMERI
è sempre possibile passare da un numero intero a un floating point
per passare da floating a intero mi tronca (devo fare: int(variabile))→ se voglio approssimare devo
usare funzione specifica (= round(variaile))

se voglio che mi faccia una divisione arrotondando a n cifre significative devo scrivere:
print(format(divisione,’nf’))

se scrivo numero*stringa mi ripete la stringa numero volte

se scrivo print(format(numero,’%’)) mi trasforma il numero in percentuale
se scrivo print(format(numero,’.n%’)) mi scrive il numero in percentuale arrotondato a n cifre
significative

VARIABILE BOOLEANA (True, False)

• solo con iniziale maiuscola
• se lo metto in operazione lo prende come 1 (True) e 0 (False)
• ogni numero diverso da 0 è in automatico True, ogni numero uguale a 0 è in automatico False
FUNZIONI BOOLEANE
=funzioni che restituiscono un valore booleano (and, or, not) (scitte sempre in minuscolo)
OPERATORI BOOLEANI DI CONFRONTO
=operatori che mi restituiscono valori booleani:
a==n confronta: se a=n→ True ; a=/n→ False
a!=n confronta: se a=/n→ True ; a=n→ False

IF → if condizione:
istruzione 1
istruzione 2, …

se la condizione è vera → mi fa le istruzioni

se la condizione è falsa → mi stampa da dopo le istruzioni

if condizione:
istruzione 1
istruzione 2, …
else:
istruzione
se la condizione è vera → mi fa le istruzioni
se la condizione è falsa → mi fa le istruzioni dopo “else”

per mettere più opzioni faccio vari cicli if dopo else

oppure al posto di “else” scrivo “elif” poi una condizione come fosse if
if condizione:
istruzione 1
istruzione 2, …
elif condizione:
istruzione
elif condizione:
istruzione
else:
istruzione

IMPORT
ti importa cose
se scrivi import math as m
b=*libreria*.*operazione/funzione*(1,3)
se scrivi print(dir(*libreria*)) ti da tutte le funzioni della libreria

CICLO WHILE
metto condizione che mi da variabile booleaana
se la condizione è true mi fa body poi mi ritorna alla condizione, se è true mi va al body poi …
se la condizione è false mi va al post code

while *condition*:
istr 1
istr 2
istr 3
else:
istr 1
istr 2

#somma 0, 1, 2, 3, 4

CICLO FOR
=per un certo numero di volte esegui questo ciclo → esiste un contatore che conta quante volte fai il
ciclo

funzione RANGE:
RANGE(start, stop, step)

for i in range (1, 100, 3):

istr 1
istr 2
…

= parto a contare da 1 incluso e vado di 3 in 3 fino a 100 escluso

start<=i<stop

start e step possono non essere precisati → range (1, 10) (step non definito)
 range(10) (start e step non definito)

ti prende la “i” come numero

STRINGHE
nome=Giovanna
print(nome[0]) → assegna un numero ad ogni lettera di nome partendo da 0 (G=0, i=1, o=2, v=3, a=4,
n=5, n=6, a=7) → ti stampa G
print(nome[-2])→ parte dalla fine → n (lo 0 non si conta)
Maria < Mario pk “a” è prima di “o” in tabella aski
print(ord(“a”)) → ti stampa il numero di “a” in tabella aski –> 111
print(chr(111)) → stampa la lettera che in tabella aski ha la posizione n. 111 –> a
print(len(nome)) → stampa il numero di lettere di Giovanna –> 8
print(nome[:] → stampa tutto pk non do né inizio né fine
print(nome[2:9]) → stampa dalla lettera nella posizione 2 alla lettera nella posizione 8
print(nome[2:10:2]) → stampa pertendo dalla posizione 2 alla posizione 9 di 2 in 2 (start, stop, step)

nome=’Piero’
cognome=’Rossi’
print(nome, cognome) ci hai messo 1 spazio solo
print(nome+’_’+cognome) (hai concatenato stringhe), mettendoci più spazi

concatenazione=’un’’due’’tre’
print(concatenazione) → ti dà “unduetre”
print(‘uno’) → uno
print(‘due’) → due
print(‘tre’) → tre

print(‘uno’,end=’ ’) →
print(‘due’,end=’ ‘) → uno due tre
print(‘tre’) →

print(‘uno’,end=’*’) →
print(‘due’,end=’*‘) → uno*due*tre
print(‘tre’) →

print(‘uno’,’due’,’tre’, sep=’*‘) → mi scrive “uno*due*tre”

print('uno','due','tre', sep='') → mi scrive “unoduetre”

\n → vai a capo
\t → fai uno spazione

FUNZIONI
=gruppo di istruzioni all’interno di un programma
es: dato il raggio, calcola area, perimetro, …
→ costruisci funzione che calcola l’area
→ costruisci funzione che calcola la circonferenza
vantaggi:
1. + facile scomporre lavoro tra programmatori
 2. + facile controllare
3. + facile sostituire pezzi di programma
le funzioni devono avere un nome →
• deve sempre cominciare con una lettera minuscola o minuscola o _
• nn si possono usare parole chiave

def nomeFunzione(…):
istruzione 1
istruzione 2

definire una funzione= definire la struttura

chiamare una funzione= nomeFunzione(…)

le variabili definite in una funzione nn vengono viste dal programma principale o dalla funzione che la
contiene

tipi di funzione:
• void → eseguono funzioni di cui sono composte ma nn restituiscono niente al programma
principale
• produttive → eseguono funzioni di cui sono composte e restituiscono qualcosa al programma
principale

molto utile fare funzione main, in cui metti tutte le altre funzioni

come importare un modulo:

1. import math
math.sqrt()
2. import math as m
m.sqrt()
3. from math import sqrt
sqrt()
4. from math import * (vuol dire che le importi tutte)
sqrt()

void → passaggio per argomenti:

def funz(n):
print(n)
nome=input(‘inserisci il tuo nome ‘)
funz(nome) #nome passa a funz come n

RICORDA DI METTERE COMMENTI

Per fare funzioni produttive usa return, che restituisce a funzione sopra quello che gli dici
blocca immediatamente

variabile formale= variabile che dichiaro in intestazione di funzione

variabile locale= variabile che si trova all’interno di una funzione
FUNZIONI RICORSIVE
=funzioni che richiamano se stesse

FUNZIONE FATTORIALE:
n!=n*(n-1)(n-2)… n appartiene a N (se n=0 → 0!=1)
s!=5*4*3*2*1

n!=n*(n-1)(n-2)…
(n-1)!=(n-1)(n-2)(n-3)...
n!=n(n-1)! → funzione ricorsiva

def fatt(n):
if n==0:
fattoriale_n=1
else:
fattoriale_n=n*fatt(n-1)
return fattoriale_n
n=int(input('inserisci un numero '))
print(fatt(n))

i: 123456 7 8
Fibonacci(n): 1 1 2 3 5 8 13 21 …
n(i)= n(i-1)+n(i-2)
n(6)= n(5)+n(4)
8=5+3

def Fibonacci_n(i):
if i==1 or i==2:
n=1
else:
n= Fibonacci_n(i-1)+Fibonacci_n(i-2)
return n
num= int(input('inserisci la posizione '))
for i in range (1,num+1):
#Fibonacci_n(i)
print('nella sequenza di fibonacci il numero nella posizione',i,'è',Fibonacci_n(i))

LISTE (=sequenze ordinate di elementi)

differenze con stringhe:
• stringhe sono liste di caratteri, le liste sono sequenze di elementi di qualunque tipo: caratteri,
numeri, liste
• le liste sono mutabili, le stringhe sono immutabili
si definisce con parentesi quadre:
lista=['a',1,2.4,[0,1]]
ad ogni elemento della lista è associato un indice, come nelle stringhe
si parte da 0
primo_elemento=lista[0] (=’a’)
secondo_elemento=lista[1] (=1)

come si dichiara una lista:

1. lista=[10,11,12]
2. lista=list(range(10,13))
list è una funzione integrata
3. lista=[0]*200
(10,11,12)
crea 200 liste [0] e poi le unisce in un’unica lista e associa alla
variabile lista questa

come accedere agli elementi di una lista:

1. numbers=[0, 1, 2, 3, 4]
for i in range(len(numbers)):
print(numbers[i])
2. numbers=[0, 1, 2, 3, 4]
i=0
while i<len(numbers):
print(numbers[i])
3. numbers=[0, 1, 2, 3, 4]
for num in numbers:
print(num)

concatenazione di liste:
lista1=[0,1,2]
lista2=[3,4,5]
1. lista_unione=lista1+lista2
print(lista_unione)
2. lista1+=lista2
print(lista1)
3. lista2+=lista1 (cambia solo ordine)
print(lista2)

Funzione APPEND
lista1=[0,1,2]
lista2=[3,4,5] (aggiunge alla lista1 la lista2 come unico elemento)
lista1.append(lista2) → [0, 1, 2, [3, 4, 5]]
print(lista1)

come aggiungere elemento dalla lista:

• append
• lista.insert(i,elem) → mi aggiunge l’elemento “elem” nella posizione i della lista “lista”

come eliminare elemento dalla lista:

 • lista.pop(i) → mi toglie l’elemento in posizione i nella lista “lista”
• del lista[i] → mi toglie l’elemento in posizione i nella lista “lista”
• lista.remove(elem) →mi toglie il primo elemento “elem” che vede dalla lista “lista” (se ci sono
2 ”elem” toglie solo il primo)
come cercare elemento in lista:
• lista.index(elem) → mi cerca l’elemento “elem” nella lista “lista”, se nn è presente dà errore,
quindi è meglio farla sempre precedere da un if che dica che è presente

per copiare lista:

• a=b → se cambi a ti cambia anche b e viceversa
• a=b[:] → ti crea lista a uguale a b
in funzione variabili non variano, liste si

SI POSSONO GENERARE DEI NUMERI CASUALI:

esiste libreria chiamata “random” con funzioni random → la devi importare
→ randint , genera casualmente un numero intero compreso fra 2 valori dati in ingresso
a=random.randint(start,stop) → mi fa un numero casuale compreso tra start e stop, estremi
inclusi

→ randrange, genera casualmente un numero intero compreso fra 2 valori dati in ingresso, posso
mettere anche lo step
a=random.randrange(start, stop, step)

→ random(), funzione che genera un float che è sempre compreso tra 0 e 1, con 0 incluso e 1 escluso

→ uniform(1.0,10.0), genera un float compreso tra 1 e 10

GRAFICI
con libreria matplotlib.pyplot (abbreviata come plt)
crea liste x e y con valori
plt.plot(x,y) → crea grafico
plt.show() → mostra grafico
plt.xlabel(“nome asse”) → crea l’etichetta dell’asse x chiamata “nome asse”
plt.title(“titolo”) → crea titolo “titolo”
plt.grid() → aggiunge griglia
plt.plot(x,y,color=’red’,marker=’*’) → crea grafico con linea rossa e punto *
plt.plot(x,y,color=’red’,marker=’*’, linestyile=’’) → non mette linea
plt.xticks([0,1,2,3,4],[‘2018’,’2019’,’2020’,’2021’,’2022’]) → mi rinomina i valori
plt.legend([‘caffè’,’te’])

elenco marker:
• ‘o’ → punti tondi
• ‘s’ → quadrati
• ‘*’ → stelline
• ‘D’ → rombi
• ‘^’,’<’,’>’,’v’ → triangoli con le punte
• ‘p’ → pentagono
 • ‘h’ → esagono

elenco colori:
• ‘b’ → blu
• ‘g’ → green
• ‘k’ → black
• ‘w’ → white
• ‘c’ → cyan
• ‘r’ → red
• ‘y’ → yellow
• ‘m’ → magenta

elenco linestyle:
• ‘-’
• ‘–’
• ‘-.’
• ‘:’
• ‘None’
• ‘ ‘
• ‘‘
• ‘solid’
• ‘dashed’
• ‘dashdot’
• ‘dotted’
• ‘’

ALGORITMO DI ORDINAMENTO
l’algoritmo di ordinamento ha una prestazione pari a n^2, con n che è il numero di elementi

per ordinare:
def SelectionSort(lista):
for i in range(len(lista)):
for k in range(len(lista)):
if lista[k]<lista[i]:
#a=i
#pos_i=lista.index(i)
#lista[pos_i]=k
#pos=lista.index(k)
#lista[pos]=a
lista[k],lista[i]=lista[i],lista[k]

FUNZIONE TIME: conta i secondi passati dal 1 gennaio 1970

per stampare in ordine crescente

lista=[11,9,5,7,16]
def InsertionSort(lista):
for i in range(len(lista)):
j=i
while j>0 and lista[j-1]>lista[j]:
lista[j], lista[j-1]=lista[j-1], lista[j]
j-=1
return lista
print(InsertionSort(lista))