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 = {'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'

• 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}
>>>

La raó de la seva existència és que no sempre serà possible accedir a una dada pel seu índex, sinó per exemple, per algun valor que el defineix (p.e. un empleat pel seu DNI). És a dir, volem accedir a un valor per una clau.

Python crea els diccionaris així:

passwd = {'bill':'clinton', 'barack':'obama'}

I ens permet accedir-hi així:

passwd['bill'] > clinton

Els diccionaris són mutables:

passwd['bill'] = 'gates'

Exemple: omplir un diccionari des d'un fitxer.

Suposem que tenim una llista d'usuaris i els seus passwords en un fitxer. El format és una línia per usuari formada per dues paraules: el nom d'usuari i el password.

passwords = {} f = open('passwords.txt','r') for line in f.readlines():

   usr, passw = line.split()
   passwords[usr] = passw

f.close()

Diccionaris

p = {'a':'A', 'b':'B', 'c':'C', 'd':'D'} for i in p.keys():

   print(i,end=',')

> a,b,c,d for i in p.values():

   print(i,end=',')

> A,B,C,D for i in p.items():

   print(i,end=',')

> ('a','A'),('b','B'),('c','C'),('d','D') list(p.values()) > ['A','B','C','D'] 'a' in p > True

Tuples

Tuples

Hi ha una altra classe de col·lecció a Python que és semblant a la llista, però que és immutable: la tupla.

t = 'a','b','c','d'

o

t = ('a','b','c','d')

Si només hi ha un element s'ha d'escriure amb una coma final:

t = ('a',) type(t) > tuple t = ('a') type(t) > str

Les operacions son les mateixes que per les llistes (tenint en compte que són immutables!)

Referències

Cada una de les dades que creem té una referència que podriem entendre com l'adreça de memòria on es pot localitzar.

Si executem:

a = “banana” b = “banana”

a i b són dos noms diferents amb el mateix valor, però és la "mateixa" cadena de valors o guardem dues vegades a memòria la mateixa cadena de caràcters?

Cada objecte té un identificador únic, que podem obtenir amb la funció id:

id(a) > 135044008 id(b) > 135044008

Per tant, en aquest cas Python ha creat una estructura banana i les dues variables en fan referència.

Les llistes funcionen diferent (a i b tenen el mateix valor però no fan referència al mateix objecte):

a = [1,2,3] b = [1,2,3] print(id(a),id(b)) > 238870816, 245363636

Com que les variables fan referència a objectes, si una variable fa referència a una altra tenim:

a = [1,2,3] b = a print(id(a),id(b)) > 238870856, 238870856

Com que la llista té dos noms, direm que té un àlies. Això és perillós per objectes mutables!!! Pels immutables no hi ha problema.

El clonatge és una tècnica per la que fem una còpia de l’objecte en si, no de la referència. Pel cas de les llistes ho podem fer així:

a = [1,2,3] b = a[:] b[0] = 5 print(a,b) > [1,2,3] [5,2,3]

Si passem una llista com a argument d’una funció, passem una referència, no una còpia. Considerem aquesta funció:

def head(l):

   return(l[0])

a = [1,2,3] head(a) > 1

Considerem ara aquesta altra funció:

def deleteHead(l):

   del l[0]
 return l

a = [1,2,3] deleteHead(a) > [2,3]

Si retornem una llista també retornem una referència:

def tail(l):

   return l[1:]

a = [1,2,3] rest = tail(a) print(rest, a) > [2,3] [1,2,3]

Com que la llista s’ha creat amb : és una nova llista. Qualsevol modificació de rest no té efectes en a.

En canvi en el següent cas:

numbers = [1,2,3] def test(l):

   l.reverse()

print(numbers) > [3,2,1]

Exemple: Estadística de les paraules d'un document?

def numW():

   
   Aquest programa calcula l'estadística de les paraules d'un document
   
   fname = input("Nom del document")
   text = open(fname, 'r').read()
   text = text.lower()
   for ch in '!"·$%&/()=?¿|@#¢∞¬÷÷“”≠¡{}[]+-,.;:-_><':
       text.replace(ch,' ')
   words = text.split()
   counts = {}
   for w in words:
       if w in counts:
           counts[w] = counts[w] + 1
       else:
           counts[w] = 1
   n = eval(input("Quantes paraules vols analitzar (les més freqüents)?"))
   lfreq = []
   for w in counts:
       lfreq.append((counts[w],w))
   print(lfreq)
   lfreq.sort(reverse=True)
   print(lfreq)
   for i in range(min(n,len(lfreq))-1):
       print(lfreq[i][1], lfreq[i][0])