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 immutabili (eccetto che per i range), di seguito il link alla documentazione uffciale:
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() |
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:
Per l'analisi si rimanda alla documentazione ufficiale: