El teu primer script a Python: print()

Després d’instal·lar Python i comprovar que pots obrir l’intèrpret o executar un arxiu .py, el següent que vols fer és mostrar alguna cosa per pantalla. La funció print() és el punt de partida habitual.

Què és print() i què fa exactament?

print() és una funció incorporada (és a dir, ve per defecte amb Python) que serveix per enviar informació a la sortida estàndard. Això significa que el que escriguis amb print() apareixerà a la pantalla quan executis l’script.

La seva forma més bàsica és aquesta:

print("Hola món")

En executar aquest script, veuràs en pantalla:

Hola món

El que està entre parèntesis és una cadena de text. L’important aquí és que print() sempre porta parèntesi, fins i tot si només vols imprimir un valor.

Per què print necessita parèntesi?

En versions antigues de Python (la 2.x), print no era una funció, sinó una paraula clau del llenguatge. Es podia escriure sense parèntesi:

# Això és vàlid només a Python 2, NO a Python 3
print "Hola món"

Però Python 3 va unificar el disseny: print va passar a ser una funció com qualsevol altra. Per això, sempre s’ha d’escriure així:

print("Text")

Si oblides els parèntesis, veuràs aquest error:

SyntaxError: Missing parentheses in call to 'print'

Aquest és un dels errors més comuns entre persones que fan servir guies velles o aprenen amb vídeos que fan servir Python 2.

Què es pot imprimir?

print() pot mostrar una o més coses. El més habitual és imprimir cadenes de text (el que està entre cometes), però també pots imprimir números, variables o una barreja.

Exemples bàsics:

print("Hola")        # Cadena de text
print(42)            # Número sencer
print(3.14)          # Número decimal
print("Resultat:", 5 + 3)  # Múltiples valors separats per coma

Sortida:

Hola
42
3.14
Resultat: 8

Quan passes diversos elements a print(), Python els mostra separats per un espai (això es pot canviar, ho veurem més endavant).

Cadenes de text: com escriure-les bé

Una cadena de text (en anglès, string) és simplement una seqüència de caràcters: lletres, números, símbols, espais. A Python, una cadena s’escriu entre cometes.

Pots fer servir cometes simples (‘) o dobles (“):

print("Hola")
print('Hola també')

Ambdues formes són vàlides. Python no distingeix entre elles, sempre que obris i tancaments amb el mateix tipus.

Quan fer servir cometes simples o dobles?

No és obligatori seguir una regla estricta, però és útil tenir en compte el següent:

1. Si el teu text inclou cometes simples, fa servir cometes dobles a fora.
2. Si inclou cometes dobles, fa servir cometes simples a fora.

Exemples:

