ASIX-M3-UF1-A4

Cadenes

https://j2logo.com/ejercicios-python/#retoSemanal

• Una cadena és una seqüència de caràcters (String).

• Es poden assignar directament a variables o llegir des de teclat.

>>> nom = Joan

>>> cognoms = input("Introdueix els teus cognoms")

• A cada caràcter de la cadena li correspon una posició:

Hola Joan 
012345678

• Podem accedir als caràcters de la cadena indicant la posició i a subcadenes indicant un rang (slicing).

>>> salutacio = "Hola Joan"

>>> salutacio[3]   # mostra el caràcter de la posició 3
'a'
>>> salutacio[-3]  # mostra el caràcter de la posició 3 comptant des del final de la cadena
'o'
>>> salutacio[2:4] # mostra els caràcters de les posicions 2 i 3
'la'
>>> salutacio[:4]  # mostra els caràcters de les posicions 0, 1, 2 i 3
'Hola'
>>> salutacio[5:]  # mostra els caràcters des de la posició 5 fins al final 
'Hola'
>>> salutacio[:-2]  # mostra tota la cadena menys els dos últims caràcters
'Hola Jo'

Operacions amb cadenes

- Concatenar

>>> nomComplert = "Joan" + "Climent"
>>> print(nomComplert)
JoanCliment

- Repetir

>>> print('Hola' * 3)
HolaHolaHola

• Codificacions dels caràcters:

- ASCII: 7 bits per caràcter i només té en compte els caràcters anglesos.

- UNICODE: 16 bits per caràcter i codifica els caràcters de totes les llengües.

• Funcions per veure els codis:

>>>ord('A')
65
>>>ord('a')
97
>>>chr(65)
'A'
>>>chr(97)
'a'

Funcions

- len(cadena): ens diu la mida en caràcters d'una cadena (-1 si no la troba).

>>> len("Python3")
7

- find(cadena,inici,fin): ens diu la posició on comença una cadena (o caràcter) en un altra cadena.

>>> frase = "Els millors somriures són els que ningú entén"
>>> frase.find("somriures")
12
>>> frase = "Els millors somriures són els que ningú entén"
>>> frase.find("plors")
-1

Pot tenir fins a tres paràmetres: cadena.find(subcadena, inici, fin)

Paràmetre	Obligatori	Descripció
subcadena	Sí	La subcadena (o caràcter a buscar)
inici	No	En quina posició començar la búsqueda (0 per defecte)
fin	No	En quina posició finalitzar la búsqueda (darrer caràcter per defecte)

- split(caràcter): permet separar una cadena en diferents parts, indicant el caràcter separador.

>>> cadena = "De les nits més fosques neixen les albes més lluminoses"
>>> cadena.split()
['De', 'les', 'nits', 'més', 'fosques', 'neixen', 'les', 'albes', 'més', 'lluminoses'] # Llista de strings

Per defecte el caràcter separador és un blanc però es pot especificar qualsevol altre:

>>> numcad = "22.244.567"
>>> numcad.split('.')
['22', '244', '567'] # Llista de strings

- join(llista): s'utilitza per convertir una llista en una cadena separant cada element de la llista pel caràcter indicat.

>>> paraules = ['Qui', 'té', 'la', 'seva', 'pròpia', 'llum', 'incomoda', 'qui', 'està', 'a', 'les', 'fosques']
>>> " ".join(paraules)  # l'espai farà de separador
'Qui té la seva pròpia llum incomoda qui està a les fosques'

- strip(cadena): Elimina els caràcters indicats de l'inici i del final de la cadena, o els espais en blanc si no s'indiquen caràcters específics.

>>> "Qui dia passa any empeny".strip('Qui')
' dia passa any empeny'
>>> "Qui dia passa any empeny".strip('ny')
'Qui dia passa any empe'

- upper(): Converteix la cadena a majúscules.

>>> "Python3".upper()
'PYTHON3'

- lower(): Converteix la cadena a minúscules.

>>> "Python3".lower()
'python3'

- islower(): True si tots els caràcters de la cadena estan en minúscules (False en cas contrari).

