Modifiche

Da GolemWiki.

Python Lezione 4 Giugno 2008

8 971 byte aggiunti, 16:30, 5 giu 2008
nessun oggetto della modifica


== Il Python ==
è un linguaggio di programmazione interpretato.
Il linuaggio interpretato è simile agli altri linguaggi in circolazione ma, invece di essere trasformato direttamente in codice binario dal meccanismo automatico, viene interpretato da questo e poi mandato all'hardware.
È meglio di quelli compilati perchè si adatta ai vari hardware.
Python è un ottimo linguaggio di prorammaziobe ma è un pò più lento, diversamente da quello in c.
Python ha 4 interpreti:generamlmente si usa cpython (classic python, scritto in c) in tutte le distribuzioni python, ma c'è anche pypy e jython (scritto in java per python).

La prima riga di ogni script python deve iniziare con #!usr/bin/env/python

il #! del file fa capire al sistema operativo che quello non è un file di testo ma un eseguibile.


== '''
I COMMENTI ''' ==

: sono righe che l'interprete salta e non legge
es:
''# stampa:”hello word”''

==
'''PRINT''' ==
: è una funzione, è seguito da una stringa (una cosa tra 2 virgolete).La stringa deve essere tra virgolette in tutti i comandi, i numeri interi invece no.
Il punto e virgola in molti dei linguaggi di porgrammazione si mette alla fine di ogi riga, in Python si può ma un buon pitonista in genere non lo fa mai.
PRINT stampa l'oggetto che viene dopo.
Se scrivo:
''print 3''
se si esegue questo stampa 3
se scrivo
'' print “3”''
stampa lo stesso ma in questo caso l'oggetto che si passsa è una stringa
se scrivo
''print 3+2''
scrive
'' 5''
se scrivo
''print “3+2”''
lui mi dà
''3+2''

Le variabili non importa dichiararle, basta scrivere ad un certo punto
''messaggio=”hello world”''
''print messaggio''
se questo programma viene eseguito il risultatato sarà:
''hello world''
l'interprete va a vedere cosa c'è dentro la variabile messaggio e stampa hello world


