Estructures de dades

Les estructures de dades que venen amb Python i s'usen habitualment són:

Llista
Diccionari
Conjunt
Tupla

Llistes

Comencen per 0, com a molts llenguatges.

l1 = [0,1,2,3]
lx = [0,1,True,"Hola"]

Per saber la longitud d´una llista

len(lx)

Diferències amb Java, la comilla(") i la comilla simple(') és el mateix

l=["a","b","c"]

però serveix per poder ficar cometes dobles dins de la simple

msg ='Dijo "Vete de aqui!"'
msg

msg ='Dijo "Vete de aqui!"'

amb python "a" == 'a' es TRUE

Tuples

Tupla és una llista de sol lectura. No és habitual usar-la, però si sabem del cert que només volem lectura és una mica més eficient.

t = ("a","b","c")
t

('a', 'b', 'c')

Diccionari

Diccionari, Hash, Tabla Hash, Has Map, Mapa son tots sinònims. És diferent d'Arrays...

Arrays

Claus	Valors
0	"Roser"
1	"David"
2	"Miquel"

Amb un diccionari, les claus, poden ser del tipus que vulgui, no sol enters. Exemple: Strings
Les claus tenen que ser úniques, no hi pot haver repetides.

Diccionari

Claus	Valors
"Roser"	111
"David"	222
"Miquel"	223

Nomenclatura per diccionaris

() Brackets
[] Square Brackets
{} Curly Brackets
<> Angle Brackets

d = {"Roser": 111,
    "David": 234,
    "Miquel": 342}
d["Roser"]

111

for keys in d:
    print(keys)

Roser

David

Miquel

Exercici 1 -> Crear un nou diccionari on les claus del primer siguin els valors del segon i els valors, passin a ser les claus.

Per una de les possibles solucions al exercici s'introdueix un nou concepte el de comprenhension.

Comprenhension Lists and Dicts

Hi ha "Dict Comprenhensions" y "List Comprenhensions", serveixen per a inicialitzar i omplir de dades d'una llista (o diccionari) basant-nos en valors d'una llista (o dict.) existent.
Per a llegir o escriure una comprenhension, es comença per la comanda del mig (pel "for") de l'instrucció.

Dict comprenhension

d2 = {key:value for key,value in dictionary_source.items()}

List comprenhension

d2 = {elem for elem in List_source}

# Solution "for" 1

dict_reverse = {}

for key, value in d.items():
    name = key
    tel  = value
    dict_reverse[tel] = name
dict_reverse

Una segona solució, seria...

#Solution 2 items() example
d.items()
dict_reverse2 = {}
for key, item in d.items():
    dict_reverse2[item] = key
    print(key, item)
dict_reverse2

#Solution 3 with only keys
# keys() example

dict_reverse3 = {}
for key in d.keys():
    tel = d[key]
    dict_reverse2[tel] = key
dict_reverse3

Solution 4 Comprenhemsion

dict_reverse_oneline = {tel:name for name, tel in d.items()}
dict_reverse_oneline

Exercici 2 -> A partir d'una llista, que va del 1 al 10, crear amb una linea , una nova llista, amb els valors al quadrat de la primera.

Solució usant List Comprension.

numbers = range(1,11)
llista2 = [ num**2 for num in numbers]
llista2

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Solució sense List Comprension.

numbers = range(1,11)
i: int = 0
while i < len(numbers):
    numbers[i]=numbers[i]**2
    i+=1

Slices

Els slices són una opció per retallar diferents llistes, de maneres diferents.

S'utilitza sovint perquè és molt pràctic, i una funcionalitat inèdita.

#Indexes = 0..7 (8 letters)
# len -1 = últim índex

slic = ["a","b","c","d","e","f","g","h"]
len(slic)

#del 2 al 7
slic[2:7]

['c', 'd', 'e', 'f', 'g']

#del 2 al final
slic[2:len(slic)]

['c', 'd', 'e', 'f', 'g', 'h']

#del 2 al final
slic[2:]

['c', 'd', 'e', 'f', 'g', 'h']

# Del principi a la 5 lletra
slic[:5]

['a', 'b', 'c', 'd', 'e']

#Tota la llista retornant una copia
slic[:]

['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']

#Si fiques un index fora de límits del array, no dona error outofBounds del segon índex
slic[2:2000]

['c', 'd', 'e', 'f', 'g', 'h']

#Llegir tota una llista saltant de X en X, es un tercer parametre "step"
slic[0:8:2]

['a', 'c', 'e', 'g']

#Índex negatius, comencen pel final de la llista. El -1 és el final de la llista.
slic[-1]

'h'

#Puc fer rangs amb índexs negatius
slic[-8:-1]

['a', 'b', 'c', 'd', 'e', 'f', 'g']

slic[-8:] #fins la h. No puc ficar el índex final

['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']

#Exemple avançat. Invertir una secuencia
slic[::-1]

['h', 'g', 'f', 'e', 'd', 'c', 'b', 'a']

"Hola Mundo"[::-2]

'onMao'

Sets

Objecte creats que funcionen similar a la teoría de conjunts.

S'utilitzen sobretot quant vols tenir elements que no es repeteixin.
Els elements no tenen ordre, (realment tenen ordre d'inserció), quant començes a utilitzarlos amb diferents operacions, aquest ordre es pot perdre.
Es poden realitzar operacions d'àlgebra entre conjunts: unió, intersecció, diferència ...

# num_set: set ={} #igual que un dict
num_set: set = set() #Mejor así. Desambigua

num_set.add(1)
num_set.add(1)
num_set.add(1)
num_set.add(2)
num_set.add(2)
num_set

len(num_set)

2

num_set.pop()

1

#Borra si existe, sin dar error , si no existe -> Remove si no existe , fallara
num_set.discard(2)

seta:set = {1,2,3}
setb:set = {3,4,5}
seta
setb

#unió tots els elements amb un eliminat duplicats
seta.union(setb)
seta | setb

#elements que es troben als dos conjunts
seta.intersection(setb)
seta & setb

#saber si un objecte es subconjunt d'un altre o sigui que tots els seus elements es
#troben al b.
seta.issubset(setb)

False

#saber si un objecte es superconjunt del altre ( o sigui que tots els elementos del altre)
seta.issuperset(setb)

False

#Poder eliminar duplicats d'una llista, la passo a un conjunt(set)
types_list = ["journal","journal","journal","journal","journal","others"]
types_set = set(types_list)
types_set

# Set comrenhension
set2 = {elem*2 for elem in seta}
print(set2)

#Dict comprenhensio
d1 = {"a": 1, "b":2}
d2 = {k: v for k, v in d1.items()}
print(d2)

Enumerate: recuperar l'index i els valors.

Utilitzem normalment els índex, si vols o necessites els índexs, utilitzem el while.

Si no ens fa falta el index, utilitzem el for

Pero si volem saber els índex i els valors podem utilitzar enumerate

És especialment útil si volem recórrer diccionaris.

lista_index = ["a","b","c","d","e"]

for item in enumerate(lista_index):
    print(item)

(0, 'a')

(1, 'b')

(2, 'c')

(3, 'd')

(4, 'e')

Com ho fem si volem veure, per exemple el segon element de cadascuna de les tuples?.

for item in enumerate(lista_index):
    print(item[1])

a

b

..

e

Si volem crear una llista de tuples podem fer...

el = list(enumerate(lista_index))
el

[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd'), (4, 'e')]

Per poder mostrar amb el for, el primer o el segon element de cadascuna de les tuples realitzem aquesta comanda

for index, elem in enumerate(lista_index):
    print(elem)

a

b

..

e

o si volem veure el índex

for index, elem in enumerate(lista_index):
    print(index)

0

1

..

4

Altres utilitats, anomenar cada element d'un array amb una variable

nombre, apellido1, apellido2 = ["David","De Mingo"]
print(nombre + "-" + apellido1)

David-De Mingo

També si algunes posicions no ens interessen, podem assignar aquelles posicions a _ .

nombre, apellido1, _ ,_ = ["Miquel","Amorós","David","De Mingo"]
print(nombre + "-" + apellido1 )

Miquel-Amorós

Exercici 3 --> Construir la llista de tuples amb un bucle while.

Solució Exercici 3

i = [0,1,2,3,4,5,6,7]
l = ["a","b","c","d","e","f","g","h"]

#Construir la llista de tuples amb un bucle while
count=0
length = len(l)
array_out = []

while (count < length):
    index = i[count]
    elem = l[count]
    t = (index,elem)
    array_out.append(t)
    count += 1
    
print(array_out)

Documentació funcions

Per saber totes les funcions associades al objecte, es pot fer com realitzem amb Java...

nom_objecte. -> Autocomplete

nom_objecte.nom_funcio + Documentació de la funció

Resum de les estructures.

Ja hem vist com funciona cada estructura, ara exposarem un resum i una infografia de quan usar cada una.

Diccionaris

Ideals per organitzar els elements si no els volem per ordre d'inserció.

El rendiment és òptim per a fer cerques i edició d'un sol element donada la seva clau.

El que és una mica més lent que altres estructures és mostrar tot el diccionari.

Llistes

Són les més comuns, aporten moltíssima flexibilitat. És fàcil accedir als elements per índex, obtenir trossos de llista per intèrvals d'index (l1[2:5], l1[:-3], l1[0:20:2] ...)

L'inconvenient és fer cerques si no saps l'índex, que és lent.