Llistes i Tuples

Conceptes

Exemples

Valors literals de tipus list
[] (llista buida)
[1, 5, 29]
['Toni', 'Núria', 'Miquel', 'Anna']
[['Toni', 1], ['Núria', 5], ['Miquel', 29]]
Valors literals de tipus tuple
() (tupla buida)
(1, 5, 29)
('Toni', 'Núria', 'Miquel', 'Anna')
(('Toni', 1), ('Núria', 5), ('Miquel', 29))
Funcions de conversió
>>> lnum = [1, 2, 3, 4, 5] # llista a tupla
>>> tuple(lnum)
(1, 2, 3, 4, 5)

>>> tvocals = ('a', 'e', 'i', 'o', 'u') # tupla a llista
>>> list(tvocals)
['a', 'e', 'i', 'o', 'u']

>>> paraula = "Python"
>>> list(paraula)  # string a llista
['P', 'y', 't', 'h', 'o', 'n']

>>> paraula = "Python"
>>> tuple(paraula) # string a tupla
('P', 'y', 't', 'h', 'o', 'n')
Funcions predefinides. Els exemples són amb llistes però també s’apliquen a tuples
>>> max([5,3,1,22,7,0]) # màxim
22
>>> min([5,3,1,22,7,0]) # mínim
0
>>> sum([5,3,1,22,7,0]) # suma d'elements
38
>>> len([5,3,1,22,7,0]) # longitud
6
>>> list('hola')  # conversió a list
['h', 'o', 'l', 'a']
Operacions bàsiques: concatenació, consulta, pertinença, llesques. Els exemples són amb llistes però també s’apliquen a tuples
>>> [1, 2] + [3, 5, 63] # concatenació
[1, 2, 3, 5, 63]
>>> [1, 2] + []
[1, 2]
>>> limb = [[10, 20, 30], [1, 2, 3]]
>>> limb + [-1, -2]
[[10, 20, 30], [1, 2, 3], -1, -2]

>>> [0] * 4  # repetició
[0, 0, 0, 0]
>>> [1, 2] * 3
[1, 2, 1, 2, 1, 2]

>>> ll = [30, 20, 10, 40, 50]
>>> ll[2]    # indexació
10
>>> ll[-1]
50
>>> ll2 = [[2, 4, 6],[10, 30, 50],['quatre','cinc']]
>>> ll2[1][2]   # indexació de llistes imbricades
50
>>> ll2[2][0][0]
'q'

>>> ll3 = [100, 20, 10, 40, 30, 50]
>>> 10 in ll3  # pertinença
True
>>> 70 in ll3
False
>>> 10 not in ll3
False
>>> 70 not in ll3
True
>>> ll3[1:4]   # talls o llesques(slices)
[20, 10, 40]
Mètodes. Els exemples són amb llistes però també s’apliquen a tuples
>>> ll4 = [0, 3, 3, 6]
>>> num3 = ll4.count(3)  # comptar aparicions d'elements
>>> num3
2
>>> posició = ll4.index(3)  # trobar posició de la primera aparició
>>> posició
1
Desempaquetat d’una seqüència. L’exemple és amb llistes però s’aplica també a tuples
>>> ll4 = [10, 20, 30]
>>> a, b, c = ll4
>>> a
10
>>> b
20
>>> c
30
Operadors relacionals
>>> [4, 4, 3] == [4, 4, 3]
True
>>> [4, 4, 3] != [4, 4]
True
>>> [4, 4, 3] < [4, 4, 7]
True
>>> [4, 4, 3] > [4, 4]
True
Modificació d’un element
>>> ll = [30, 20, 10, 40, 50]
>>> ll[3] = 100  # mutabilitat
>>> ll
[30, 20, 10, 100, 50]
Substitució d’una llesca
>>> ll = [30, 20, 10]
>>> ll[0:2] = [40]
>>> ll
[40, 10]

>>> ll[1:] = []
>>> ll
[40]

>>> del ll[:]
>>> ll
[]
Mètodes modificadors (excepte sort, que trobareu més endavant a l’apartat d’ordenació)
>>> ll4 = [0, 3, 3, 6]
>>> ll4.append(10)  # afegir elements al final
>>> ll4
[0, 3, 3, 6, 10]

>>> ll6 = [1, 2, 3, 4]
>>> ll6.reverse()   # capgirar una llista
>>> ll6
[4, 3, 2, 1]
Ordenació
 >>> ll = [4, 52, 32, 12, 0]