== '''ECCEZIONE''' ==
:se io commento la definizione di messaggio (es: ''# messaggio = " hello world "'' ) il programma non sa cos'è messaggio e se scrivo:
''print "messaggio"''
il risultato sarà:name error, che, viene chiamato eccezione.

In Python non si possono sommare cose diverse, o meglio, lo posso fare ma mi converte il numero in stringa.per esempio
''print messaggio*2''
l'esecuzione darà
''messaggio messaggio
''
esempio:
''Print “ciao”+”mondo”''
lo eseguo e mi darà:
'' ciao mondo''

Se si scrive python da riga di comando parte l'interprete se scriviamo roba lui l'esegue e si usa per provare le cose.per uscire premere ctrl+d.

== '''
LE STRINGHE:''' ==
supportano molti metodi perchè sono oggetti (che è un altro nome per variabile).le stringhe sono immutabili.
Se una stringa viene dichiarata la seconda volta, diversamente dalla prima, quella precedente viene buttata.
''messaggio=”ciao”
messaggio=”ciao mondo”
print “messaggio”''
lui scrive
'' ciao mondo''
LE STRINGHE SONO IMMUTABILI.

==
'''Funzione DIR''' ==


''messaggio=”ciao”
dir(messaggio)''
a questo punto il programma da una serie di caratteri incomprensibili.
Praticamente dà i '''metodi''' che suporta la stringa messaggio.

== I '''metodi''' ==
sono operazioni che si possono applicare alla stringa.
quelli che iniziano con '''__'''spesso vengono usati per scoraggiare la gente ad usarli,in quanto qui non esistono i permessi e ognuno può modificare ciò che vuole.

Quando il metodo inizia con '''AD''' richiama l'operatore dell'addizione

'''__ doc__''' ce l'hanno tutti gli oggetti (stringhe, interi...)



metodo '''IS''':
tutti I metodi che iniziano per is danno come risultato o vero o falso.
es:
''messaggio.isalpha()''
mi dicese messaggio è o meno alfanumerico.
isalpha è un oggetto quindi se non mi ricordo ha le proprietà doc quindi se io scrivo ''messaggio.isalpa.__doc__''
mi dice che fa.

Importante metto tra “ solo se è una stringa.
Se io definisco un oggetto con un altro oggetto con una funzione non metto “.
es:
'' messaggio=”gigio”
messaggio2= messaggio.upper()''

es:
''TYPE(3)''
mi dice che variabile è.se è intero o stringa.
Se io scrivo ''DIR(3)''
mi da lo stesso pappie di roba di prima.
'''
I TIPI DELLA LIBREARIA STANDARD''':sono le variabili, ci sono anche le LISTE

Esistono stringhe, interi, float (numeri con virgola)buleano (che ha due valori, vero o falso, True e false)e i CONTENITORI:

==
LE LISTE ==

es. lo scaffale ha I pc, I pc sono oggetti (pc1,pc2...).Se voglio uno scaffale di pc senza dare I nomi a tutti gli oggetti, definisco lo scaffale.
Lo scaffale si chiama''' Lista''' .si usano le parentesi quadre con oggetti separati da virgola
es. '' a = [ “pc1” , “schermo rotto” , 2]
dir (scaffale)''
da la lista dei metodi, da qui si capisce che la lista è un oggetto.
Se io faccio
''b = dir (a)''
o
''a.append(“4”)''
aggiunge alla lista a il 4.
'''la lista MUTA!'''
Se faccio ''print (“a”)''
mi da la lista degli oggetti più il 4.


== '''TUPLE''' ==

è una lista non mutabile.
La tupla è molto piu veloce rispetto alla lista.
Con tuple si usano le parentesi tonde.

== '''
DIZIONARI''' ==

il dizionario si definisce con le parentesi graffe {chiave:valore, chiave:valore}
a{chiave}
da il valore associato alla chiave.

Dizionari liste e tuple sono dele sequenze e sono iterable e si possono scorrere.

==
'''1.If elif else''' ==


if condizione :
indentato roba da fare se vero.

Python supporta o tab o spazio, si decide quanti tab o spazi alla prima indentazione.
Meglio lo spazio perchè in futuro I tab verranno lasciati.
Di solito si usa 4 spazi.
Non c'è la graffa in pyton o I begin o gli end, si chiude e si apre la riga solo se si indenta.

Esempio:
''a=3
b=1''

''if a >b:
print (“ a è maggiore di b”)
elif a==b:
print (“ a è uguale a b”)
else:
print(“b è maggiore di a”)''

'''2.is, is not or, and,!='''
''if a is 1:
print (“si”)
elif a is not 1:
print (“no”)

if a is 1 and b is 3:
print (“si”)

if a is 1 or b is 3:
print (“okkei”)
''
'''!= è il diverso.'''


== '''3.append, insert''' ==

''a.append(“4”)''
aggiunge alla lista a il 4.
Se faccio print (“a”)
mi da la lista degli oggetti più il 4.

con '''insert''' devo inserire anche la posizione
''a.insert(2,34)''
mette il 34 in posizione 2



== '''4.for''' ==

specifica un ciclo, fa le cose tante volte fino ad una condizione.
For variabile in una sequenza di qualche tipo.
Es: ''for elemento in a:
print elemento''

es b è una tupla.
Allora posso scrivere:
''for elem in b
print “altro elemento”
“print elem”''

elem o qualsiasi altro nome gli dia è ogni elemento dentro la tupla o lista o dizionario.

Se io voglio sia la chiave sia il valore in un dizionario (se metto elem mi mette solo la chiave) posso fare:
for chiave in a:
''print “chiave: “ + chiave
print “valore: “ + a[chiave]''

'''DOPO I DUE PUNTI METTO SEMPRE IL TAB.'''

==
'''5.xrange''' ==

xrange è un iterable di dieci elementi con il primo valore uguale a 0 .E' una lista ma non ha le proprietà di una lista.
se io voglio fare un for da uno a dieci (cioè la somma da uno a 10)

es: ''for I xrange(10)
print I''
lui stampa
''1
2
3
4
5
6
7
8
9
10''
xrange vale solo per for.

== '''6.range''' ==

è una lista.se io scrivo:
''print range(10)''
lui mi da ''[0,1,2,3,4,5,6,7,8,9].''
è più lento di xrange e poi sta morendo

==
'''7.len''' ==

''len (a)''
da la lunghezza della stringa

==
'''8.enumerate''' ==

se io ho una lista di tre elmenti
''a=[“ciao”,”bel”, “mondo”]''

''for I, elem in enumerate(a):
print str(I) + “:” + elem
''
da la posizione corrente di ogni elemento.
''0:ciao
1:bel
2:mondo''


== '''9.raw_input''' ==

dai il valore.
''Base= raw_input (“inserisce la base:”)
esponente=raw_input (“inserisci l'/ esponente”)''

ti chiede il valore di base ed esponente.

==
'''10.Int''' ==

forza il fatto che quel valore sia un intero.
''
Es:base=int(base)
result=int(result)''


== '''11.UPPER,LOWER,CAPITALIZE''' ==

'''capitalize''' è un comando che sulla la stringa su cui viene applicato ,prende la prima lettera dopo gli spazi e ci mette la maiuscola

es:
''print “ciao mondo”.capitalize()''
''Ciao mondo''
es:
''print “ciao mondo”.title()
Ciao Mondo''

'''LOWER:''' prende la striga e emette tutto minuscolo
'''UPPER:''' il contrario di lower

== '''
ESEMPIO DELLA SERATA:''' ==


Calcolo di una potenza.

''Base= raw_input (“inserisce la base:”)
esponente=raw_input (“inserisci l'/ esponente”)

base=int(base)
result=int(result)

result=1
for i in xrange(esponente):
result = result * base
print result''

l'operatore int forza il fatto che l'operatore deve essere un intero, lo dobbiamo scrivere, altrimenti non funziona perchè lui lo vede come stringa
772
contributi

Menu di navigazione