UD3. Introducció a Python

Al tema anterior, per començar a vore els principis de la programació estructurada hem vist algorismes en ordinograma i la seua implementació en Python. En este tema aprofundirem un poc més en Python pel que fa als operadors i expressions, així com a l'entrada i eixida de dades. A més, com que més endavant es vorà el llenguatge Java, conforme anem veient coses en Python, anirem dient ja les diferències en java. Estes diferències solen ser iguals en Java i en C.

Característiques bàsiques de Python

Python és un llenguatge creat a finals dels 80 per Guido Van Rossum, i deu el seu nom a l'afició pel grup còmic britànic Monty Python.

És un llenguatge de programació interpretat, de tipificació dinàmica i multi plataforma. És de propòsit general, fins i tot per a la creació de scripts.

Què necessitem per a programar en Python?

Ho podem fer de diverses maneres:

• Usar un intèrpret online (no cal instal·lar res)

  Per exemple, onlinegdb.com. Caldrà seleccionar el llenguatge Python 3, escriure el codi i polsar Run.

• Instal·lar l'intèrpret de Python: www.python.org/downloads

  Una vegada instal·lat (Linux ja el porta) podrem:

  • Provar comandaments en mode interactiu: en el terminal escriurem python3. Entrarem en el mode interactiu: després de fer intro en cada instrucció, s'executarà.

  

  • Escriure el programa en un fitxer de text: Li direm, per exemple, holaMon.py, i l'executarem amb: python3 holaMon.py. No cal compilar res, perquè Python és interpretat.

  • Usar un IDE (Entorn de Desenvolupament Integrat): Per exemple, Visual Studio Code. Potser calga instal·lar l'extensió de Python. Escriurem el nostre programa, el guardarem (holaMon.py) i l'execurarem amb la icona del triangle.

Estructura d'un programa en Python

Un programa en Python té una estructura molt simple:

• No s'ha de posar punt i coma després de cada instrucció.
• No es posen delimitadors de bloc de programa. Simplement se sangra.
• No cal indicar el tipus de dades de les variables.

Qualsevol programa escrit en Pyhton té la següent estructura:

Veiem que l'única part (pràcticament) necessària en un programa és l'entrada, processament i la sortida de dades, com en qualsevol llenguatge de programació.

En Python estos apartats poden variar de posició.

Veiem uns exemples i els analitzem.

L'exemple més simple, mostrar un missatge per pantalla:

print("Hola, Pep")

Un altre exemple més complet:

# Programa que calcula l'àrea d'un rectangle (1)
# Autor: Pep Garcia
# Data: 2024/10/01

import time  #(2)!

def areaRectangle(base, altura): # (3)!
    return base * altura

b = int(input("Dis-me la base del rectangle: ")) #(4)!
a = int(input("Dis-me l'altura del rectangle: "))

time.sleep(2) # Espera 2 segons

area = areaRectangle(b, a) #(5)!

print("L'àrea del rectangle és", str(area)) #(6)!

1. Descripció del programa
2. Importació de llibreries
3. Definició de funcions
4. Entrada de dades
5. Processament de dades
6. Sortida de dades

Exemple

Copia i apega el codi anterior en l'IDE que tingues de Python i executa'l per vore què fa.

Comentem, per adamunt, algunes coses del programa que més endavant ampliarem:

• Descipció del programa. Son comentaris, no s'executen.
• A l'import indiquem que necessitem una llibreria: conjunt de funcions que ja estan implementades i les podem fer servir als nostres programes. En este exemple la llibreria és time i ens cal per a usar la funció time.sleep() que fa que el prgrama pare en eixe punt uns segons (2 en este cas).
• Desprès tenim la definició d'una funció, que comença amb la paraula reservada def. Tot el que es pose dins del bloc de la definició d'una funció ha d'anar sagnat (en este cas és només la instrucció return).
• Després ja tenim el nostre programa pròpiament dit, on veiem que:
  • Les línies no tenen cap sagnat (van just a l'esquerra)
  • Amb els input aconseguim que s'introduisquen dades per teclat.
  • Es fa la crida a la funció que hem definit abans (areaRectangle).
  • Finalment mostrem a l'usuari el resultat (print).

Noms de variable i funcions en Python

Abans hem vist que hem posat noms de variable i funcions. Estos noms han de tindre unes regles, que solen ser les mateixes en tots els llenguatges, encara que poden variar un poc. En Python estes són les regles per als noms de variables i funcions:

Regles per a noms de variables i funcions en Python

• Son una combinació de lletres minúscules [ a...z ], majúscules [ A...Z ], dígiint [ 0...9 ] i el caràcter subratllat [ _ ].
• Poden tindre qualsevol longitud.
• S'admeten els accents, la ç i la ñ.
• No poden haver símbols especials ni operadors: [, !, @, #, $, %, *, ...
• No poden començar amb dígit.
• No poden ser paraules reservades:

Variables

Les variables són els llocs on es guarda la informació (per exemple, els llocs on es guarda cada dada introduïda per teclat).

Es poden classificar en globals i locals:

• Variables globals: es creen fora de qualsevol funció. Es pot accedir a elles des de qualsevol part del programa.
• Variables locals: es creen dins d'una funció. Es pot accedir a elles només des d'eixa funció.

Més endavant vorem els tipus de dades (enter, caràcter, etc) de les variables.

Comentaris

En algunes parts del programa cal que el programador pose anotacions per a:

• Recordar el que ha fet, per a futures modificacions.
• Indicar a altres programadors com s'ha fet alguna cosa.
• Indicar la data (o autor, etc.) de creació del programa.

Tipus de comentaris:

• D'una línia:
  • Precedit per coixinet: # soc un comentari
  • Entre cometes simples: 'soc un comentari'
  • Entre cometes dobles: "soc un comentari"
• De diverses línies:
  • entre trios de cometes simples: ' ' '
  • entre trios de cometes dobles: " " "
• De documentació de funcions: si posem un comentari entre cometes en la primera línia dins d'una funció (per a explicar què fa) després podrem accedir a eixe comentari des d'altres parts del programa. Ara ho veurem.

Veiem en este programa exemples dels diferents tipus de comentaris:

'''
Programa que calcula l'area d'un rectangle
Autor: Pep Garcia
Data: 1-10-2024
'''
import time
# -----------------------------------------
def areaRectangle(b, a):
    '''
    Esta funció calcula l'àrea d'un rectangle
    Paràmetres:
        b -> La base del rectangle
        a -> L'altura del rectangle
    '''
    return b*a
# -----------------------------------------

# Entrada de dades per teclat:
base = int(input("Dis-me la base del rectangle: "))
altura = int(input("Dis-me l'altura del rectangle: "))

# Càlculs
time.sleep(2) # Espera dos segons
area = areaRectangle(base, altura)

# Eixida de resultats per pantalla:
print("L'àrea del rectangle és", str(area))

Ens alguns IDE com el Visual Studio Code, si poses el cursor damunt del nom d'una funció et mostra els comentaris que has posat en ella:

Delimitacions

Son símbols especials que permeten al compilador reconéixer les diferents parts del programa.

El més important és el finalitzador de sentències, que, en molts llenguatges de programació (com C i Java) és el pun i coma ( ; ) però Python fa servir simplement el bot de línia.

Ací tenim els delimitadors que s'usen en Python.

Python	C i Java	Nom	Utilitat
Salt de línia	;	Finalitzador	- Finalitzar una instrucció simple o una declaració de variables
Tabulació	{ }	Bloc	- Delimitar inici i fi d'un bloc de codi
,	,	Separador	- Separar els elements d'una llista
( )	( )	Parèntesi	- Agrupar operacions - Paràmetres de funcioins
[ ]	[ ]	Claudàtors	- Per a vectors, llistes...

Tipus de dades

Les dades que manegen els programes són de distints tipus: lletres, números sense decimals, amb decimals...

Per tant, les variables seran d'un tipus determinat. En la majoria de llenguatges de programació, abans d'utilitzar una nova variable, cal definir-la (declarar-la): indicar de quin tipus és. Però en Python no cal. Simplement el tipus de la variable serà del mateix tipus que el valor que li s'assigne.

edat = 30
nom = "Pep"
pes = 74.5
casat = True

Veiem els distints tipus que solen tindre els llenguatges de programació.

Tipus elementals

En Python hi ha 4 tipus bàsics: enter, amb decimals, cadena i lògic.

Altres llenguatges, com C i Java, en tenen més, per a indicar enters xicotets o grans, amb signa o sense... Igual que per a números amb decimals.

Números enters: int

Números enters (sense decimals).

Quan posem un número s'interpreta que està en sistema de numeració decimal. Però podem dir-li que ho interprete com a binari, octal o hexadecimal:

print(11)   # Número 11 en sistema decimal. Mostra 11
print(0b11) # Numero 11 en sistema binari. Mostra 3
print(0o11) # Número 11 en sistema octal. ostra 9
print(0x11) # Número 11 en sistema hexadecimal. Mostra 17

El print mostra el número en sistema decimal.

Números amb decimals: float

Números amb decimals

print(5.2)  # mostra 5.2
print(5.)   # mostra 5.0
print(.2)   # mostra 0.2
print(5e2)  # mostra 500
print(5e-2) # mostra 0.05

Lògics: bool

Serveix per si una variable volem que tinga 2 únics estats (vertader o fols). Els únics valors que pot tindre una variable d'este tipus són True o False.

majorEdat = True
jubilat = False

Ens servirà per a quan usem sentències condicionals (ja entrarem en detall):

if jubilat:
    print("Està jubilat")
else:
    print("No està jubilat")

NOTA

En C++ i Java és true i false (en minúscula). C no té eixe tipus de dades com a tal (usa el 0 per a false i l'1 per a true).

Cadenes: str

És el tipus de dades per a guardar una cadena de caràcters (un nom de persona, per exemple). Una dada de tipus str és una successió de 0 o més caràcters dins de cometes simples o dobles (encara que es recomana entre cometes dobles, ja que molts llenguatges només admeten les dobles).

nom = "Pep Garcia"
domicili = 'Carrer La Punt, 54'
print("Nom de l'alumne:", nom)

Per a guardar cadenes els llenguatges utilitzen formes distintes:

• En C no és un tipus sinó un vector de caràcters (ja vorem els vectors).
• En Java no és un tipus, sinó una classe (ja vorem les classes).
• En Python sí que és un tipus de dades.

Seqüències d'escapament

Per a poder posar unes cometes dobles dis d'una cadena amb cometes dobles es pot usar el caràcter d'escapament \. També per a cometes simples:

print("Podem mostrar 'i \" dins de cometes dobles")
print('Podem mostrar \' i " dins de cometes simples')

En una cadena de text també podem utilitzar este caràcter d'escapament per a representar diverses accions:

Python, C i Java	Acció	Exemple	Resultat
\n	Nova línia	print("Hola\nAdéu")
\t	Tabulador	print("Hola\tAdéu")	Hola Adèu
\r	Retorn de carro	print("Hola\rTu")	Tula
\b	Backspace	print("Hola\bAdéu")	HolAdéu

Encara que les més emprades són \n i \t.

Totes estes seqüències d'escapament també es poden usar en C i Java.

Tipus composts

Els tipus simples (que acabem de veure) serveixen quan hem de guardar una informació simple. És a dir, formada per una sola dada (una temperaura, un nom, una edat...)

Però si volem guardar en una variable el domicili d'un client (format per un carrer, número, codi postal...) o una data (dia, mes any), el programador haurà de definir un tipus de dades compost. Estos tipus de dades compostos els vorem més endavant.

Declaració de variables

Una variable és una porció de memòria (RAM), representada per un nom (identificador) on es guardarà un valor que pot variar al llarg de l'execució d'un programa.

Declarar una variable vol dir indicar de quin tipus serà eixa variable. Depenent del llenguatge de programació caldrà declarar les variables o no. Per tant, atenent a este criteri, tenim 2 tipus de llenguatges de programació:

Llenguatges de tipificació estàtica (C, Java... però no Python)

Estos llenguatges obliguen a indicar de quin tipus serà una variable abans d'usar-la. Després, al moment de fer servir les variables, el llenguatge controla que el valor que s'assigne a una variable corresponga al tipus de la variable. Si no és el cas, donarà error-

int n;
float x;
n = 3;
n = "Pep";  // Error perquè no és del mateix tipus.
n = 4.7;    // No dóna error però lleva la part decimal. Guardarà un 4.
z = 6;      // Error perquè la variable z no està declarada prèviament.

Llenguatges de tipificació dinàmica (Python, PHP...)

En estos llenguatges no es declara la variable prèviament. Simplement quan se li assigna un valor, la variable agafa el tipus d'eixe valor. I pot variar de tipus cada vegada que se li assigna un nou valor.

n = 7       # Primera vegada que ix la variable n. n val 7 i és int
n = 5.67    # Ara n val 5.67. Per tant, ara és float
n = 9       # Ara n val 9. Per tant, torna a ser int
n = n+2     # Ara n val 11. Continua sent int
n = n/4     # Ara n val 2.75. Per tant, ara n és float
n = "Pep"   # Ara n és str (cadena)
n = n+2     # ERROR. No li podem sumar 2 al text "Pep"

Com veiem a l'exemple, no tindrem les situacions d'error dels llenguatges de tipificació estàtica (ja que no s'ha de declarar la variable i poden canviar de tipus). Però pot ser un desavantatge ja que podria ser que volguérem que en fer la divisió de 11/4 volguérem guardar la part entera (2) i no 2.75. Ens pot portar a situacions inesperades o inconsistents. Caldrà anar en compte en estos casos.

NOTA

Si en algun moment parlem de "declarar" una variable en Python, ens estarem referint al primer moment del programa on li s'assigna un valor a eixa variable.

Àmbit i visibilitat

NOTA

Aquestos conceptes s'explicaran en detall quan veiem la programació modular (funcions). No obstant, veiem un avanç.

Les variables poden "declarar-se" (començar a usar-se) en qualsevol part del programa, però segons el lloc on siguen declarades, les podrem fer servir només en alguna part (variables locals) o bé en tot el programa (variables globals).

Exemple 1

La variable a és local a la funció "funcioneta"

# ---------------------
def funcioneta():
    a = 3 # declarem la variable 'a' com a LOCAL (dins de la "funcioneta")
    print(a)
# ---------------------

print("El programa comença a executar-se per ací")
funcioneta()
print(a) # ERROR perquè accedim a la variable local de "funcioneta"

Si una variable està declarada dins d'una funció, només podem accedir a ella dins d'eixa funció.

Exemple 2

# ------------------------
def funcioneta():
    print(a)
# ------------------------

print("El programa comença a executar-se per ací")
a = 3   # Declarem la variable 'a' com a GLOBAL (fora de les funcions)
funcioneta()
print(a)

Si una variable "delarada" (primer ús) fora de les funcions, podrem accedir a ella des de qualsevol lloc del programa (bé, sempre després de ser declarada). Però ja vorem que no convé declarar variables globals.

L'àmbit i visibilitat d'una variable són conceptes íntimament relacionats. Fan referència a des d'on es pot accedir a una variable:

• La visibilitat és la propietat que indica si es pot accedir o no a una variable en un punt determinat del programa.
  • En l'exemple 1:
    • Dins de la funció "funcioneta" sí que hi ha visibilitat de 'a'.
    • Fora de la funció "funcioneta" no hi ha visibilitat de 'a'.
  • En l'exemple 2:
    • En tot el programa sí que hi ha visibilitat de 'a'.
• L'àmbit és la zona del programa on és visible una variable.
  • En l'exemple 1, l'àmbit de 'a' és dins de la funció "funcioneta"
  • En l'exemple 2, l'àmbit de 'a' és a tot el programa.

En C i Java, a més de definir variables locals a una funció es poden definir locals a un bloc de codi, tancat entre claus { }. En eixe cas, eixes variables només poden ser accedides dins d'eixe bloc de codi.

En Python un bloc seria el trós de codi (seguit) amb el mateix sagnat (o subsagnat). Però si una variable es declara en eixe bloc, en Python sí que podem accedir des d'altres blocs, encara que no és recomanable:

if (edat >= 18):
    major = True #(1)!
else:
    major = False

print(major) #(2)!

1. El primer ús de "major" es fa en este bloc
2. Però Python em permet usar-la fora del bloc

En canvi, és recomanable declarar la variable en el "bloc de fora":

major = False #(1)!

if (edat >= 18):
    major = True

print(major) #(2)!

1. Declarem la variable en el "bloc de fora"
2. ... ja que vaig a usar-la en eixe bloc

Operadors

Anem a veure els distints operadors que solen tindre els llenguatges de programació i a contruir expressions amb elles, així com la forma d'introduir dades per teclat i mostrar resultats per pantalla.

Operadors aritmètics

Python	C i Java	Significat	Observacions
+	+	Suma
-	-	Resta o signe
*	*	Multiplicació
/	/	Divisió amb decimals (11/4 -> 2.75)	En C i Java: (11/4 -> 2 -- 11/4.0 -> 2.75)
//	NO	Divisió entera (11//4 -> 2)
%	%	Residu divisió entera (21%4 -> 1)
**	NO	Potència (2**3 -> 8)

Operadors relacionals

Python	C i Java	Significat
==	==	Igual
!= <>	!=	Distint
<	<	Menor
<=	<=	Menor o igual
>	>	Major
>=	>=	Major o igual

Ja veurem que, principalment, estos operadors s'utilitzen en les condicions de les instruccions if i while.

Exemples

if (nota >= 5):
    print("Aprovat")
...

while (edat < 0):
    print("Edat incorrecta. Torna-me-la a dir")
...

Operadors lògics

Ja veiérem al primer tema quins eren els operador l'ogics i com actuaven (recordeu les "taules de veritat"). Veiem ara com es representen en Python, C i Java:

Python	C i Java	Significat
or	||	Vertader si algun és vertader
and	&&	Vertader si els 2 són vertaders
not	!	El contrari

Exemples d'operadors lògics

...
if edat >= 18 and edat <= 65:
    print("Estàs en edat de treballar")
else:
    print("No estàs en edat de treballar")
...

...
while nota < 0 or nota > 10:
    print("Nota incorrecta. Torna-la a posar")
...

plou = True
faSol = False
print(plou or faSol)    # True
print(plou and faSol)   # False
print(not plou)         # False

Curtcircuit d'expressions

Si recordem les taules de veritat, podem afirmar que...

• false AND ... --> false
• true OR ... --> true

Per tant, com les expressions s'avaluen d'esquerra a dreta, en el moment en què el compilador puga assegurar el valor final de l'expressió lògica (True o False), pararà d'avaluar-la. Esta manera de treballar s'anomena curtcircuit d'expressions. Això ens dóna un benefici pel que fa al control d'errors i a la valocitat d'execució.

Exemples

if (descompte1 > 0 or descompte2 > 0 or descompte3 > 0):
    print("S'aplica algun descompte")

Si el descompte1és major que 0, ja no es comproven les altres 2 expressions i passa a executar-se directament el print.

(x<0) and print("El valor de la variable és negatiu")

Només mostrarà el text si el valor de x és negatiu.

Exercici sobre el curtcircuit d'expressions

Què passarà en cada cas?

sumaNotes = 50
quantsAlumnes = 0
if (quantsAlumnes > 0) and (sumaNotes/quantAlumnes >= 5):
    print("Nota miyjana aprovada")
else:
    print("Nota mitjana no aprovada")

if (sumaNotes/quantAlumnes >= 5) and (auntAlumnes > 0)

Operador d'assignació

Este operador ja ha aparegut en molts exemples. S'utilitza quan volem emmagatzemar un valor en una variable. En Python i en la majoria de llenguatges de programació, l'operador d'assignació és el símbol igual (=).

Python	C i Java	Significat
=	=	Assignació

És a dir: primer s'avalua la part de la dreta, i després s'assigna eixe resultat a la variable esquerra.

Exemple

x = 10      # x valdrà 10
y = 20      # y valdrà 20
x = x + 1   # x no valdrà 10, sinó 11
y = x + y   # y no valdrà 20, sinó 31

Per descomptat, l'assignació és destructiva (com es veu a l'exemple): sempre que es fa una assignació elimina el valor antic de la variable. És a dir, només pot guardar una dada en un moment determinat.

Si volem assignar un mateix valor a moltes variables també ho podem fer així (també en C i Java):

a = b = c = d = 10

Operadors aritmètics reduïts (operadors aritmètics i d'assignació)

L'operador d'assignació que hem vist (=) assigna un valor a una variable. Però si el que volem fer és augmentar (o disminuir) el valor que ja té la variable, podem usar els operadors aritmètics reduïts.

Python	C i Java	Significat	Assignació reduïda	Assignació equivalent
+=	+=	Suma i assignació	x += y	x = x + y
-=	-=	Resta i assignació	x -= y	x = x - y
*=	*=	Producte i assignació	x *= y	x = x * y
**=	NO	Potència i assignació	x **= y	x = x ** y
/=	/=	Divisió i assignació	x /= y	x = x / y
%=	%=	Residu i assignació	x %= y	x = x % y
//=	NO	Divisió entera i assignació	x //= y	x = x // y
NO	++	Autoincrement	x++	x = x + 1
NO	--	Autodecrement	x--	x = x - 1

Com veiem, estos dos operadors fan 2 coses: una operació aritmètica i una assignació. També es coneixen com operadors d'actualització. En les dos columnes de la dreta, x és una variable , i y és una expressió, constant o variable.

Exemple

y = 1
x = 4
x += y      # x = x + y         ---> x = 5
x *= 2      # x = x * 2         ---> x = 10
x -= 3 - y  # x = x - (3 - y)   ---> x = 10 - (2)   ---> x = 8

Exercici 2. Assignacions

Al següent programa Python, què valdrà cada variable després de cada assignació?

a = 6
b = 3
b = 1 + b           # a =       b =
a = a / b           # a =       b =
b = 6 // b + b      # a =       b =

Exercici 3

En el següent programa Python, què valdrà cada variable després de cada assignació?

a=4
b = 20
b += 23     # a=     b= 
b //= 2     # a=     b= 
a -= 2      # a=     b= 
a *= b + 2  # a=     b= 
a %= b      # a=     b= 
a**= b-19   # a=     b= 

Altres operadors

El sizeof

La quantitat de bytes que s'utilitza per a guardar una dada depén del tipus de dades, així com del llenguatge de programació, la varsió del compilador i del tipus de processador que s'utilitze (32 o 64 bits).

Per tant, perquè el nostre programa puga ser portable, de vegades és necessari saber quants bytes ocupen les variables amb les quals treballarem. Per aixó alguns llenguatges tenen una funció per a tal fi:

import sys
x = 10
text = "10"
print(sys.getsizeof(x), "bytes")            # 28 bytes (1)
print(sys.getsizeof(text), "bytes")         # 51 bytes (2)
print(sys.getsizeof(1000), "bytes")         # 28 bytes
print(sys.getsizeof("Hola, Pep"), "bytes")  # 58 bytes
print(sys.getsizeof(1234.56789), "bytes")   # 24 bytes (3)

1. Qualsevol enter ocupa 28 bytes
2. Quantitat de caracters + 49
3. Un float ocupa 24 bytes

Expressions

Ja hem vist les dades i els operadors. Amb ells podem formar expressions.

Una expressió és una combinació de dades (operands) i operadors (seguint certes regles de construcció) i que poden estar agrupats per parèntesi per a indicar l'ordre de càlcul.

Exemples d'expressions

• base * altura / 2
• (-b + sqrt(b2 - 4ac))/2
• 1000
• edat >= 0 and edat <= 100
• cognoms
• "Sr." + nom + " " + cognoms

Llocs on pot aparéixer una expressió

• En una assignació:
  • area = base * altura / 2
  • total += preu * quantitat
• En els paràmetres d'una funció:
  • sqrt(b ** 2 - 4 * a * c)
  • print("Sr." + nom + " " + cognoms)
• En una condició:
  • if(edat < 0):
  • while (nota < 0 or nota > 10)

El tipus de les expressions

Igual que una variable (o una constant) és d'un tipus determinat, una expressió també té el seu tipus.

Per exemple, tenim les variables enteres a i b i la variable float x.

• És lògic pensar que a * b també serà entera, i també a + b, etc

Ara bé:

• De quin tipus serà una expressió amb operands de diferents tipus: a * x?
• De quin tipus serà a / b? Enter (sense decimals) o float (amb decimals)?

En eixos casos cada llenguatge de programació fa una conversió de tipus o promoció. Hi ha diferents formes de promoció:

Promoció interna

Si en una expressió hi ha dades amb decimals i sense, el resultat també tindrà decimals.

Per tant, si tenim 4 + 2.3 el resultat serà 6.3 (float), no 6 (int).

Esta norma serveix per a tots els llenguatges. Però C i Java tenen més tipus per a representar els números. En estos llenguatges, si una expressió té diferents tipus, l'expressió serà del tipus que ocupa més bytes (però si l'expressió té números decimals, l'expressió serà d'un tipus amb decimals).

Promoció per assignació

Esta conversió la fa el compilador quan s'intenta assignar a una variable una expressió de diferent tipus.

preu = 3    # Ara preu és int (i el seu valor és 3)
preu = 4.6  # Ara preu és float (i el seu valor és 4.6)

int preu;   // Ara (i en tot el programa) preu serà int
preu = 3;   // preu ara val 3
preu = 4.6; // preu ara val 4 i continua sent int (en Python seria 4.6) (1)

1. En este cas diem que s'ha fet una promoció per assignació: el float 4.6 ha "promocionat" a l'int 4.

Promoció forçada (càsting)

El programador pot indicar que una expressió canvie a un tipus en concret. Eixa conversió es diu càsting o promoció forçada.

x = 4.6
n = int(x) * 2  # int(4.6) * 2 --> 4 * 2    --> 8 --> n valdrà 8
n = int(x * 2)  # int(4.6 * 2) --> int(9.2) --> 9 --> n valdrà 9

euros = 10
print(int(euros * 166.386)) # Mostrarà 1663 (sense deimals)

tel = 962829995 # tel és un enter i val 962829995. Podriem sumar-li números, etc.
tel = str(tel)  # tel ara és una cadena i val "962829995". Podriem concatenar...

Els tipus possibles en Python són: int, float, str i bool.

int n;
float x = 4.6;
n = ((int)x)*2;     // (4*2)        --> n valdrà 8
n = ((int)(x*2));   // (int)(9.2)   --> n valdrà 9

int n = 10;
int m = 3;
float x = 4.6;
x = (float)(n/m);   // (float)3         --> x valdrà 3.0
x = (float)n/m;     // (float)(10)/3    --> 10.0/3  --> x valdrà 3.333...

En este últim cas veiem que el càsting és útil per si volem fer una divisió d'emters però amb decimals en C i Java.

Precedència i associativitat d'operadors

Ací tenim una relació dels operadors ordenats per procedència de major a menor. En cas d'igualtat de precedència de divers operadors en una expressió, l'associativitat ens diu per on es comença a avaluar (d'esquerra a dreta o de dreta a esquerra).

CATEGORÍA DE L'OPERADOR	OPERADORS PYTHON	OPERADORS JAVA	ASSOCIATIVITAT
Parèntesi, vectors	( ) [ ]	( ) [ ]	ESQUERRA
Operadors unaris	+ -	++ -- + -	DRETA
Potència	**		DRETA
Multiplicació, divisió i residu	* / // %	* / %	ESQUERRA
Suma i resta	+ -	+ -	ESQUERRA
Operadors relacionals	< <= > >= == != <>	< <= > >= == !=	ESQUERRA
'No' lògic	not	!	ESQUERRA
'i' lògic	and	&&	ESQUERRA
'o' lògic	or	||	ESQUERRA
Operador condicional		?:	DRETA
Assignacions	= += -= = *= /= //= %=	= += -= *= /= %=	DRETA

No cal saber-se tot això de memòria. Simplement hem de saber que, per a avaluar les expressions, hi ha unes regles per vore què s'avalua primer. Davant del dubte, farem ús dels parèntesis per a indicar quines operacions volem que es facen primer.

Exercici 5. Expressions i tipus

Suposem que tenim estes variables en un programa en Python:

• a = 12
• x = 2.5
• y = 0.6

Indica de quin és el valor de cadascuna de les següents expressions:

• a + x
• x + y
• int(x) + y
• int(x) + int(y)
• int(x + y)
• a / 4
• a // 4
• a % 4
• a + x * 2
• a / a - 2
• a ** 2 + 1
• a < x or y < x
• not(a < x)
• (a >= x) and (y <= a)

Eixida de dades: print

Les instruccions d'entrada i eixida permeten la construcció de programes interactius. És a dir, amb elles podrem mostrar dades en pantalla i introduir dades per teclat.

En Python:

• Eixida de dades: print
• Entrada de dades: input

Exemple senzill de print

Esta funció mostra per pantalla allò que se li passa com a paràmetre. Ja ha aparegut anteriorment. Anem a detallar el seu funcionament.

Veiem estos exemples:

nom = "Pep"
cognoms= "Garcia"
print("Hola,", nom, cognoms)    # Mostra: Hola, Pep Garcia
print("Hola," + nom + cognoms)  # Mostra: Hola,PepGarcia

Com podem vore:

• print pot rebre una o més dades com a arguments (separats per comes).
• Si els arguments són textos han d'anar entre cometes (simples o dobles).
• Es mostren els textos separats per 1 espai. Al final es posa un salt de línia.
• Les cadenes de text poden concatenar-se amb l'operador '+' però no posa espais entre elles. I no podem concatenar un text amb un número. Donaria error.

Altres paràmetres del print

print(objecte/s, sep=separador, end=finalitzador, file=fitxer)

• objecte/s --> textos, números, variables o expressions que volem mostrar (separats er comes).

dies = 3
print("En", dies, "dies hi ha", dies*24, "hores")

• sep=separador --> Ací indicarem amb una cadena de caràcters com volem que apareguen separats els objectes que mostrem. Si no posem res, el separador és un espai en blanc.

print("LÍNIA", "ARTÍCLE ", "QUANT.", "PREU", "IMPORT", sep="\t")
print("------- --------------- ------- ------- ------")
print(1, "Tomaques", 3, 2.5, 3*2.5, sep="\t")
print(2, "Peres   ", 12.5, 1.5, 12*1.5, sep="\t")
print(3, "Plàtans ", 2, 2, 2*2, sep="\t")

• end=finalitzador --> Cadena que es mostrarà al final del text. Si no posem res, el finalitzador és el fi de línia (caràcter '\n').

for n in range(1, 5): #(1)!
    print(n, end=" ") # Amb eixe end aconseguim que print NO faça intro sinó espai.
print() # En acabar fem un print() per a fer un únic intro al final.

1. Bucle on n va d'1 a 4 (ja ho veurem)

• file=fitxer --> Si no volem que es mostre per pantalla sinó a un fitxer.

fitxer=open("nomFitxer.txt", "a")   #(1)!
print("Hola, Pep", file=fitxer)
fitxer.close() #(2)!

1. El mode "a" afig el text al final del fitxer. El mode "w" reescriu el fitxer.
2. Fins que no es "tanca" el fitxer, no s'escriu el buffer en ell.

Usant el print amb format (ús de f-strings)

Suposem que volem mostrar els articles comprats, en forma de taula:

Què passaria si cada part de cada línia la separem amb un tabulador?

print("LIN", "ARTICLE            ", "KILOS", "PREU/KG", "IMPORT", sep="\t")
print("---", "-------------------", "-----", "-------", "------", sep="\t")

linia = 1
article = "Tomaques del Mareny"
quantitat = 3
preu = 2.5
print(linia, article, quantitat, preu, quantitat*preu, sep="\t")

linia = 2
article = "Safrà iraní"
quantitat = 0.0004
preu = 4266.67
print(linia, article, quantitat, preu, quantitat*preu, sep="\t")

Segons les dades que tinguen les variables, podria ser que ens desquadrara tot:

Això és degut a que els noms dels articles són de distinta llargària i els números no sempre tenen els mateixos decimals, etc.

Per a evitar això (a partir de la versió 3.6 de Python) tenim els f-strings, és a dir: "cadenes amb format", on podrem especificar el format que tindrà cada variable que posem en la cadena. Recordem que volíem que l'aspecte fora este:

Per tant, li haurem de dir que en cada línia d'articles:

• El número de línia ocupe 3 posicions
• El nom de l'article ocupe 20 posicions
• Els kilos ocupen 7 posicions (4 d'elles que siguen decimals)
• El preu que ocupe 7 posicions (2 d'elles que siguen decimals)
• L'import que ocupe 6 posicions (2 d'elles decimals)

I la forma de fer-ho amb el f-string és així:

print(f"{linia:3} {article:20} {quantitat:7.4f} {preu:7.2f} {quantitat*preu:6.2f}")

És a dir, abans de la cadena es posa una f (o F), i cada variable o expressió es posa dins les claus i especificant el format després dels dos punts. Exemples:

nom = "Pep"
edat = 30
pi = 3.14159265359
print(f"El meu nom és {nom} i tinc {edat} anys")
print(f"Tinc {edat:<10} anys")  # Posa el número a l'esquerra dins de 10 caràcters
print(f"Tinc {edat:>10} anys")  # Posa el número a la dreta dins de 10 caràcters
print(f"Tinc {edat:^10} anys")  # Posa el número centrat dins de 10 caràcters
print(f"Pi és {pi:.2f} aprox")  # Mostra 2 decimals
print(f"Pi és {pi:10.2f} aprox")    # Mostra 2 decimals, a la dreta dins de 10 car.

El resultat seria:

Observem que emprem <, > i ^ per a posar el valor a l'esquerra, dreta o centrat. I per als float indiquem també quants decimals volem (i li posem una f).

Realment els f-strings no tenen res a vore amb el print, sinó que serveix per a crear una cadena amb dades amb el format que volem. Per exemple:

base = float(input("Base: "))
altura = float(input("Altura: "))

area = (base * altura) / 2

missatge = f"L'àrea del triangle de base {base} i altura {altura} és {area:.2f}"

print(missatge)

A més, Python disposa de moltes operacions que podem fer en una cadena: passar-la a minúscules, a majúscules, obtindre una subcadena... I algunes de les operacions són alineació a dreta, esquerra, centrat.

En VSCode (i altre IDEs), si posem el punt al costat d'una variable (o constant) de tipus str, vorem les operacions que podem fer amb ella:

Per tant, podem fer altres coses en les cadenes sense usar els f-strings. Ací tenim uns exemples:

nom = "Pep"
print("Hola", nom.upper(), "com va?")           # Hola PEP com va?
print("Hola", nom.ljust(10, '_'), "com va?")    # Hola Pep_______ com va?
print("Hola", nom.center(10, '_'), "com va?")   # Hola ___Pep____ com va?
print("Hola", nom.rjust(10, '_'), "com va?")    # Hola _______Pep com va? (1)

1. En compte d'eixe '_' podem posar qualsevol caràcter, com per exemple un espai.

Entrada de dades: input

Serveix per a que un programa puga demanar dades per teclat. Serà un poc diferent segons els tipus de dades que volem introduir.

Vegem-ho amb exemples:

Entrada de text

print("Com et diuen?")
nom = input() #(1)!
print("Hola, " + nom + "!")

1. Ací l'execució espera que li posem per teclat un valor i polsem "INTRO". El valor introduït es guardarà a la variable nom.

Ara bé, l'input de Python també permet indicar el que estem demanant, sense haver de fer abans el print:

nom = input("Com et diuen?") #(1)!
print("Hola, " + nom + "!")

1. Ací mostrarà el text, i farà l'input normal.

Entrada de números

El problema és si, en compte de demanar un text per teclat, volem demanar un número, ja que l'agafarà com a text i no podrem fer operacions aritmètiques amb ell:

num = input("Dis-me un número: ")
print("El següent número és el ", num + 1)  # ERROR!

Això provoca l'error:

TypeError: can only concatenate str (not "int") to str

Això és degut a que input sempre retorna un str. Per això, en l'expressió num + 1 intenta concatenar en compte de sumar. I dona error perquè no es poden concatenar números sinó textos.

Per tant, si volem tractar-lo com a enter caldrà fer un càsting (conversió de tipus):

num = input("Dis-me un número: ")
num = int(num)
print("El següent número és el ", num + 1)

O bé es podria fer l'input i el càsting en la mateixa instrucció:

num = int(input("Dis-me un número: "))  #(1)!
print("El següent número és el ", num + 1)

1. Es fa càsting sobre l'entrada de dades

En compte d'int també es pot fer casting a float, si fora el cas.

Diverses entrades en un mateix input

En un input podem demanar diverses dades separades per un espai en blanc (o pel caràcter que volem). Ara bé: això no té res a vore amb l'input, sinó amb el mètode split del tipus de dades str. Veiem uns exemples:

horaCompleta = input("Dis-me quina hora és (en format h:m:s): ")
hores, minuts, segons = horaCompleta.split(":") #(1)!

pes, altura = input("Dis-me el pes i altura (seprats per blanc): ").split()

1. Fem 3 assignacions alhora. split separa una cadena en una llista de cadenes.

Veiem que quan fem split, en l'assignació cal posar tantes variables com dades s'espera que s'introduïsquen. Si no, donarà error.

Cal tindre en compte que després caldria fer els càstings corresponents a int o float de cada variable.

Exercici 6. Entrada i eixida de dades

Fes un programa que pregunte quants anys té algú i que mostre per pantalla la quantitat d'anys que falten per a la majoria d'edat i per a jubilar-se.

Exercici 7

Programa que pregunte per la base i l'altura d'un triangle i mostre per pantalla l'àrea d'eixe triangle

Exercici 8

Demana per teclat les dades de 2 llibres: títol, autor i preu (permet decimals). Després cal mostrar les dades en forma de taula: 30 caràcters per al títol, 20 per a l'autor i 10 per al preu (incloent 2 decimals i alineat a la dreta)

Exercici 9

Demana per teclat només un valor: una data (per exemple 6/9/2024). Després escriu eixa data però amb el format: "6 del 9 de 2024".

Exercicis

Exercici 10

Escriu el resultat de les següents expressions:

• 5 / 2 + 17 % 3
• 3 * 6 / 2 + 18 / 3 * 2
• 42 * 2 / 3 / (5 + 2)
• ((5 + 3) / 2 * 3) / 2 - int(28.7) // 4 + 29 % 3 * 4
• 3 <= 4
• 45 <= 7 or not (5 >= 7)
• (8 * 2 < 5 or 7 + 2 > 9) and 8 - 5 < 18
• (2 * 7 > 5 or 7 / 2 == 3) and (7 > 25 or not True) and True
• 35 > 47 and 9 == 9 or 35 != 3 + 2 and 3 >= 3
• 9 == 15 or 8 != 5 and 7 == 4
• 8 > 8 or 7 == 7 and not(5 < 5)
• 4 + 2 < 8 and 24 + 1 == 25 or True

Exercici 11

Escriu una expressió on s'especifique que una variable numèrica de nom quant siga menor o igual que 500 i múltiple de 5 però distinta de 100.

Exercici 12

Troba els errors en el següent programa que calcula l'àrea d'un cercle a partir del radi. Després copia'l amb les correccions i executa'l.

print("pi=", pi)
pi = 3,14
print(Programa de càlcul de l'àrea d'un cercle)
radi = input('Dis-me el radi');
'''Calcular i imprimir l'area
area = PI * radio**2;
print('\n\nL'àrea del cercle és: {aera:5.2}\n');

Exercici 13

Sense executar el programa, digues què mostrarà per pantalla:

a = 10
b = 3
c = a/b
d = a<b and b<c
a += a + b
b = float(a//b)
print(a, b, c, d)

Exercici 14

Contesta les següents qüestions tipus test:

1. Els tipus primitius en Python són:
   • bool, char, short, int, long, float, double
   • int, float, boo, str
   • caràcters, variables i constants
2. Es defineix a = 5, b = 2 i c = 0. Quin serà el valor de c després d'esta instrucció: c = a > b
   • 3
   • 2
   • True
   • False
   • Error
3. Quin és el valor d'esta expressió: 10 / int(4.5)
   • 2
   • 2.5
   • 3
   • Altra cosa