Diferència entre revisions de la pàgina «ASIX-M3-UF1-A4»
De wikiserver
(→Classes) |
(→Classes) |
||
Línia 740: | Línia 740: | ||
self.saldo = saldocli | self.saldo = saldocli | ||
− | nouclient = Client("Albert Pérez", | + | nouclient = Client("Albert Pérez", "32435465H", "Rue del Percebe, 13", 34232312, 123.45) |
</source> | </source> | ||
Revisió del 12:09, 15 març 2022
Contingut
[amaga]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
'Joan'
>>> 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'
- - Comparar lexicogràficament
>>>'Hola' > 'hola'
False
>>>'uno' > 'dos'
True
Funcions
- - len(cadena): ens diu la mida en caràcters d'una cadena (-1 si no la troba).
>>> len("Python3")
7
Mètodes
- - startswith(cadena) i endswith(cadena): indiquen si la cadena comença o acaba amb per la cadena pasada com a argument.
>>> cad = "python3 mètodes"
>>> cad.startswith("python3")
True
>>> cad.endswith("mètodes")
True
>>> cad.endswith("metodes")
False
- - 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
>>> llistaNums = [1, 2, 3, 4]
>>> for num in reversed(llistaNums) : # a l'inrevés
... num
...
4
3
2
1
- - Suma dels elements d'una llista
>>> llistaNums = [1, 2, 3, 4]
>>> sum(llistaNums)
10
- - str(): Mostrar el contingut de la llista com un String des d'un programa
print("Contingut llista: " + Str(llistaNoms))
['Maria', 'Pere', 'Carles', 'Sofia', 'Raquel', 'Joan']
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, 10]
>>> 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
https://www.w3resource.com/python-exercises/tuple/
- Indexació i slicing
>>> dies[0]
'dilluns'
>>> dies[-1]
['dissabte', 'diumenge']
>>> dies[2:4]
('dimecres', 'dijous')
>>> dies[2:-1]
('dimecres', 'dijous', 'divendres')
- Element en tupla?
>>> 'dimecres' in dies
True
>>> 'gener' in dies
False
- -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
- Tupla buida
>>> tup = ()
>>> tup
()
>>> tupla = tuple()
>>> tupla
()
- assignació multiple
>>> tupla = 2, 2, 3
>>> tupla
(2, 2, 3)
>>> num1, num2, num3 = tupla
>>> num1 + num2 + num3
7
>>> num1, num2, num3, num4 = tupla
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: need more than 3 values to unpack
- afegir elements a la tupla
>>> tupla = (2, 4, 6, 8)
>>> tupla = tupla + (10,) # No es pot fer amb cadenes
>>> tupla
(2, 4, 6, 8, 10)
>>> tupla = tupla[:3] + (12, 14, 16)
>>> tupla
(2, 4, 6, 12, 14, 16)
- convertir tupla a llista i a l'inrevés
>>> llista = list(tupla)
>>> llista
[2, 4, 6, 12, 14, 16]
>>> llista.append(18)
>>> llista
[2, 4, 6, 12, 14, 16, 18]
>>> tupla = tuple(llista)
>>> tupla
(2, 4, 6, 12, 14, 16, 18)
- convertir tupla a cadena
>>> tupla = ('p', 'y', 't', 'h', 'o', 'n')
>>> tupla
('p', 'y', 't', 'h', 'o', 'n')
>>> cadena = ''.join(tupla)
>>> cadena
'python'
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
Classes
Python permet crear els teus propis tipus de dades mitjançant classes i objectes.
Una classe es un tipus de dada definit pel programador, i per crear objectes d'aquesta classe cal fer instàncies a la mateixa.
Exemple classe client:
class Client:
nom =''
nif = ''
adreça = ''
numCompte = 0
saldo = 0
Per poder utilitzar aquesta classe hem de fer una instància:
nouClient = Client()
Podem identificar a quina classe pertany nouClient i quin espai de memòria ocupa:
print(nouClient)
<__main__.Client object at 0x7eff7844e978>
Per accedir els camps:
nouClient.nom = "Albert Pérez"
nouClient.nif = ”32435465H”
nouClient.adreça= ”Rue del Percebe, 13”
nouClient.numCompte= 34232312;
nouClient.saldo= 123.45
Una forma elegant de inicialitzar la variable (objecte) és utilitzant el mètode inicialitzador:
class Client:
def __init__(self, nomcli, nifcli, adrcli, comptecli, saldocli):
self.nom = nomcli
self.nif = nifcli
self.adreça = adrcli
self.numCompte = comptecli
self.saldo = saldocli
nouclient = Client("Albert Pérez", "32435465H", "Rue del Percebe, 13", 34232312, 123.45)
al = Alumne() al.nom ='Pepe' al.edat = 27 print(al.nom) print(al.edat)