>>> "Python3".islower()
False
>>> "python3".islower()
True

- isupper(): True si tots els caràcters de la cadena estan en majúscules (False en cas contrari).

>>> "Python3".isupper()
False
>>> "PYTHON3".isupper()
True

- isalpha(): True si tots els caràcters de la cadena són lletres (False en cas contrari).

>>> "Python3".isalpha()
False
>>> "Python".isalpha()
True

Executar programes amb arguments

• Des de la línia de comandes es pot executar un programa amb arguments separant-los amb espais.

• Els arguments estaran accessibles amb la llista de strings argv del mòdul estàndard sys.

• El primer argument sys.argv[0], contindrà el nom del programa.

Si creamos un programa llamado arguments.py con el siguiente contenido:

import sys

if(len(sys.argv) == 3):
    print ("Nom del programa: ", sys.argv[0])
    print ("Primer argument: ", sys.argv[1])
    print ("Segon argument:", sys.argv[2])
else:
    print ("El programa requereix 2 arguments")

• Execució del programa: python3 arguments.py argument1 argument2

Col·leccions de dades

• Les col·leccions de dades poden emmagatzemar un conjunt de valors, normalment, que tenen relació entre ells.
• Són les següents:

Llistes

Diccionaris

Tuples

Llistes

• Una llista és una seqüència ordenada d'elements.

• En una llista es poden afegir i/o eliminar elements.

• Una llista pot contenir elements del mateix tipus o de diferents tipus.

["Maria", "Pere", "Carles", "Sofia", "Raquel", "Joan"]  # Llista de noms

[0, 5, "Bé", "Notable", "A+", "B", True, False]  # Llista amb elements de diferents tipus

• Es pot accedir als elements d'una llista atenen al seu índex.

>>> llistaNoms =["Maria", "Pere", "Carles", "Sofia", "Raquel", "Joan"]
>>> llistaNoms[0]
'Maria'        
>>> llistaNoms[5]
'Joan'

Operacions

>>> llistaNoms =["Maria", "Pere", "Carles", "Sofia", "Raquel", "Joan"]

- element in llista: retorna una valor booleà en funció de si l'element és a la llista o no.

>>> "Raquel" in llistaNoms
True
>>> "Ricard" in llistaNoms
False

- len: ens diu el nombre d'elements de la llista.

>>> len(llistaNoms)
6

- Recorregut d'una llista

>>> llistaNums = [1, 2, 3, 4]
>>> suma = 0
>>> for num in llistaNums:
...    suma += num
... 
>>> suma
10

Mètodes

>>> llista = [1, 2, 3, 4, 5, 4, 2, 4, 3, 2, 1]

- append(element): afegeix un element al final de la llista.

>>> llista.append(6)
>>> llista
[1, 2, 3, 4, 5, 4, 2, 4, 3, 2, 1, 6]

- count(element): retorna el nombre de vegades que apareix element.

>>> llista.count(4)
3

- sort(): ordena els elements.

>>> llista.sort()
>>> llista
[1, 1, 2, 2, 2, 3, 3, 4, 4, 4, 5, 6]

- reverse(): inverteix la llista.

>>> llista.reverse()
>>> llista
[6, 5, 4, 4, 4, 3, 3, 2, 2, 2, 1, 1]

- index(element): retorna l'índex del primer element igual a element.

>>> llista.index(4)
2

- remove(element): elimina la primera ocurrència de element.

>>> llista.remove(4)
>>> llista
[6, 5, 4, 4, 3, 3, 2, 2, 2, 1, 1]

- pop(index): elimina l'ièssim element de la llista i retorna el seu valor.

>>> element=llista.pop(1)
>>> element
5
>>> llista
[6, 4, 4, 3, 3, 2, 2, 2, 1, 1]
>>>

- insert(index,element): afegeix l'element en la posició index de la llista i desplaça els elements posteriors.

>>> llista.insert(7,10)
>>> llista
[6, 4, 4, 3, 3, 2, 2, 10, 2, 1, 1]

- clear(): buida la llista de tots els elements.

>>> llista.clear()
>>> llista
[]

- extend(llista): Uneix dues llistes.