print("Ella va dir 'hola'") # Correcte
print('Va dir "hola" i se'n va anar') # També correcte

Si fas servir el mateix tipus de cometes per dins i per fora, necessites escapar les cometes internes. Per això es fa servir el caràcter \ (barra invertida):

print('Ella va dir \'hola\'') # Cometes simples escapades
print("Dic \"hola\"") # Cometes dobles escapades

---

Caràcters especials dins de cadenes

Alguns caràcters tenen un significat especial quan apareixen precedits per una barra invertida \. Aquests són els més comuns:

Seqüència	Significat
\n	Salt de línia
\t	Tabulació (tab)
\\	Barra invertida
\’	Cometa simple
\”	Cometa doble

Exemple:

print("Línia 1\nLínia 2")

Sortida:

Línia 1
Línia 2

Un altre exemple:

print("C:\\usuaris\\joan")

Si no escales bé les barres invertides en rutes (com en Windows), Python pot interpretar-les com a comandaments de control. Per a evitar això, pots fer servir cadenes en cru (raw strings):

print(r"C:\usuaris\joan")

La r davant de la cadena indica que no s’ han d’ interpretar els caràcters especials.

Cadenes multilínia

Pots escriure una cadena que ocupi diverses línies fent servir tres cometes seguides:

text = """Aquest és un text
que ocupa diverses
línies seguides."""
print(text)

També pots fer servir ”’ si prefereixes cometes simples. El contingut dins de la cadena es manté exactament com l’ escriu, amb salts de línia inclosos.

Això és útil si necessites mostrar missatges llargs, escriure ajuda o definir blocs de text sense fer servir \n manualment.

Com fer servir print() amb múltiples valors

Com ja vam veure, pots passar més d’un valor a print(), separats per comes:

print("Nombre:", "Joan", "Edat:", 30)

Python l’imprimirà com a:

Nom: Joan Edat: 30

El separador per defecte és un espai. Però pots canviar-lo fent servir l’argument sep=:

print("un", "dos", "tres", sep="-")

Això imprimirà:

un-dos-tres

Això és útil quan vols generar sortides amb comes, guions, punts, etc., sense haver de concatenar cadenes manualment.

Canviar el final de línia amb end =

Per defecte, print() afegeix un salt de línia (\n) al final. Per això cada crida apareix en una nova línia.

Pots canviar aquest comportament fent servir l’argument end=:

print("Hola", end=" ")
print("món")

Això imprimeix:

Hola món

Sense salt de línia entre les dues trucades. També pots fer servir altres caràcters com a acabat:

print("==>", end="")
print(" següent")

Llegir els errors

Quan alguna cosa falla, Python mostra un missatge d’error (traceback). Al principi pot semblar intimidant, però és més útil del que sembla. El que necessites mirar és:

1. La línia que falla (Python la mostra amb número i contingut).
2. El tipus d’error (per exemple: SyntaxError, TypeError, etc.).
3. El missatge que l’acompanya (això et diu què està malament).

Alguns errors comuns en començar:

print("Hola)   # Falta cometa

Error:

SyntaxError: unterminated string literal

Això significa: “cadena sense acabar”. Falta la cometa de tancament.

Un altre exemple:

print("Edat: " + 30)

Error:

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

Estàs intentant sumar una cadena (str) i un número (int). No es pot. La solució és convertir el número a text:

print("Edat: " + str(30))

O simplement separar amb coma:

print("Edat:", 30)

Inserir valors dins de cadenes: tres formes de formatejar text

Hi ha diverses formes d ‘inserir valors dins d’una cadena. No són equivalents. Algunes són més llegibles, d’altres més antigues. Et convé conèixer-les bé perquè les veuràs totes en codi real, encara que no totes s’utilitzin igual avui dia.

Anem a veure-les amb detall:

1. L’estil clàssic: operador %

Aquesta és la forma més antiga de formatejar text a Python, heretada de C. Segueix funcionant, però ja no es recomana com a primera opció en codi nou.

Exemple:

nom = "Anna"
edat = 30
print("Nom: %s, Edat: %d" % (nom, edat))

Sortida:

Nom: Anna, Edat: 30

Aquí, els símbols %s i %d són marcadors de posició:

1. %s es fa servir per a cadenes.
2. %d per a enters.
3. %f per a decimals (floats).

Avantatges: és directe i llegible en casos simples.

Desavantatges:

1. Costa mantenir-ho si hi ha moltes variables.
2. Els errors de tipus poden ser confusos.
3. No permet noms de variables dins de la cadena.

Error típic:

print("Edat: %d" % "30")

Això retorna:

TypeError: %d format: a number is required, not str

Perquè “30” és una cadena, no un número. Amb %d s’espera un sencer real, no una cosa que sembla un número.

2. .format(): estil més modern i flexible

Va aparèixer a Python 2.6 i continua sent àmpliament fet servir. Fa servir claus {} com a marcadors.

Exemple bàsic:

nom = "Anna"
edat = 30
print("Nom: {}, Edat: {}".format(nom, edat))

Sortida:

Nom: Anna, Edat: 30

També pots fer servir índexs o noms per a més claredat:

print("Nom: {0}, Edat: {1}".format(nom, edat))
print("Nom: {n}, Edat: {e}".format(n=nom, e=edat))

Avantatges:

• Més llegible que l’ estil %.
• Permet ordre arbitrari de variables.
• Pots formatejar tipus, ajustar ample, etc.

Formateig amb especificacions:

pi = 3.14159265
print("Pi val {:.2f}".format(pi))  # Dos decimals

Sortida:

Pi val 3.14

Error típic:

Oblidar passar tots els arguments:

print("Nom: {}, Edat: {}".format(nom))  # Falta edat

Error:

IndexError: tuple index out of range

El nombre de claus ha de coincidir amb el nombre d’ arguments.

3. f-strings: la forma més clara a Python 3.6+

Si estàs fent servir Python 3.6 o superior (cosa que hauries), aquesta és l’opció més directa, neta i mantenible.

Exemple:

nom = "Anna"
edat = 30
print(f"Nom: {nom}, Edat: {edat}")

Sortida:

Nom: Anna, Edat: 30

Aquí no necessites cridar a .format(), ni fer servir %. N’hi ha prou amb anteposar f a la cadena i escriure les variables directament dins de les claus.

Avantatges:

1. Llegible, net, directe.
2. Suporta expressions dins les claus:

print(f"Edat en mesos: {edat * 12}")

1. Pots aplicar formats dins també:

pi = 3.14159265
print(f"Pi val {pi:.2f}")

Limitació: només funciona des de Python 3.6. Si has d’escriure codi compatible amb versions anteriors, fes servir .format().

Quin convé fer servir?

Estil	Convé fer-lo servir avui?	Quan
%	No	Només per a llegir codi vell
.format()	Sí, si necessites compatibilitat < 3.6	Codi que funcioni en entorns antics
Cordes F	Sí	Codi nou a Python 3.6 +

En aquesta sèrie farem servir principalment f-strings, excepte en exemples on tingui sentit mostrar diferències.

I si vull imprimir diverses línies amb variables?

Combina tot el que has vist:

nom = "Joan"
edat = 41
ciutat = "Lleida"

 

missatge = f"""
Nom: {nom}
Edat: {edat}
Ciutat: {ciutat}
"""

print( missatge)

La cadena s’ escriu com a bloc, i cada línia pot contenir variables inserides.

Evita errors de concatenació

Un error típic en començar és intentar sumar cadenes amb altres tipus sense convertir-los:

edat = 30
print("Edat: " + edat)  # Error

Això dona:

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

Forma correcta:

print("Edad: " + str(edat))

O millor encara:

print(f"Edat: {edat}")

Què passa si passo diversos valors amb coma?

print("Nom:", nom, "Edat:", edat)

Python afegeix espais automàticament. Això no és el mateix que:

print("Nom:" + nom + "Edat:" + str(edat))

El primer és més segur i evita conversions manuals.

Dreceres útils

1. Pots imprimir sense salt de línia: print(“alguna cosa”, end=””)
2. Pots canviar el separador: print(a, b, sep=” | “)
3. Pots imprimir expressions: print(f”Total: {3 + 2}”)
4. Pots veure quin tipus té una variable amb type():

x = "hola"
print(type(x))  # <class 'str'>

Checklist per recordar en treballar amb print() i text

• Fes servir cometes simples o dobles, però tanca-les bé.
• Si fas servir rutes de Windows, considera r”…” per evitar problemes.
• Escapa les cometes internes amb \.
• No barregis cadenes amb sencers sense convertir-los.
• Tria f”…” per a inserir variables en text.
• Fes servir print(…, sep =…) i end =… si vols més control.
• Revisa sempre el nombre i tipus de variables en .format() i %.

Amb això tanques una de les parts fonamentals del llenguatge. Aprendre bé print() i com treballar amb cadenes no és només útil per a “mostrar coses per pantalla”: és part central de gairebé qualsevol script que depuri, transformi dades o interactuï amb persones.