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

Revisió de 12:52, 15 març 2022

Contingut

1 Cadenes
2 Col·leccions de dades
3 Classes
4 Referències

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 )

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

Revisió de 12:52, 15 març 2022

Contingut

Cadenes

Operacions amb cadenes

Funcions

Mètodes

Executar programes amb arguments

Col·leccions de dades

Llistes

Operacions

Mètodes

Llistes imbricades

Diccionaris

Operacions

Mètodes

Tuples

Operacions

Mètodes

Classes

Referències

Menú de navegació

Eines de l'usuari

Espais de noms

Variants

Vistes

Més

Cerca

Navegació

Mòduls

Eines