>>> llista1=["A", "B", "C"]
>>> llista2=[1, 5,1 0]
>>> llista1.extend(llista2)
>>> llista1
['A', 'B', 'C', 1, 5, 10]

Llistes imbricades

• Una llista imbricada és una llista que apareix com a element d’una altra llista.

>>> llistaImbricada = ["Joan" ,[7563, True], "Maria", [5056, False]]

• Obtenir un element d’una llista imbricada:

# obtenin primer la llista imbricada:
>>> llistaImbricada = ["Joan" ,[7563, True], "Maria", [5056, False]]
>>> dadesEmpleat = llistaImbricada[1]
>>> sou = dadesEmpleat[0]
>>> sou
7563

# directament:
>>> sou = llistaImbricada[3][0]
>>> sou
5056

• matrius: per fer una matriu s'utilitzen llistes imbricades

>>> matriu = [[1, 2, 3],['A','B','C'],[True, False, True]]
>>> matriu[0]
[1, 2, 3]
>>> matriu[1][1]
'B'

• Recorregut de les llistes d'una matriu:

>>> for llista in matriu:
...    llista
... 
[1, 2, 3]
['A', 'B', 'C']
[True, False, True]

• Recorregut dels elements d'una matriu:

>>> for llista in matriu:
...    for element in llista:
...       element
... 
1
2
3
'A'
'B'
'C'
True
False
True

Diccionaris

• Cada element d'un diccionari s'identifica per una clau i permet l'accés per aquesta clau.

>>> passwords = {'lmarin':'l@1n', 'dvidal':'d1@l'}
>>> passwords['dvidal']                             # accés per clau
'd1@l'

• Permeten emmagatzemar valors enters, cadenes, llistes...

>>> inventari = {}    # diccionari buit
        o
>>> inventari = {'ordinadors' : 150, 'projectors' : 7, 'mvs': ['ubuntu_18.04', 'ubuntu_20.04', 'windows_10']}
>>> inventari['projectors']   # accés a un valor
7
>>> inventari['mvs']          # accés a la llista
['ubuntu_18.04', 'ubuntu_20.04', 'windows_10']
>>> inventari['mvs'][1]       # accés a un valor de la llista           
'ubuntu_20.04'

Operacions

• Nombre d'elements d'un diccionari

>>> len(inventari)
3

• in: Existeix la clau?

>>> 'mvs' in inventari
True

• Afegir i actualitzar elements:

>>> inventari['raspberry_pi_4'] = 12 # afegir
>>> inventari['projectors'] = 8      # actualitzar
>>> inventari
{'ordinadors': 150, 'projectors': 8, 'mvs': ['ubuntu_18.04', 'ubuntu_20.04', 'windows_10'], 'raspberry_pi_4': 12}
>>>

• Recorregut del diccionari

>>> for clau in inventari:    # retorna les claus
...    clau
... 
'ordinadors'
'projectors'
'mvs'
'raspberry_pi_4'

>>> for valor in inventari.values():  # retorna els valors
...    valor
... 
150
8
['ubuntu_18.04', 'ubuntu_20.04', 'windows_10']
12

>>> for clau, valor in inventari.items():  # retorna les claus i els seus valors
...    clau, valor
... 
('ordinadors', 150)
('projectors', 8)
('mvs', ['ubuntu_18.04', 'ubuntu_20.04', 'windows_10'])
('raspberry_pi_4', 12)

Mètodes

• - dict(): crea un diccionari.

>>> aules = dict(ISO = 301, Informàtica = 204, Electrònica = 109)
>>> aules
{'ISO': 301, 'Informàtica': 204, 'Electrònica': 109}

• copy(): copia el diccionari.

>>> copy_aules = aules.copy()
>>> copy_aules
{'ISO': 301, 'Informàtica': 204, 'Electrònica': 109}

• - fromkeys(): rep un element iterable (cadena, llista o tupla) i un valor i retorna un diccionari combinant cada component de l'element iteratiu amb el valor.

>>> comptador = dict.fromkeys('ABCD',1)
>>> comptador
{'A': 1, 'B': 1, 'C': 1, 'D': 1}