>>> ll.sort()    # ordenar elements amb ordre ascendent (mètode modificador)
>>> ll
[0, 4, 12, 32, 52]
>>> lln = ['Toni', 'Anna', 'Núria', 'Miquel']
>>> lln.sort()
>>> lln
['Anna', 'Miquel', 'Núria', 'Toni']
>>> ll.sort(reverse=True)  # ordenar elements amb order descendent
>>> ll
[52, 32, 12, 4, 0]

>>> llb = [4, 52, 32, 12, 0]
>>> sorted(llb) # funció, no modifica la llista
[0, 4, 12, 32, 52]

>>> def func_ord(x):
...   return x[1],x[0]
>>> lparells = [(6, 2), (3, 2), (2, 8), (4, 1)]
>>> lparells.sort(key=func_ord) # funció clau (definida per l'usuari)
>>> lparells
[(4, 1), (3, 2), (6, 2), (2, 8)]

>>> lparells = [(6, 2), (3, 2), (2, 8), (4, 1)]
>>> lparells.sort(key=lambda x: (x[1],x[0])) # funció clau amb expressió lambda
>>> lparells
[(4, 1), (3, 2), (6, 2), (2, 8)]

>>> lparells = [(1, 5), (3, 2), (2, 8), (4, 1)]
>>> sorted(lparells, key=lambda x: (x[1],x[0]))
[(4, 1), (3, 2), (1, 5), (2, 8)]

>>> lparells = [(6, 2), (3, 2), (2, 8), (4, 1)]
>>> max(lparells, key=lambda x: (x[1],x[0]))
(2, 8)

>>> lparells = [(6, 2), (3, 2), (2, 8), (4, 1)]
>>> min(lparells, key=lambda x: (x[1],x[0]))
(4, 1)
Sentència for
>>> ll = [1,5,10]
>>> for element in ll:
...     print(element)
1
5
10
Tipus range
>>> range(5) # no es mostren els elements però podem operar amb ells
range(0, 5)

>>> list(range(5)) # convertim el resultat de range a llista només per visualitzar-ho
[0, 1, 2, 3, 4]
>>> list(range(2,5))
[2, 3, 4]
>>> list(range(2,12,2))
[2, 4, 6, 8, 10]
Sentència for amb el tipus range
>>> ll = [1,5,10]
>>> for i in range(len(ll)):
...     print(i)
0
1
2

>>> ll = [1,5,10]
>>> for i in range(len(ll)):
...     print(ll[i])
1
5
10
Llistes per comprensió
>>> ln1 = [1, 2, 3, 4, 5]
>>> [n**2 for n in ln1]
[1, 4, 9, 16, 25]

>>> ln2 = [1, 2, 3, 4, 5, 6, 7, 8]
>>> [n for n in ln2 if n % 2 == 0]
[2, 4, 6, 8]
Funció zip
>>> llista1 = [1, 2, 3, 4]
>>> llista2 = [10, 20, 30, 40]
>>> resultats = []
>>> for a, b in zip(llista1, llista2):
...    resultats.append(a + b)
>>> resultats
[11, 22, 33, 44]

>>> zip(llista1,llista2) 
<zip object at ...>
>>> list(zip(llista1,llista2)) # convertim el resultat de zip a llista només per visualitzar-lo
[(1, 10), (2, 20), (3, 30), (4, 40)]
Còpia superficial de llistes
>>> ll1 = [100, 20, 10, 40, 30, 50]
>>> llnova1 = ll1[:]  # còpia superficial de llistes amb llesques
>>> llnova1
[100, 20, 10, 40, 30, 50]

>>> ll2 = ['a', 'b', 'c']
>>> ll2nova = ll2.copy()  # còpia superficial de llistes amb copy
>>> ll2nova
['a', 'b', 'c']
Mètode d’strings que retorna una llista: split()
>>> s4 = 'qui roba un ou, roba un bou'
>>> ll = s4.split()  # str a list separant per blancs
>>> ll
['qui', 'roba', 'un', 'ou,', 'roba', 'un', 'bou']
>>> s5 = '35:523:True:baix'
>>> ll2 = s5.split(':')  # str a list amb separador
>>> ll2
['35', '523', 'True', 'baix']
Mètode d’strings que rep una llista: join()
>>> ll3 = ['qui','roba','un','ou']
>>> s6 = ''.join(ll3)  # list a str sense separador
>>> s6
'quirobaunou'
>>> s7 = '-'.join(ll3)  # list a str amb separador
>>> s7
'qui-roba-un-ou'

Exercicis del tema

Referències