Diferència entre revisions de la pàgina «ASIX-M3-UF1-A4»

Revisió del 18:11, 11 nov 2020 (mostra codi font) Rsort (Discussió | contribucions) (→‎Llistes) ← Vés a l'edició anterior		Revisió del 18:14, 11 nov 2020 (mostra codi font) Rsort (Discussió | contribucions) (→‎Llistes) Vés a l'edició següent →
Línia 211:		Línia 211:
	</source>		</source>
−	Els elements d'una llista s'indexen de la mateixa manera que una cadena de caràcters. De fet les llistes i els strings són conceptualment molt semblants, i podem aplicar-hi operadors semblants.
−	La diferència és el que contenen. Les llistes poden contenir qualsevol tipus de dades, incloent “classes” definides pel programador. Les llistes són mutables, és a dir, es poden canviar sobre la mateixa estructura (els strings no!).	+	Mètodes:
−
−	Donada una llista l:
	l.append: afegeix elements al final.		l.append: afegeix elements al final.

---

Revisió del 18:14, 11 nov 2020

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: ens diu la mida en caràcters d'una cadena (-1 si no la troba).

>>> len("Python3")
7

- find: 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: 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: 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: 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:

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 index.

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

Mètodes:

   l.append: afegeix elements al final.
   l.sort: ordena els elements.
   l.reverse: inverteix la llista.
   l.index(x): retorna l'índex del primer element igual a x.
   l.count(x): retorna el nombre de vegades que apareix x.
   l.remove(x): elimina la primera ocurrència de x.
   l.pop(i): elimina l'ièssim element de la llista i retorna el seu valor.
   x in l: retorna una valor booleà en funció de si x és a la llista o no.

Suposant que tenim una llista formada per milers de milions d'elements, podriem ordenar aquestes operacions en funció del temps que trigarien a executar-se?

Exemple

def getNumbers():

   nums = []
   xStr = eval(input("Entra un nombre (<Enter> per acabar): "))
   while xStr != "":
       x = eval(xStr) 
       nums.append(x)
       xStr = eval(input("Entra un nombre (<Enter> per acabar): "))
   return nums

def m(nums):

   suma = 0.0
   for num in nums:
       suma += num
   return suma/len(nums)

def stdDev(nums, mean):

   import math
   sumDev = 0.0
   for num in nums:
       dev = mean - num
       sumDev += dev * dev
   return math.sqrt(sumDev/len(nums)-1)

data = getNumbers() print("Mitja: ", mean(data), " | Desviació: ", stdDev(data, mean(data)))

Llistes

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

l = [0,1,3,['a','b']]

Per obtenir un element d’una llista imbricada ho podem fer de dues maneres:

1. amb dues passes...

li = l[3] li[0] > 'a'

1. o bé ...

l[3][0] > 'a'

I és que les llistes imbricades es fan servir per representar matrius:

m = [[1,2,3],[4,5,6],[7,8,9]] m[0] > [1,2,3] m[1][1] >5

Diccionaris

Diccionaris

Python ens proporciona un altre tipus de col·lecció molt útil: els diccionaris.

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])