• - zip(): rep dos elements iterables (cadenes, llistes o tuples) amb el mateix números d'elements i retorna un diccionari combinant cada component de cada element segons la posició que ocupa.

>>> resultat = dict(zip(['Joan','Maria','Pau'],[10,9,9]))
>>> resultat
{'Joan': 10, 'Maria': 9, 'Pau': 9}

• - clear(): buida el diccionari de tots els seus elements.

>>> resultat.clear()
>>> resultat
{}

• - items(): retorna una llista amb totes les tuples (clau, valor).

• - keys(): retorna una llista amb totes les claus.

• - values(): retorna una llista amb tots els valors.

>>> inventari = {'ordinadors' : 150, 'projectors' : 7, 'mvs' : ['ubuntu_18.04', 'ubuntu_20.04', 'windows_10'], 'raspberry_pi_4' : 12}

>>> inventari.items()
dict_items([('ordinadors', 150), ('projectors', 8), ('mvs', ['ubuntu_18.04', 'ubuntu_20.04', 'windows_10']), ('raspberry_pi_4', 12)])

>>> inventari.keys()
dict_keys(['ordinadors', 'projectors', 'mvs', 'raspberry_pi_4'])

>>> inventari.values()
dict_values([150, 8, ['ubuntu_18.04', 'ubuntu_20.04', 'windows_10'], 12])

• - get(): rep una clau i retorna el valor associat (res si no existeix).

>>> inventari.get('raspberry_pi_4')
12

• - pop(): rep una clau, l'elimina i retorna el valor (error! si no existeix).

>>> inventari.pop('projectors')     # elimina l'element projectors
8
>>> inventari
{'ordinadors': 150, 'mvs': ['ubuntu_18.04', 'ubuntu_20.04', 'windows_10'], 'raspberry_pi_4': 12}

>>> inventari.pop('mv')             # error! la clau 'mv' no existeix
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'mv'

• - setdefault(): pot funcionar com a get, o també pot afegir un nou element.

>>> inventari.setdefault('ordinadors')  # com get()
150
>>> inventari.setdefault('impressores', 7)  # afegir un nou element
7
>>> inventari
{'ordinadors': 150, 'mvs': ['ubuntu_18.04', 'ubuntu_20.04', 'windows_10'], 'raspberry_pi_4': 12, 'impressores': 7}

• - update(): rep com a paràmetre un diccionari: les claus coincidents, s'actualitzen els valors, la resta s'agreguen (clau, valor).

>>> act_inventari = {'ordinadors' : 200, 'raspberry_pi_4' : 10, 'scaners' : 5}
>>> inventari.update(act_inventari)
>>> inventari
{'ordinadors': 200, 'mvs': ['ubuntu_18.04', 'ubuntu_20.04', 'windows_10'], 'raspberry_pi_4': 10, 'impressores': 7, 'scaners': 5}

Tuples

• Semblant a les llistes però immutables.

>>> dies = ('dilluns', 'dimarts', 'dimecres', 'dijous', 'divendres', ['dissabte', 'diumenge'])
>>> dies
('dilluns', 'dimarts', 'dimecres', 'dijous', 'divendres', ['dissabte', 'diumenge'])

Operacions

• Indexació i slicing.

>>> dies[0]
'dilluns'
>>> dies[-1]
['dissabte', 'diumenge']
>>> dies[2:4]
('dimecres', 'dijous')
>>> dies[2:-1]
('dimecres', 'dijous', 'divendres')

• -len(): mida de la tupla o de l'element

>>> len(dies)     # mida de la tupla (quants elements?)
6
>>> len(dies[4])  # mida de l'element (cadena)
9
>>> len(dies[5])  # mida de la llista
2

Mètodes

• -index(): si troba l'element, ens diu la seva posició i si no el troba error!

>>> dies.index('dimarts')
1
>>> dies.index('gener')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: tuple.index(x): x not in tuple

• -count(): retorna nombre de vegades que apareix l'element en la tupla.

>>> dies.count('dijous')
1
>>> dies.count('febrer')
0
>>> dies[5].count('dissabte') # per comptar dins de la llista
1