6 999
contributi
Nessun oggetto della modifica |
S3v (discussione | contributi) (tolto "stub") |
||
(123 versioni intermedie di 4 utenti non mostrate) | |||
Riga 1: | Riga 1: | ||
{{ | {{Acc_Menu_Python}} | ||
== Interi == | == Tipi numerici == | ||
=== Interi === | |||
Gli interi sono... numeri interi :) | Gli interi sono... numeri interi :) | ||
Riga 14: | Riga 16: | ||
<class 'int'> | <class 'int'> | ||
</pre> | </pre> | ||
=== Float === | |||
I float sono i numeri con la virgola, sia positivi che negativi e compresi anche quelli con parte decimale pari a 0. | |||
<pre> | |||
>>> type(0.5) | |||
<class 'float'> | |||
>>> type(1.0) | |||
<class 'float'> | |||
>>> type(-3.7) | |||
<class 'float'> | |||
</pre> | |||
=== Numeri complessi === | |||
Li tralasciamo. Chi è interessato ora sa che in Python esiste un tipo predefinito per gestirli; si presume che sia in grado di trovare la documentazione autonomamente. | |||
== Booleani == | == Booleani == | ||
Esistono solo 2 possibili valori: True o False; rispettivamente | Esistono solo 2 possibili valori: True o False; i numeri 1 e 0 possono rispettivamente essere usati come sinonimi. | ||
{{Box|Nota|La T e la F devono necessariamente essere maiuscole.}} | {{Box|Nota|La T e la F devono necessariamente essere maiuscole.}} | ||
Riga 34: | Riga 51: | ||
[[Categoria:Lezione | == Sequenze == | ||
Una sequenza può essere definita come un elenco ordinato e numerabile di oggetti. | |||
In Python esistono 6 diversi tipi di sequenze: '''stringhe, bytes, bytearray, liste, tuple e range'''. | |||
Le sequenze si dividono in 2 categorie, '''mutabili''' (liste, bytearray) e '''immutabili''' (stringhe e tuple, bytes), per ''mutabile'' si intende la possibilità di aggiungere, modificare ed eliminare componenti (oggetti). | |||
I range sono sequenze di numeri ottenute tramite l'omonima funzione ''range()''. | |||
In questa sede tratteremo le sequenze più comuni: '''stringhe''', '''liste''' e '''tuple'''. | |||
=== Stringhe === | |||
Una stringa è una sequenza di caratteri, che in Python sono raggruppati tra apici. | |||
{{Box|Nota|È indifferente l'uso degli apici singoli o doppi. L'importante è che la stringa si apra e si chiuda con il medesimo simbolo.}} | |||
<pre> | |||
>>> string1 = "una bella stringa" | |||
>>> string2 = 'una bella stringa' | |||
>>> string1 == string2 | |||
True | |||
</pre> | |||
Sono scritture equivalenti e sempre assegnano del testo. È possibile utilizzare anche le virgolette ripetute tre volte; in questo caso anche gli a capo sono accettati: | |||
<pre>"""Questo | |||
e` un testo che vedi | |||
formattato cosi` come'e` | |||
""" | |||
</pre> | |||
Si noti che <code>'1234'</code> è una stringa, e non un numero: | |||
<pre> | |||
>>> type('1234') | |||
<class 'str'> | |||
</pre> | |||
Le stringhe possono essere '''indicizzate (indexed)''', cioé la posizione di ogni carattere può essere individuata con un numero intero: | |||
<pre> | |||
+---+---+---+---+---+ | |||
| P | r | o | v | a | | |||
+---+---+---+---+---+ | |||
0 1 2 3 4 5 | |||
-5 -4 -3 -2 -1 | |||
</pre> | |||
L'indicizzazione, come mostra la tabella sopra, può essere effettuata sia partendo dal primo carattere (sequenza di numeri positivi) che dall' ultimo (sequenza di numeri negativi). | |||
E' possibile estrapolare porzioni (substring) o singoli caratteri di una stringa per mezzo dello '''slicing''' (taglio). | |||
Per estrapolare il primo carattere posso scrivere: | |||
<pre> | |||
>>> 'Prova'[0] | |||
'P' | |||
</pre> | |||
ma anche: | |||
<pre> | |||
>>> 'Prova'[0:1] | |||
'P' | |||
</pre> | |||
Nel secondo caso é come se avessi scritto dal 1° al 2° carattere escluso | |||
Per estrapolare l' ultimo carattere: | |||
<pre> | |||
>>> 'Prova'[-1] | |||
'a' | |||
</pre> | |||
non posso in questo caso scrivere: | |||
<pre> | |||
>>> 'Prova'[-1:0] | |||
'' | |||
</pre> | |||
Per estrapolare dal 2° al penultimo carattere: | |||
<pre> | |||
>>> 'Prova'[1:-1] | |||
'rov' | |||
</pre> | |||
ma anche: | |||
<pre> | |||
>>> 'Prova'[-4:-1] | |||
'rov' | |||
</pre> | |||
E' possibile anche indicare lo ''step'', cioé di quanti caratteri mi voglio muovere all' interno della stringa (il valore di default di step é 1). | |||
Per estrapolare tutti i caratteri dal 1° all'ultimo, con step 2: | |||
<pre> | |||
>>> 'Prova'[0::2] | |||
'Poa' | |||
</pre> | |||
oppure: | |||
<pre> | |||
>>> 'Prova'[-5::2] | |||
'Poa' | |||
</pre> | |||
oppure posso scorrere la stessa stringa dall'ultimo al primo carattere: | |||
<pre> | |||
<pre> | |||
>>> 'Prova'[::-1] | |||
'avorP' | |||
</pre> | |||
Le stringhe possono essere '''concatenate''' con l'operatore '''+''': | |||
<pre> | |||
>>> 'Prova' + 'Prova2' + 'Prova3' | |||
'ProvaProva2Prova3' | |||
</pre> | |||
'''ripetute''' con l'operatore '''*''': | |||
<pre> | |||
>>> 'Prova'*3 | |||
'ProvaProvaProva' | |||
</pre> | |||
Per la manipolazione delle stringhe sono disponibili una serie di '''operazioni comuni a tutte le sequenze''' (mutabili e non, eccetto che per i range), di seguito il link alla documentazione uffciale (prima tabella ): | |||
* [http://docs.python.org/release/3.1.3/library/stdtypes.html#sequence-types-str-bytes-bytearray-list-tuple-range Sequence Types — str, bytes, bytearray, list, tuple, range] | |||
Per l'analisi dei singoli '''metodi''' applicabili alle stringhe: | |||
{{Box|Nota|Un metodo può essere definito (in modo un po' rudimentale) come una funzione applicabile ad un determinato oggetto. La sintassi standard é: ''oggetto.nome_metodo()''}} | |||
* [http://docs.python.org/release/3.1.3/library/stdtypes.html#string-methods String Methods] | |||
=== Liste === | |||
Una lista è un insieme ordinato di oggetti. Gli oggetti inseriti in una lista possono essere di tipo diverso (stringhe, numeri, liste, ecc.). | |||
Per assegnare valori ad una lista la sintassi é la seguente: | |||
<pre> | |||
>>> io = ['ho', 46, 'anni'] | |||
>>> io | |||
['ho', 46, 'anni'] | |||
</pre> | |||
{{Box|Nota|Per l'inserimento di oggetti di tipo stringa, é ammesso anche l'uso dei doppi apici}} | |||
Tutti gli oggetti contenuti in una lista sono '''indicizzati (indexed)''' con un valore numerico ed é possibile eseguire lo '''slicing (taglio)''', analogamente a quanto detto per le stringhe. | |||
Le liste, essendo oggetti '''mutabili''', danno la possibilità di: | |||
''inserire'' elementi: | |||
<pre> | |||
>>> io[3:3] = ['compiuti'] | |||
>>> io | |||
['ho', 46, 'anni', 'compiuti'] | |||
</pre> | |||
''modificare'' elementi: | |||
<pre> | |||
>>> io[3] = 'incompiuti' | |||
>>> io | |||
['ho', 46, 'anni', 'incompiuti'] | |||
</pre> | |||
anche usando lo slicing: | |||
<pre> | |||
>>> io[3:] = ['da', 'compiere'] | |||
>>> io | |||
['ho', 46, 'anni', 'da', 'compiere'] | |||
</pre> | |||
''eliminare'' elementi: | |||
<pre> | |||
>>> io[3:] = [] | |||
>>> io | |||
['ho', 46, 'anni'] | |||
</pre> | |||
analogamente alle stringhe, le liste possono essere '''concatenate''': | |||
<pre> | |||
>>> io+io | |||
['ho', 46, 'anni', 'ho', 46, 'anni'] | |||
</pre> | |||
'''ripeute''': | |||
<pre> | |||
>>> io*2 | |||
['ho', 46, 'anni', 'ho', 46, 'anni'] | |||
</pre> | |||
possiamo '''aggiungere liste come nuovi elementi''', e agire sugli elementi di quest'ultime: | |||
<pre> | |||
>>> accidenti = ['sono', 'già', 'grande'] | |||
>>> io[3:3] = [accidenti] | |||
>>> io | |||
['ho', 46, 'anni', ['sono', 'già', 'grande']] | |||
>>> io[3][2] | |||
'grande' | |||
</pre> | |||
Per la manipolazione delle liste si possono effettuare una serie di '''operazioni comuni a tutte le sequenze mutabili''', di seguito il link alla documentazione ufficiale: | |||
* [http://docs.python.org/release/3.1.3/library/stdtypes.html#mutable-sequence-types Mutable sequence types] | |||
Per l'analisi dei '''metodi''' ed ulteriori funzionalità: | |||
* [http://docs.python.org/release/3.1.3/tutorial/datastructures.html#more-on-lists More on Lists] | |||
=== Tuple === | |||
Per definire una tupla possiamo riprendere quando detto per le liste, insieme ordinato di oggetti. A differenza delle liste le tuple sono oggetti '''immutabili''', non é possibile inserire, modificare o cancellare elementi (oggetti). | |||
Le tuple possono contenere oggetti mutabili come loro elementi. | |||
Per creare una tupla la sintassi è la seguente: | |||
<pre> | |||
>>> tricolore = ('verde', 'bianco', 'rosso') | |||
>>> tricolore | |||
('verde', 'bianco', 'rosso') | |||
</pre> | |||
Anche gli elementi di una tupla sono '''indicizzati (indexed)''' con un valore numerico, ed é possibile eseguire lo '''slicing (taglio)''' in modo analogo a quanto detto per le liste. | |||
==Collezioni non ordinate== | |||
È possibile con i dizionari ed i set gestire oggetti in cui l'ordine di sequenza è superfluo. | |||
===Dizionari=== | |||
Trattasi di una sequenza non ordinata di coppie di valori ''chiave:valore''. Siccome sono implementati tramite una tabella di hash, risultano molto efficienti quando è necessario effettuare ricerche per chiave. | |||
Ecco qualche esempio: | |||
<pre>>>> libri = {"Dante": "divina commedia", "Macchiavelli": "il principe"} | |||
>>> libri | |||
{'Macchiavelli': 'il principe', 'Dante': 'divina commedia'} | |||
>>> libri.keys() | |||
dict_keys(['Macchiavelli', 'Dante']) | |||
>>> libri.items() | |||
dict_items([('Macchiavelli', 'il principe'), ('Dante', 'divina commedia')]) | |||
>>> libri['Macchiavelli'] | |||
'il principe'</pre> | |||
===Set=== | |||
I set sono collezioni disordinate di elementi unici. Molte delle operazioni che si possono compiere con questi oggetti sono direttamente collegabili alla teoria degli insiemi (quindi unione, differenza, intersezione, sottoinsieme...). | |||
Ecco un chiaro esempio: | |||
<pre> | |||
>>> a = {1,2,3,4,5,6} | |||
>>> 2 in a | |||
True | |||
>>> {2,3}.issubset(a) | |||
True | |||
>>> a | |||
{1, 2, 3, 4, 5, 6} | |||
>>> a = a - {3,6} | |||
>>> a | |||
{1, 2, 4, 5} | |||
>>> a.add(4) | |||
>>> a | |||
{1, 2, 4, 5} | |||
>>> a.add(4) | |||
>>> a | |||
{1, 2, 4, 5} | |||
>>> a.union({5,6,7}) | |||
{1, 2, 4, 5, 6, 7} | |||
</pre> | |||
[[Categoria:Accademia Python - Lezione 1]] | |||
[[Categoria:Accademia Python - Lezione 2]] | |||
[[Categoria:Accademia Python - Lezione 3]] | |||
[[Categoria:Accademia Python - Lezione 12]] | |||
[[Categoria:Accademia Python - Lezione 13]] |
contributi