Python és un llenguatge modern i potent, amb poc esforç es poden programar accions que en altres llenguatges de programació resulten laborioses. És del tipus interpretat, com els llenguatges d'script, i orientat a objectes. En aquest article usem dos recursos: 1) el intèrpret en línia de Python en la versió 3, en un Linux Ubuntu 20.04, els exemples s'identifiquen per que les línies comencen ammb els símbols >> > com ara:
jordi@jordi-sve1513c5e:~$ python3
Python 3.8.5 (default, Jul 28 2020, 12:59:40)
[GCC 9.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>
També usarem els tutorials de https://www.w3schools.com/python que permeten executar codi, seran els exemples sense els ">>>".
Variables simples
Les variables es declaren simplement usant-les:
>>> salutacio="hola"
>>> salutacio
'hola'
>>> salari=40000
>>> salari
40000
Hem creat, i mostrat a continuació, una variable de tipus text i un altre de tipus numèric enter. De la mateixa forma directa podem crear variables de tipus numèric amb decimals i usar Python com a calculadora:
>>> irpf=22.4
>>> irpf
22.4
>>> retencio=6000*irpf/100
>>> retencio
1344.0
>>>
Les variables són molt flexibles, poden anar canviar de contingut sense cap problema:
from datetime import datetime
time = datetime.now() #importa data i hora sistema
x = 5 #variable x numèrica
y = "John Dillinger"
x = (time.strftime("%I:%M:%S")) #variable x data
print(x)
print(y)
En cada instant podem comprovar el tipus de variable que és:
>>> type(x)
<class 'int'>
>>>
Cal tenir en compte que es diferencia entre majúscules i minúscules:
>>> X="Python"
>>> print(x)
100
>>> print(X)
Python
>>>
Es poden donar valors de forma compacta:
>>> x , X = 100, "Python"
>>> print(x)
100
>>> print(X)
Python
>>>
Els diferents tipus de variables permesos són:
| Text: | str |
| Numeric: |
int, float,
complex |
| Llistes: |
list, tuple,
range |
| Mapeig: |
dict |
| Conjunts: |
set, frozenset |
| Booleà: |
bool |
| Binari: | bytes, bytearray,
memoryview |
Variables de tipus objecte i mòduls Python
Les
variables de tipus objecte a més a més d'un valor també tenen
associades accions, es poden fer accions predeterminades amb elles. Un
exemple seria una variable de tipus data per contindre un dia del
calendari; Python disposa de mòduls, que venen a ser una mena de plug-ins que es poden cridar amb la instrucció import per usar-los si ens convé, entre aquests mòduls està time.
>>> import time
>>> time.strftime("%d/%m/%y")
'10/02/21'
>>>
Si mirem el tipus de variable que és time veiem que ens diu "classe mòdul":
>>> import time
>>> type(time)
<class 'module'>
>>>
La funció strftime forma part de la classe time extreu la data del sistema, en el format especificat. En general és recomanable usar print per mostrar variables:
>>> print (time.strftime("%I:%M:%S"))
01:49:34
>>>
Les variables de tipus objecte s'agrupen en classes d'objectes; per exemple podem crear una classe de forma simple:
>>> class MyClass:
... x = 5
...
>>> p1 = MyClass()
>>> print(p1.x)
5
>>>
defineix una classe d'objectes MyClass; qualsevol variable que formi part de la classe contindrà una subvariable x (més correctament, una propietat de la classe). Les dues primeres línes defineixen la classe, la tercera (en blanc) acaba la definició, després creem la variable p1 del tipus classe Myclass, i per últim mostrem la seva propietat x.
En Python la indentació és necessària, indica quan acaben les instruccions que ocupen diverses línies. Per exemple:
>>> class Myclass:
... x = 5
File "<stdin>", line 2
x = 5
^
IndentationError: expected an indented block
obtenim un error degut a que no hem indentat la línia de declaració de la propietat x; cal fer-ho amb el tabulador.
En aquesta introducció no entrarem en detalls de la programació orientada a objectes (constructors, destructors, etc).
Llistes
Les llistes són variables que poden guardar molt valors de forma ordenada, estructurada, classificant cada valor segons la seva posició a la llista, començant per la posició 0:
>>> llista = ["Python","Powershell", "C", "Java"]
>>> print (llista[0])
Python
>>> print (llista)
['Python', 'Powershell', 'C', 'Java']
>>>
Els valors poden ser de qualsevol tipus:
>>> llista = ["Python",100, 3.14159]
En realitat les llistes són objectes de la classe list:
>>> type(llista)
<class 'list'>
Per tant qualsevol llista contindrà certes propietats i accions predefinides; per exemple per ordenar alfabèticament la llista:
llista = ["Python","Powershell", "C", "Java"]
llista.sort()
print(llista)
['C', 'Java', 'Powershell', 'Python']
Les llistes contenen molt altres mètodes, veure.
Podem modificar qualsevol valor donant la seva posició:
>>> llista[1]="Powershell"
Es pot canviar un valor per varis valors, insertant-los usant un rang com ara:
>>> llista
['Python', 'Powershell', 3.14159]
>>> llista[1:2]=["C", "Yaml"]
>>> llista
['Python', 'C', 'Yaml', 3.14159]
>>>
veiem que el valor 1, "Powershell" ha estat subsistit per 2 valors "C" i "Yaml".
Llistes de llistes
Com dintre d'una llista podem ficar qualsevol variable de qualsevol tipus, fins i tot podem ficar llistes dintre de llistes:
>>> Llenguatges=[llista, "javascript"]
>>> print(Llenguatges)
[['C', 'Java', 'Powershell', 'Python'], 'javascript']
>>>
Observem que la primera dada de la llista Llenguatges és un altre llista. En el cas particular de que una llista contingui exclusivament altres llistes, tindrem una "llista de llistes", que sovint en l'argot de programació s'anomena una matriu:
>>> Llenguatges=[llista, ["javascript","Java","PHP","CSS"]]
>>> print(Llenguatges)
[['C', 'Java', 'Powershell', 'Python'], ['javascript', 'Java', 'PHP', 'CSS']]
>>>
Python permet crear llistes inicialment buides, i després anar afegint elements conforme necessitem espai usant la funció predeterminada append:
llista = []
llista.append("a")
llista.append("b")
print(llista)
['a', 'b']
També amb append podem afegir llistes a llistes:
>>> comarques_famílies=[]
>>> comarques_famílies.append(['Baix Camp'])
>>> comarques_famílies.append(['Alt Camp'])
>>> print (comarques_famílies)
[['Baix Camp'], ['Alt Camp']]
Fixem-nos amb els dobles claudàtors, indiquen que tenim una llista de llistes amb dues llistes, cada una amb un únic element. Anem a afegir un segon element en la primera llista:
comarques_famílies[0].append('INS Baix Camp')
>>> print (comarques_famílies)
[['Baix Camp', 'INS Baix Camp'], ['Alt Camp']]
>>>
El contrari d'afegir és eliminar: remove elimina el 1r element que coincideixi amb l'especificat; fixem-nos en què passa amb aquesta inserció:
>>> comarques_famílies.append('INS Baix Camp')
>>> print(comarques_famílies)
[['Baix Camp', 'INS Baix Camp'], ['Alt Camp'], 'INS Baix Camp']
>>>
Com no hem especificat en quina llista volem inserir el valor, s'ha inserit al final, fora de les dues llistes; suposem que no és el que voliem fer, i ara volem esborrar aquest valor;
>>> comarques_famílies.remove('INS Baix Camp')
>>> print(comarques_famílies)
[['Baix Camp', 'INS Baix Camp'], ['Alt Camp']]
Fet. No ha esborrat el valor que està dins de la 1a subllista per que no ho hem especificat; en canvi si fem
>>> comarques_famílies[0].remove('INS Baix Camp')
>>> print(comarques_famílies)
[['Baix Camp'], ['Alt Camp']]
ara sí ha eliminat el valor de la 1a llista.
Una altre característica molt flexible és l'anomenar cada llista amb un nom, i juntar-les totes en una llista de llistes amb noms:
>>> a = ["apple", "banana", "cherry"]
>>> b = ["Ford", "BMW", "Volvo"]
>>> c = [a, b]
>>> print(c)
[['apple', 'banana', 'cherry'], ['Ford', 'BMW', 'Volvo']]
>>>
Si després modifiquen les llistes a o b, la llista de llistes c automàticament s'actualitza:
>>> a.append("orange")
>>> b.append("Honda")
>>> print(c)
[['apple', 'banana', 'cherry', 'orange'], ['Ford', 'BMW', 'Volvo', 'Honda']]
>>>
Fitxers font Python
Si guardem el codi font de Python en un fitxer de text, per exemple fitxer.py, després podrem executar-lo des del shell simplement escrivint:
python3 fitxer.py
La majoria d'editors de codi reconeixen l'extensió .py i per tant reconeixen les instruccions Python.
Lectura de dades externes al programa
Si importem el mòdul sys obtenim l'objecte stdin (entrada estàndard), que conté la funció readlines() capaç de llegir un fitxer des de l'entrada estàndard línia a línia. Per exemple, el següent programa:
import sys
for order in sys.stdin.readlines():
print(order)
llegirà de l'entrada estàndard (el teclat) línia a línia de text i la mostrarà per la sortida estàndard (el monitor):
jordi@jordi-sve1513c5e:~/Documents/Feina/M6 2020/UF2$ python3 linia.py
hola
adeu
El problema és que la lectura no té final; però si redireccionem l'entrada estàndard a un fitxer de text (l'anomenem prova en l'exemple a continuació), llavors sí s'atura en arribar al final del fitxer:
jordi@jordi-sve1513c5e:~/Documents/Feina/M6 2020/UF2$ cat prova | python3 linia.py
linia 1
linia 2
jordi@jordi-sve1513c5e:~/Documents/Feina/M6 2020/UF2$
Les línies en blanc es poden eliminar usant la funció strip de la classe string (cadenes de text) doncs la variable order que retorna la lectura és un string:
import sys
for order in sys.stdin.readlines():
linia = order.strip()
print(linia)
Hem usat l'anomada estructura de control de programa for ... in, que té la segënt estructura general
for variable in llista:
accions
La classe stdout del mòdul sys té la funció write que permet escriure resultats amb format més complert que la funció simple print:
import sys
for order in sys.stdin.readlines():
linia = order.strip()
print(linia)
sys.stdout.write("darrera línia llegida: %s\n" % linia)
Resultat:
jordi@jordi-sve1513c5e:~/Documents/Feina/M6 2020/UF2$ cat prova | python3 linia.py
linia 1
linia 2
darrera línia llegida: linia 2
jordi@jordi-sve1513c5e:~/Documents/Feina/M6 2020/UF2$
Exercicis
1. Tenim un fitxer de text de 4 línies amb el següent contingut:
Baix Camp;43002594 Institut Baix Camp;Serveis Socioculturals i a la Comunitat;Instal·lació i Manteniment;Serveis Socioculturals i a la Comunitat;Vidre i Ceràmica;Indústries Alimentàries
Baix Camp;17001759 Ins Escola d'Hoteleria i Turisme;Hoteleria i Turisme
Tarragona;43006630 Institut Pere Martell (Tarragona);Administració i Gestió;Fusta, Moble i Suro;Informàtica i Comunicacions;Tèxtil, Confecció i Pell;Indústries Alimentàries
Tarragona;43003653 Institut Comte de Rius (Tarragona);Transport i Manteniment de Vehicles;Instal·lació i Manteniment;Comerç i Màrqueting;Serveis Socioculturals i a la Comunitat
Llegiu totes les línies del fitxer i guardeu cada línia en una llista de Python, cada element de la llista serà un valor de tipus String.
2. Seguint amb l'exercici anterior; la funció count de la classe string retorna el nombre de ocurrències d'un text dins d'un string. Sabent que el fitxer de centres d'FP conté en cada fila la comarca, el nom d'un centre d'FP, i una llista d'especialitats, tot separat per comes, useu count per comptar els ";" de cada fila, li resteu 1, i mostreu el text "nombre d'especialitats:" i seguidament el valor calculat.
3. Seguint amb l'exercici anterior, volem formar una matriu que contingui per cada línia la comarca i el nombre d'especialitats de cada comarca;
['Priorat', 2, 'Alt Camp', 4, 'Tarragona', 5, 'Tarragona', 3, 'Baix Camp', 5, 'Baix Camp', 1, 'Tarragona', 5, 'Tarragona', 4]
Per extreure el nom de la comarca podeu usar alguna de les funcions de la classe string; suggeriment: la funció split "trenca" un string en elements individuals i els deixa en una llista
linies = linia.split(";")
deixarà en la llista línies cada dada (nom de comarca, nom de centre, ...) com a element de la llista línies.
