Accademia:Oggetti predefiniti

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.

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.

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 (tabella 1):

• Sequence Types — str, bytes, bytearray, list, tuple, range

Per l'analisi dei singoli metodi applicabili alle stringhe:

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

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

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

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

• Mutable sequence types

Per l'analisi si rimanda alla documentazione ufficiale: