El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència

HOME

Amb l'entorn ja en marxa, és hora d'aprendre les regles del joc: com s'estructura el codi Python (indentació, comentaris) i amb quins materials bàsics treballa (nombres, textos, booleans). També coneixeràs els operadors per combinar-los, com convertir un tipus en un altre i una eina que faràs servir cada dia: les f-strings. Aquesta lliçó és la base sobre la qual es construeix absolutament tota la resta, així que pren-t'ho amb calma i prova cada exemple al REPL o en un script.

Contingut

La indentació: com Python organitza els blocs
Comentaris
Tipus de dades bàsics: int, float, str, bool i None
Operadors aritmètics
Operadors de comparació
Operadors lògics
Conversió de tipus
f-strings: textos amb valors incrustats

La indentació: com Python organitza els blocs

En molts llenguatges, els blocs de codi es delimiten amb claus { }. Python va prendre una decisió diferent i molt característica: els blocs es delimiten amb la indentació, és a dir, amb els espais al principi de cada línia.

Observa aquest fragment (fa servir una condició if; les estudiarem a fons al mòdul 2, aquí només ens interessa la forma):

estoc = 5

if estoc > 0:
    print("Hi ha exemplars disponibles")
    print("Pots vendre'l")
print("Fi del programa")

Les dues línies indentades (desplaçades 4 espais a la dreta) formen el bloc que depèn de l'if: només s'executen si la condició es compleix.
L'última línia, sense indentar, està fora del bloc: s'executa sempre.
Els dos punts : al final de l'if anuncien que a continuació ve un bloc indentat.

Regles d'or:

Fes servir 4 espais per nivell d'indentació (és la convenció oficial, recollida a la guia d'estil PEP 8).
No barregis tabuladors i espais: provoca errors difícils de veure. Configura l'editor perquè la tecla Tab insereixi 4 espais (VS Code ho fa per defecte als fitxers Python).
La indentació no és decorativa: canviar-la canvia el significat del programa.

if estoc > 0:
print("Hi ha exemplars")   # IndentationError: falta la indentació

Aquest codi no s'executa: Python espera un bloc indentat després dels : i no el troba. La conseqüència positiva d'aquest disseny és que tot el codi Python del món té un aspecte uniforme i llegible.

Comentaris

Un comentari és text que Python ignora del tot; existeix només per als humans que llegeixen el codi. S'escriu amb el símbol #: tot el que hi ha des de # fins al final de la línia és comentari.

# Aquest script calcula el valor del prestatge de novetats de Papyrus
preu = 15.90          # preu en euros d'un exemplar
exemplars = 3         # unitats al prestatge

# El total es el preu per les unitats
print(preu * exemplars)

Bones pràctiques:

Comenta el perquè, no el què evident. # suma 1 a x al costat de x = x + 1 no aporta res; # la comanda inclou un exemplar de regal sí.
Mantén els comentaris actualitzats: un comentari que menteix és pitjor que cap.
Per "desactivar" temporalment una línia de codi mentre proves, posa-li # al davant (és el que s'anomena comentar codi).

Tipus de dades bàsics: `int`, `float`, `str`, `bool` i `None`

Tot valor en Python té un tipus, que determina què és i què s'hi pot fer. Els cinc fonamentals:

Tipus	Nom	Què representa	Exemples
`int`	Enter	Nombres sense decimals	`42`, `-3`, `0`, `2500`
`float`	Coma flotant	Nombres amb decimals	`15.90`, `-0.5`, `3.0`
`str`	Cadena de text (string)	Text	`"Papyrus"`, `'Hamlet'`
`bool`	Booleà	Cert o fals	`True`, `False`
`NoneType`	Res	Absència de valor	`None`

Pots preguntar el tipus de qualsevol valor amb la funció type():

>>> type(42)
<class 'int'>
>>> type(15.90)
<class 'float'>
>>> type("Papyrus")
<class 'str'>
>>> type(True)
<class 'bool'>

Enters (`int`)

Nombres sense part decimal: unitats en estoc, nombre de clients, any de publicació. En Python poden ser arbitràriament grans (no hi ha límit pràctic de mida).

>>> 120 + 35          # exemplars totals en dues prestatgeries
155

Decimals (`float`)

Nombres amb part decimal, escrits amb punt (no coma): 15.90, no 15,90. Són l'elecció natural per als preus de Papyrus.

Un detall important: els float s'emmagatzemen en binari i de vegades produeixen petites imprecisions:

>>> 0.1 + 0.2
0.30000000000000004

No és una errada de Python (passa en gairebé tots els llenguatges), sinó una limitació de la representació binària. Per a aquest curs n'hi ha prou de saber que existeix i que en mostrar preus convé arrodonir (les f-strings, al final d'aquesta lliçó, ho resolen amb elegància).

Cadenes de text (`str`)

Text delimitat per cometes dobles "..." o simples '...' — totes dues són vàlides, tria'n una i sigues consistent. Si el text conté una cometa, fes servir l'altre tipus per fora:

botiga = "Papyrus"
lema = 'La llibreria "de tota la vida" del teu barri'

Dues operacions bàsiques amb cadenes de text:

>>> "Papyrus" + " " + "Llibres"    # concatenació (unir textos)
'Papyrus Llibres'
>>> "=" * 20                       # repetició
'===================='
>>> len("L'Odissea")               # longitud: nombre de caràcters
9

Les cadenes de text donen per a molt més (mètodes, llescat, etc.); ho veurem en profunditat al mòdul 4. Per ara, amb crear, unir i mesurar en tens prou.

Booleans (`bool`)

Només dos valors possibles: True (cert) i False (fals), amb la inicial en majúscula. Responen preguntes de sí o no: hi ha estoc?, el client té descompte?

te_estoc = True
esta_descatalogat = False

Els booleans agafen tot el sentit amb les sentències condicionals del mòdul 2; aquí aprendrem a produir-los amb els operadors de comparació.

`None`: l'absència de valor

None representa "res" o "encara sense valor". És útil, per exemple, per indicar que encara no coneixem una dada:

data_devolucio = None   # el llibre no esta prestat a ningu

No és 0 ni una cadena de text buida: és el seu propi tipus, i significa literalment absència de valor.

Operadors aritmètics

Python inclou els operadors matemàtics habituals i algun més:

Operador	Operació	Exemple	Resultat
`+`	Suma	`15.90 + 12.50`	`28.4`
`-`	Resta	`20 - 3`	`17`
`*`	Multiplicació	`15.90 * 3`	`47.7`
`/`	Divisió (sempre dona `float`)	`10 / 4`	`2.5`
`//`	Divisió entera (descarta els decimals)	`10 // 4`	`2`
`%`	Mòdul (residu de la divisió)	`10 % 4`	`2`
`**`	Potència	`2 ** 10`	`1024`

Exemple aplicat a Papyrus:

# L'Anna vol repartir 10 exemplars nous en caixes de 4
exemplars = 10
per_caixa = 4

print(exemplars // per_caixa)   # 2  -> caixes completes
print(exemplars % per_caixa)    # 2  -> exemplars solts que sobren

// respon a "quantes caixes completes puc omplir?"
% respon a "quants exemplars queden fora?"

La precedència segueix les regles matemàtiques (primer **, després * / // %, després + -). Davant del dubte, fes servir parèntesis: (15.90 + 12.50) * 2 és més clar i evita sorpreses.

Operadors de comparació

Comparen dos valors i retornen sempre un booleà (True o False):

Operador	Significat	Exemple	Resultat
`==`	Igual a	`5 == 5`	`True`
`!=`	Diferent de	`5 != 3`	`True`
`>`	Més gran que	`10 > 20`	`False`
`<`	Més petit que	`10 < 20`	`True`
`>=`	Més gran o igual	`5 >= 5`	`True`
`<=`	Més petit o igual	`4 <= 3`	`False`

>>> estoc = 0
>>> estoc > 0            # queda algun exemplar?
False
>>> preu = 15.90
>>> preu <= 20           # entra en el pressupost d'en Lluis?
True
>>> "Hamlet" == "hamlet" # les majuscules importen en els textos
False

Atenció: == (comparar) i = (assignar, ho veurem a la propera lliçó) són coses diferents. Confondre'ls és un dels errors més clàssics de principiant.

Operadors lògics

Combinen booleans per expressar condicions compostes:

Operador	Retorna `True` quan...	Exemple
`and`	tots dos operands són `True`	`True and False` → `False`
`or`	almenys un és `True`	`True or False` → `True`
`not`	inverteix el valor	`not True` → `False`

Exemple: en Lluís vol un llibre que estigui disponible i costi menys de 20 euros:

estoc = 3
preu = 15.90

hi_ha_estoc = estoc > 0
es_assequible = preu < 20

print(hi_ha_estoc and es_assequible)   # True  -> compleix totes dues condicions
print(not hi_ha_estoc)                 # False -> si que hi ha estoc
print(estoc == 0 or preu > 50)         # False -> no es compleix cap de les dues

Taula de veritat resumida d'and i or:

A	B	`A and B`	`A or B`
`True`	`True`	`True`	`True`
`True`	`False`	`False`	`True`
`False`	`True`	`False`	`True`
`False`	`False`	`False`	`False`

Conversió de tipus

Sovint necessites transformar un valor d'un tipus a un altre. Python ofereix funcions amb el mateix nom que el tipus destí:

Funció	Converteix a...	Exemple	Resultat
`int(x)`	Enter	`int("42")`, `int(3.99)`	`42`, `3` (trunca, no arrodoneix)
`float(x)`	Decimal	`float("15.90")`, `float(7)`	`15.9`, `7.0`
`str(x)`	Cadena de text	`str(15.90)`	`"15.9"`
`bool(x)`	Booleà	`bool(0)`, `bool("hola")`	`False`, `True`

>>> int("120")        # de text a enter: perfecte per a quantitats
120
>>> float("15.90")    # de text a decimal: perfecte per a preus
15.9
>>> str(2026) + " sera un gran any per a Papyrus"
'2026 sera un gran any per a Papyrus'
>>> int("quinze")     # aixo NO es pot convertir
ValueError: invalid literal for int() with base 10: 'quinze'

Observacions importants:

int(3.99) dona 3: trunca (talla els decimals), no arrodoneix. Per arrodonir existeix round(3.99) → 4.
Convertir text a nombre només funciona si el text sembla un nombre; si no, obtens un ValueError (aprendràs a gestionar-lo al mòdul 7).
No pots concatenar text i nombre directament: "Total: " + 42 falla. Has de convertir: "Total: " + str(42)... o millor, fer servir f-strings, que veiem tot seguit.
A bool(x), el zero, la cadena de text buida "" i None es consideren False; gairebé tota la resta, True.

Aquesta conversió serà vital a la lliçó 01-05, perquè tot el que tecleja l'usuari arriba com a text i caldrà convertir-lo.

f-strings: textos amb valors incrustats

Les f-strings (cadenes formatades) són la manera moderna i recomanada de construir textos que barregen literals i valors. S'escriuen anteposant una f a les cometes, i a dins s'hi incrusten expressions entre claus { }:

titol = "L'Odissea"
preu = 12.50
estoc = 4

print(f"{titol} costa {preu} euros i queden {estoc} exemplars")

L'Odissea costa 12.5 euros i queden 4 exemplars

Avantatges respecte de la concatenació amb +:

No cal convertir els nombres amb str(): la f-string ho fa sola.
El text es llegeix d'un cop d'ull, amb els valors al seu lloc.
Dins de les claus hi cap qualsevol expressió, no només variables:

>>> print(f"Dos exemplars: {12.50 * 2} euros")
Dos exemplars: 25.0 euros

Un avançament útil: pots controlar els decimals amb :.2f (dos decimals fixos), ideal per a preus:

>>> preu = 12.5
>>> print(f"Preu: {preu:.2f} euros")
Preu: 12.50 euros

A la lliçó 01-05 explorarem el formatatge amb més detall (alineació, amplades de columna). Per ara, acostuma't a fer servir f-strings sempre que necessitis barrejar text i valors.

Errors Comuns i Consells

IndentationError: gairebé sempre per oblidar-se d'indentar després de :, indentar on no toca, o barrejar tabuladors amb espais. Configura l'editor a 4 espais i sigues consistent.
Fer servir coma decimal: 15,90 no és un float en Python (de fet crea una altra cosa: una tupla, que veuràs al mòdul 4). Els decimals van amb punt: 15.90.
Confondre = amb ==: = assigna, == compara. Si Python et dona un SyntaxError en una comparació, revisa això primer.
Escriure true/false en minúscula: en Python són True i False. En minúscula obtindràs un NameError.
Sumar text i nombre: "Total: " + 5 llança TypeError. Solució ràpida: str(5). Solució elegant: f"Total: {5}".
Oblidar la f de la f-string: print("{titol}") sense la f imprimeix literalment {titol}, claus incloses. Si veus les claus a la sortida, et falta la f.
Consell: davant de qualsevol dubte de tipus, pregunta-ho al REPL amb type(). És gratis i estalvia moltes confusions.

Exercicis

Exercici 1

Sense executar el codi, indica el tipus (int, float, str o bool) i el valor resultant de cada expressió. Després comprova-ho al REPL:

7 / 2
7 // 2
7 % 2
"7" + "2"
7 > 2
int("7") + 2

Exercici 2

Papyrus ven Hamlet a 9.95 euros. Un client compra 3 exemplars i paga amb un bitllet de 50 euros. Escriu un script que calculi i mostri amb una f-string (i dos decimals) el total de la compra i el canvi a retornar.

Exercici 3

Escriu un script que, donades aquestes variables, calculi un booleà recomanable que sigui True només si el llibre té estoc (més de 0 unitats) i el seu preu és més petit o igual a 15 euros, i el mostri amb una f-string:

titol = "L'Odissea"
preu = 12.50
estoc = 4

Prova després de canviar estoc a 0 i comprova que el resultat canvia.

Solucions

Solució 1

7 / 2 → 3.5, tipus float (la divisió / sempre retorna float).
7 // 2 → 3, tipus int (divisió entera: descarta els decimals).
7 % 2 → 1, tipus int (residu de dividir 7 entre 2).
"7" + "2" → "72", tipus str (amb cadenes de text, + concatena, no suma).
7 > 2 → True, tipus bool (les comparacions retornen booleans).
int("7") + 2 → 9, tipus int (primer convertim el text a enter, després sumem).

Solució 2

# compra_hamlet.py
preu = 9.95
unitats = 3
pagament = 50

total = preu * unitats
canvi = pagament - total

print(f"Total de la compra: {total:.2f} euros")
print(f"Canvi a retornar: {canvi:.2f} euros")

Total de la compra: 29.85 euros
Canvi a retornar: 20.15 euros

El format :.2f garanteix dos decimals exactes, imprescindible en mostrar diners (i de passada amaga les petites imprecisions dels float).

Solució 3

# recomanable.py
titol = "L'Odissea"
preu = 12.50
estoc = 4

recomanable = estoc > 0 and preu <= 15

print(f"Recomanar {titol}? {recomanable}")

Recomanar L'Odissea? True

Amb estoc = 0, la primera condició (estoc > 0) passa a ser False, i com que and exigeix que totes dues siguin certes, recomanable es torna False.

Conclusió

Ja coneixes la gramàtica essencial de Python: els blocs es defineixen amb indentació de 4 espais, els comentaris amb #, i les dades es classifiquen en tipus (int, float, str, bool, None). Saps combinar-los amb operadors aritmètics, de comparació i lògics, convertir uns tipus en altres i construir missatges nets amb f-strings. Papyrus ja pot calcular totals, canvis i decidir si un llibre és recomanable.

Hauràs notat que portem tota la lliçó desant valors en noms com preu o estoc sense explicar formalment què són. Aquest és justament el tema de la propera lliçó: Variables i Constants — com s'assignen, com posar-los bons noms segons PEP 8 i què passa exactament quan reassignes un valor.

Sintaxi de Python i Tipus de Dades Bàsics

Contingut

La indentació: com Python organitza els blocs

Comentaris

Tipus de dades bàsics: `int`, `float`, `str`, `bool` i `None`

Enters (`int`)

Decimals (`float`)

Cadenes de text (`str`)

Booleans (`bool`)

`None`: l'absència de valor

Operadors aritmètics

Operadors de comparació

Operadors lògics

Conversió de tipus

f-strings: textos amb valors incrustats

Errors Comuns i Consells

Exercicis

Exercici 1

Exercici 2

Exercici 3

Solucions

Conclusió

Curs de Programació en Python

Mòdul 1: Introducció a Python

Mòdul 2: Estructures de Control

Mòdul 3: Funcions i Mòduls

Mòdul 4: Estructures de Dades

Mòdul 5: Programació Orientada a Objectes

Mòdul 6: Gestió de Fitxers

Mòdul 7: Gestió d'Errors i Excepcions

Mòdul 8: Temes Avançats

Mòdul 9: Proves i Depuració

Mòdul 10: Desenvolupament Web amb Python

Mòdul 11: Ciència de Dades amb Python

Mòdul 12: Projecte Final

Sintaxi de Python i Tipus de Dades Bàsics

Contingut

La indentació: com Python organitza els blocs

Comentaris

Tipus de dades bàsics: int, float, str, bool i None

Enters (int)

Decimals (float)

Cadenes de text (str)

Booleans (bool)

None: l'absència de valor

Operadors aritmètics

Operadors de comparació

Operadors lògics

Conversió de tipus

f-strings: textos amb valors incrustats

Errors Comuns i Consells

Exercicis

Exercici 1

Exercici 2

Exercici 3

Solucions

Conclusió

Curs de Programació en Python

Mòdul 1: Introducció a Python

Mòdul 2: Estructures de Control

Mòdul 3: Funcions i Mòduls

Mòdul 4: Estructures de Dades

Mòdul 5: Programació Orientada a Objectes

Mòdul 6: Gestió de Fitxers

Mòdul 7: Gestió d'Errors i Excepcions

Mòdul 8: Temes Avançats

Mòdul 9: Proves i Depuració

Mòdul 10: Desenvolupament Web amb Python

Mòdul 11: Ciència de Dades amb Python

Mòdul 12: Projecte Final

Tipus de dades bàsics: `int`, `float`, `str`, `bool` i `None`

Enters (`int`)

Decimals (`float`)

Cadenes de text (`str`)

Booleans (`bool`)

`None`: l'absència de valor