Accademia:Oggetti predefiniti: differenze tra le versioni

Da Guide@Debianizzati.Org.
Vai alla navigazione Vai alla ricerca
(float)
(tolto "stub")
 
(114 versioni intermedie di 4 utenti non mostrate)
Riga 1: Riga 1:
{{Template:Acc_Menu_Python}}
{{Acc_Menu_Python}}
== Interi ==
== Tipi numerici ==
 
=== Interi ===
Gli interi sono... numeri interi :)
Gli interi sono... numeri interi :)


Riga 15: Riga 17:
</pre>
</pre>


== Float ==
=== Float ===
I float sono i numeri con la virgola, sia positivi che negativi e compresi anche quelli con parte decimale pari a 0.
I float sono i numeri con la virgola, sia positivi che negativi e compresi anche quelli con parte decimale pari a 0.
<pre>
<pre>
Riga 25: Riga 27:
<class 'float'>
<class 'float'>
</pre>
</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 possono essere usati come sinonimi i numeri 1 e 0.
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 44: Riga 50:
</pre>
</pre>


== Stringhe ==
 
== 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.
Una stringa è una sequenza di caratteri, che in Python sono raggruppati tra apici.


Riga 55: Riga 72:
</pre>
</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:
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
<pre>"""Questo
         e` un testo che vedi
         e` un testo che vedi
Riga 68: Riga 85:
</pre>
</pre>


[[Categoria:Accademia Lezione 1]]
Le stringhe possono essere '''indicizzate (indexed)''', cioé la posizione di ogni carattere può essere individuata con un numero intero:
[[Categoria:Accademia Lezione 2]]
<pre>
[[Categoria:Accademia Lezione 3]]
+---+---+---+---+---+
| 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]]

Versione attuale delle 13:35, 7 giu 2015

Tipi numerici

Interi

Gli interi sono... numeri interi :)

Quelli delle scuole elementare, per intenderci, ma anche quelli negativi.

>>> type(0)
<class 'int'>
>>> type(1)
<class 'int'>
>>> type(100000000)
<class 'int'>
>>> type(-6)
<class 'int'>

Float

I float sono i numeri con la virgola, sia positivi che negativi e compresi anche quelli con parte decimale pari a 0.

>>> type(0.5)
<class 'float'>
>>> type(1.0)
<class 'float'>
>>> type(-3.7)
<class 'float'>

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

Esistono solo 2 possibili valori: True o False; i numeri 1 e 0 possono rispettivamente essere usati come sinonimi.

Info.png Nota
La T e la F devono necessariamente essere maiuscole.


Prova da terminale:

>>> vero = True     # deve essere maiuscolo
>>> falso = False   # sempre maiuscole
>>> vero
True
>>> falso
False
>>> vero + vero
2
>>> falso + falso
0


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.

Info.png Nota
È indifferente l'uso degli apici singoli o doppi. L'importante è che la stringa si apra e si chiuda con il medesimo simbolo.
>>> string1 = "una bella stringa"
>>> string2 = 'una bella stringa'
>>> string1 == string2
True

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:

"""Questo
        e` un testo che vedi
formattato      cosi` come'e`
"""

Si noti che '1234' è una stringa, e non un numero:

>>> type('1234')
<class 'str'>

Le stringhe possono essere indicizzate (indexed), cioé la posizione di ogni carattere può essere individuata con un numero intero:

 +---+---+---+---+---+
 | P | r | o | v | a |
 +---+---+---+---+---+
 0   1   2   3   4   5
-5  -4  -3  -2  -1

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:

>>> 'Prova'[0]
'P'

ma anche:

>>> 'Prova'[0:1]
'P'

Nel secondo caso é come se avessi scritto dal 1° al 2° carattere escluso

Per estrapolare l' ultimo carattere:

>>> 'Prova'[-1]
'a'

non posso in questo caso scrivere:

>>> 'Prova'[-1:0]
''

Per estrapolare dal 2° al penultimo carattere:

>>> 'Prova'[1:-1]
'rov'

ma anche:

>>> 'Prova'[-4:-1]
'rov'

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:

>>> 'Prova'[0::2]
'Poa'

oppure:

>>> 'Prova'[-5::2]
'Poa'

oppure posso scorrere la stessa stringa dall'ultimo al primo carattere:

<pre>
>>> 'Prova'[::-1]
'avorP'

Le stringhe possono essere concatenate con l'operatore +:

>>> 'Prova' + 'Prova2' + 'Prova3'
'ProvaProva2Prova3'

ripetute con l'operatore *:

>>> 'Prova'*3
'ProvaProvaProva'

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 ):

Per l'analisi dei singoli metodi applicabili alle stringhe:

Info.png 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()

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:

>>> io = ['ho', 46, 'anni']
>>> io
['ho', 46, 'anni']
Info.png 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:

>>> io[3:3] = ['compiuti']
>>> io
['ho', 46, 'anni', 'compiuti']

modificare elementi:

>>> io[3] = 'incompiuti'
>>> io
['ho', 46, 'anni', 'incompiuti']

anche usando lo slicing:

>>> io[3:] = ['da', 'compiere']
>>> io
['ho', 46, 'anni', 'da', 'compiere']

eliminare elementi:

>>> io[3:] = []
>>> io
['ho', 46, 'anni']

analogamente alle stringhe, le liste possono essere concatenate:

>>> io+io
['ho', 46, 'anni', 'ho', 46, 'anni']

ripeute:

>>> io*2
['ho', 46, 'anni', 'ho', 46, 'anni']

possiamo aggiungere liste come nuovi elementi, e agire sugli elementi di quest'ultime:

>>> accidenti = ['sono', 'già', 'grande']
>>> io[3:3] = [accidenti]
>>> io
['ho', 46, 'anni', ['sono', 'già', 'grande']]
>>> io[3][2]
'grande'

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:

Per l'analisi dei metodi ed ulteriori funzionalità:

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:

>>> tricolore = ('verde', 'bianco', 'rosso')
>>> tricolore
('verde', 'bianco', 'rosso')

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:

>>> 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'

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:

>>> 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}