In Python abbiamo tre categorie di tipi di dato. I tipi primitivi (interi e float), gli oggetti e le sequenze. Le sequenze presenti in Python attualmente sono stringhe, liste e tuple. Vediamo innanzitutto le stringhe

>>> s = 'Hello'
>>> s = s+', world'
>>> s
'Hello, world'
>>> len(s)
12
>>> s[0:5]
'Hello'
>>> s[7:]
'world'
>>> s[0]
'H'
>>> s[-1]
'd'
>>> dir(s)
[]
>>> x='a'
>>> x=x+'b'
>>> x
'ab'

Le stringhe possono essere espresse con una costante: basta scrivere i caratteri che la compongono tra virgolette, singole o doppie. Le variabili in Python, come ormai dovrebbe essere chiaro, non sono tipizzate e non vanno dichiarate: quindi per creare una variabile contentente una stringa basta assegnare una costante stringa alla variabile. Le stringhe sono immutabili: questo vuol dire che una volta create non possono essere modificate, si può solo creare un'altra stringa. Le stringhe possono essere concatenate utilizzando l'operatore +, come si vede nell'esempio, ma in questo caso vengono buttate via le due stringhe preesistenti, costruendone una nuova risultante dalla concatenazione delle due precedenti. Le stringhe, come tutte le sequenze in genere, sono indicizzabili tramite l'operatore [], che può specificare un range, separato dai due punti: questa operazione viene chiamata slicing.

Riferiamoci all'esempio di prima. Possiamo notare subito che i range partono da 0 e che il range s[a:b] indica tutti gli elementi da a incluso a b escluso. Usare un numero negativo come indice equivale ad indicizzare a partire dall'ultimo elemento; quando ometto il primo elemento del range si intende 0, quando ometto il secondo si intende il len della sequenza. Un esame della stringhe con dir rivela che non ha metodi: questo significa che una stringa può essere manipolata soltanto utilizzando i builtin e gli operatori predefiniti. Un'altra sequenza immutabile è la tupla:

>>> x = 1,2,3
>>> x
(1, 2, 3)
>>> a,b,c = x
>>> a
1
>>> b
2
>>> c
3
>>> x[0:1]
(1,2)
>>> x,y = 7,8
>>> x+y
15

Separando con una virgola una serie di elementi si costruisce una tupla, o meglio si impaccano (packing) gli elementi un una tupla. Questa operazione ha il suo constrario nello spacchettamento (unpacking) della tupla, che si ottiene ponendo una serie di variabili a sinistra di un assegnamento. Essendo le tuple sequenze, anche su di esse si può operare con lo slicing, come le stringhe. Python ha dunque l'assegnamento multiplo, che tecnicamente è un packing ed unpacking di tupla. Le tuple sono comode in molti casi, ma sono immutabili come le stringe, e si può operare con esse solo utilizzando poche operazioni, quelle standard per le sequenze, riassunte in Tabella 1.

Esiste una struttura dati molto più flessibile, ma ovviamente anche più inefficiente, ovvero la lista:

>>> x=[1,3]
>>> x
[1, 3]
>>> x.append(4)
>>> x
[1, 3, 4]
>>> x.insert(1,2)
>>> x
[1, 2, 3, 4]
>>> x.reverse()
>>> x
[4, 3, 2, 1]
>>> dir(x)
['append', 'count', 'index', 'insert', 'remove',
'reverse', 'sort']

A differenza delle tuple, le liste sono mutabili e si possono eseguire più operazioni su di esse. Le liste possono essere create utilizzando l'apposita sintassi, comprendo gli elementi tra parentesi quadre, e su di esse si può operare utilizzando una serie di metodi predefiniti: append, insert, reverse, eccetera, come si può vedere nell'esempio, oltre al solito slicing. Vediamo infine i dizionari, ovvero gli array associativi che sono anche essi tipi primitivi in Python:

>>> x={'a':1, 'b':2}
>>> x
{'b': 2, 'a': 1}
>>> x['a']
1
>>> x['c']=3
>>> dir(x)
['clear', 'copy', 'get', 'has_key', 'items', 'keys',
'update', 'values']
>>> x.keys()
['b', 'c', 'a']
>>> x.values()
[2, 3, 1]
>>> x.items()
[('b', 2), ('c', 3), ('a', 1)]

Il funzionamento dovrebbe essere abbastaza ovvio. Le costanti per definire i dizionari sono della forma { key:val, keys:val, … } . Per accedere agli elementi si usa la sintassi per l'indicizzazione di una sequenza; si può assegnare un elemento per crearlo, e si può eliminare un elemento con del. I dizionari non sono sequenze, ma li tratto in questo paragrafo per affinità con le altre strutture dati primitive. Se serve si possono ottenere facilmente le sequenze delle chiavi, dei valori e di tutti gli elementi (una lista di tuple).