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

Revisió del 11:50, 15 març 2022 (mostra codi font) Rsort (Discussió | contribucions) (→‎Classes) ← Vés a l'edició anterior		Revisió de 12:52, 15 març 2022 (mostra codi font) Rsort (Discussió | contribucions) (→‎Classes)
(Hi ha 6 revisions intermèdies del mateix usuari que no es mostren)
Línia 702:		Línia 702:
	Exemple classe client:		Exemple classe client:
−		+	<source lang="python">
	class Client:		class Client:
	nom =''		nom =''
Línia 709:		Línia 709:
	numCompte = 0		numCompte = 0
	saldo = 0		saldo = 0
−		+	</source>
	Per poder utilitzar aquesta classe hem de fer una instància:		Per poder utilitzar aquesta classe hem de fer una instància:
−		+	<source lang="python">
	nouClient = Client()		nouClient = Client()
−		+	</source>
	Podem identificar a quina classe pertany nouClient i quin espai de memòria ocupa:		Podem identificar a quina classe pertany nouClient i quin espai de memòria ocupa:
−	<souce lang="python">	+	<source lang="python">
	print(nouClient)		print(nouClient)
	<__main__.Client object at 0x7eff7844e978>		<__main__.Client object at 0x7eff7844e978>
	</source>		</source>
−		+	Per accedir els camps:
−		+	<source lang="python">
	nouClient.nom = "Albert Pérez"		nouClient.nom = "Albert Pérez"
−	client.nif = ”32435465H”	+	nouClient.nif = ”32435465H”
−	client.adreça=”Rue del Percebe, 13”;	+	nouClient.adreça= ”Rue del Percebe, 13”
−	client.numCompte= 34232312;	+	nouClient.numCompte= 34232312;
−	client.saldo=123.45;	+	nouClient.saldo= 123.45
		+	</source>
		+	Una forma elegant de inicialitzar la variable (objecte) és utilitzant el mètode inicialitzador:
		+	<source lang="python">
		+	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)
		+	print(nouClient.adreça)
		+	</source>
−		+	Llistes de clients. Omplir una llista amb quatre clients i a continuació mostreu les dades dels quatre clients:
−		+	<source lang="python">
−	'''  def __init__(self, nom):	+	class Client:
−	self.nom = nom'''	+	nom =''
−		+	nif = ''
−	al = Alumne()	+	adreça = ''
−	al.nom ='Pepe'	+	numCompte = 0
−	al.edat = 27	+	saldo = 0
−	print(al.nom)	+	NUMCLIENTS = 4
−	print(al.edat)	+	llCli = []
		+	for i in range(NUMCLIENTS):
		+	print("Introdueix les dades del client %d" %(i+1))
		+	nouClient = Client()
		+	nouClient.nom= input("Nom: ")
		+	nouClient.nif= input("nif: ")
		+	nouClient.adreça= input("adreça: ")
		+	nouClient.numCompte= input("numCompte: ")
		+	nouClient.saldo= input("saldo: ")
		+	llCli.append(nouClient)
		+	print("")
		+	print("Dades de tots els clients ")
		+	print("")
		+	for i in range(len(llCli)):
		+	print("Client %d" %(i+1))
		+	print("  Nom: " + llCli[i].nom )
		+	print("  Nif: " + llCli[i].nif )
		+	print("  Adreça: " + llCli[i].adreça )
		+	print("  Número de compte: " + llCli[i].numCompte )
		+	print("  Saldo: " + llCli[i].saldo )
		+	</source>
	==Referències==		==Referències==

---

Revisió de 12:52, 15 març 2022

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

[1]

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)
print(nouClient.adreça)

Llistes de clients. Omplir una llista amb quatre clients i a continuació mostreu les dades dels quatre clients:

class Client:
   nom =''
   nif = ''
   adreça = '' 
   numCompte = 0
   saldo = 0
NUMCLIENTS = 4
llCli = []
for i in range(NUMCLIENTS):
    print("Introdueix les dades del client %d"  %(i+1))
    nouClient = Client()
    nouClient.nom= input("Nom: ")
    nouClient.nif= input("nif: ")
    nouClient.adreça= input("adreça: ")
    nouClient.numCompte= input("numCompte: ")
    nouClient.saldo= input("saldo: ")
    llCli.append(nouClient)  
print("")
print("Dades de tots els clients ")
print("")      
for i in range(len(llCli)):
    print("Client %d" %(i+1))
    print("  Nom: " + llCli[i].nom )
    print("  Nif: " + llCli[i].nif )
    print("  Adreça: " + llCli[i].adreça )
    print("  Número de compte: " + llCli[i].numCompte )
    print("  Saldo: " + llCli[i].saldo )

Referències