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

De wikiserver
Dreceres ràpides: navegació, cerca
(→‎Mètodes)
(→‎Mètodes)
Línia 440: Línia 440:
 
>>> resultat
 
>>> resultat
 
{'Joan': 10, 'Maria': 9, 'Pau': 9}
 
{'Joan': 10, 'Maria': 9, 'Pau': 9}
 +
</source>
 +
 +
:* '''- clear():''' buida el diccionari de tots els seus elements.
 +
<source lang = "python">
 +
>>> resultat.clear()
 +
>>> resultat
 +
{}
 
</source>
 
</source>
  
Línia 458: Línia 465:
 
</source>
 
</source>
  
−
dict ()
 
  
−
Recibe como parámetro una representación de un diccionario y si es factible, devuelve un diccionario de datos.
 
  
−
dic = dict(nombre='nestor', apellido='Plasencia', edad=22)
+
copy()
 +
 
 +
Retorna una copia del diccionario original.
 +
 
 +
dic = {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4}
 +
dic1 = dic.copy()
 +
 
 +
dic1 → {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4}
 +
 
 +
fromkeys()
 +
 
 +
Recibe como parámetros un iterable y un valor, devolviendo un diccionario que contiene como claves los elementos del iterable con el mismo valor ingresado. Si el valor no es ingresado, devolverá none para todas las claves.
 +
 
 +
dic = dict.fromkeys(['a','b','c','d'],1)
 +
 
 +
dic →  {‘a’ : 1, ’b’ : 1, ‘c’ : 1 , ‘d’ : 1}
 +
 
 +
get()
 +
 
 +
Recibe como parámetro una clave, devuelve el valor de la clave. Si no lo encuentra, devuelve un objeto none.
 +
 
 +
dic = {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4}
 +
valor = dic.get(‘b’)
 +
 
 +
valor → 2
 +
 
 +
pop()
 +
 
 +
Recibe como parámetro una clave, elimina esta y devuelve su valor. Si no lo encuentra, devuelve error.
 +
 
 +
dic = {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4}
 +
valor = dic.pop(‘b’)
 +
 
 +
valor → 2
 +
dic → {‘a’ : 1, ‘c’ : 3 , ‘d’ : 4}
 +
 
 +
setdefault()
 +
 
 +
Funciona de dos formas. En la primera como get
 +
 
 +
dic = {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4}
 +
valor = dic.setdefault(‘a’)
 +
 
 +
valor → 1
 +
 
 +
Y en la segunda forma, nos sirve para agregar un nuevo elemento a nuestro diccionario.
 +
 
 +
dic = {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4}
 +
valor = dic.setdefault(‘e’,5)
  
−
dic → {‘nombre’ : 'nestor', ‘apellido’ : 'Plasencia', ‘edad’ : 22}
+
dic → {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4 , ‘e’ : 5}
  
−
zip()
+
update()
  
−
Recibe como parámetro dos elementos iterables, ya sea una cadena, una lista o una tupla. Ambos parámetros deben tener el mismo número de elementos. Se devolverá un diccionario relacionando el elemento i-esimo de cada uno de los iterables.
+
Recibe como parámetro otro diccionario. Si se tienen claves iguales, actualiza el valor de la clave repetida; si no hay claves iguales, este par clave-valor es agregado al diccionario.
  
−
dic = dict(zip('abcd',[1,2,3,4]))
+
dic 1 = {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4}
 +
dic 2 = {‘c’ : 6, ’b’ : 5, ‘e’ : 9 , ‘f’ : 10}
 +
dic1.update(dic 2)
  
−
dic →   {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4}
+
dic 1 → {‘a’ : 1, ’b’ : 5, ‘c’ : 6 , ‘d’ : 4 , ‘e’ : 9 , ‘f’ : 10}
  
 
===Tuples===
 
===Tuples===

Revisió del 18:57, 14 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(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

  • 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}
  • - zip(): rep dos elements iterables (cadenes, llistes o tuples) amb el mateix números d'elements i retorna un diccionari convinant els 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.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])


copy()

Retorna una copia del diccionario original.

dic = {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4} dic1 = dic.copy()

dic1 → {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4}

fromkeys()

Recibe como parámetros un iterable y un valor, devolviendo un diccionario que contiene como claves los elementos del iterable con el mismo valor ingresado. Si el valor no es ingresado, devolverá none para todas las claves.

dic = dict.fromkeys(['a','b','c','d'],1)

dic → {‘a’ : 1, ’b’ : 1, ‘c’ : 1 , ‘d’ : 1}

get()

Recibe como parámetro una clave, devuelve el valor de la clave. Si no lo encuentra, devuelve un objeto none.

dic = {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4} valor = dic.get(‘b’)

valor → 2

pop()

Recibe como parámetro una clave, elimina esta y devuelve su valor. Si no lo encuentra, devuelve error.

dic = {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4} valor = dic.pop(‘b’)

valor → 2 dic → {‘a’ : 1, ‘c’ : 3 , ‘d’ : 4}

setdefault()

Funciona de dos formas. En la primera como get

dic = {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4} valor = dic.setdefault(‘a’)

valor → 1

Y en la segunda forma, nos sirve para agregar un nuevo elemento a nuestro diccionario.

dic = {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4} valor = dic.setdefault(‘e’,5)

dic → {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4 , ‘e’ : 5}

update()

Recibe como parámetro otro diccionario. Si se tienen claves iguales, actualiza el valor de la clave repetida; si no hay claves iguales, este par clave-valor es agregado al diccionario.

dic 1 = {‘a’ : 1, ’b’ : 2, ‘c’ : 3 , ‘d’ : 4} dic 2 = {‘c’ : 6, ’b’ : 5, ‘e’ : 9 , ‘f’ : 10} dic1.update(dic 2)

dic 1 → {‘a’ : 1, ’b’ : 5, ‘c’ : 6 , ‘d’ : 4 , ‘e’ : 9 , ‘f’ : 10}

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])
Obtingut de «http://wikiserver.infomerce.es/index.php?title=ASIX-M3-UF1-A4&oldid=14351»