Apèndix F — Programació amb Python

Objectius

Reconèixer que els conceptes (variables, condicions, bucles, funcions, classes) són els mateixos en qualsevol llenguatge.
Llegir codi Python senzill i relacionar-lo amb el seu equivalent Java.
Entendre les diferències principals: tipatge, sintaxi per indentació i punt i coma.

Per què aquest annex és opcional

El llenguatge d’aquest curs és Java. Python apareix només aquí, com a reforç, mai com a requisit.

La idea de fons: el que aprens no és Java, és a programar. Els conceptes viatgen entre llenguatges; només canvia la manera d’escriure’ls.

F.1 Dues maneres d’escriure el mateix

Comencem pel clàssic “Hola món”. Fixa’t com el concepte (mostrar text per pantalla) és idèntic; només canvia l’embolcall:

Java

public class Hola {
    public static void main(String[] args) {
        System.out.println("Hola món!");
    }
}

Python

print("Hola món!")

Python és més curt perquè no cal declarar una classe ni un mètode main per començar.

Això el fa còmode per aprendre conceptes ràpid, però Java t’obliga a l’estructura que faràs servir en projectes reals.

F.2 Variables i tipus

En Java declares el tipus de cada variable. En Python el tipus s’infereix del valor: no l’escrius. En diem tipatge dinàmic.

Concepte	Java	Python
Enter	`int edat = 20;`	`edat = 20`
Decimal	`double preu = 9.99;`	`preu = 9.99`
Text	`String nom = "Ada";`	`nom = "Ada"`
Booleà	`boolean actiu = true;`	`actiu = True`
Constant	`final double IVA = 0.21;`	`IVA = 0.21` (per convenció, majúscules)
Fi d’instrucció	`;` obligatori	salt de línia (sense `;`)
Comentari	`// comentari`	`# comentari`

Error típic quan véns de Java

En Python els booleans s’escriuen amb majúscula inicial: True i False, no true/false. I el “res” és None, no null. Escriure true en Python dona un error de nom.

F.3 Condicions

La lògica de la selecció és idèntica; canvien les claus { } per dos punts i indentació, i else if es diu elif:

Java

int nota = 7;
if (nota < 5) {
    System.out.println("Suspès");
} else if (nota < 9) {
    System.out.println("Aprovat");
} else {
    System.out.println("Excel·lent");
}

Python

nota = 7
if nota < 5:
    print("Suspès")
elif nota < 9:
    print("Aprovat")
else:
    print("Excel·lent")

Els operadors lògics també canvien de nom: Java fa servir &&, ||, !; Python fa servir les paraules and, or, not.

Error típic: la indentació és obligatòria

En Java la indentació és per llegibilitat; en Python forma part de la sintaxi. Els espais del davant indiquen quin codi va dins de l’if. Si t’equivoques amb la indentació, el programa canvia de significat o dona IndentationError. Fes servir sempre 4 espais (mai barregis espais i tabuladors).

F.4 Bucles

Els bucles també hi són, amb petites diferències. El for de Python recorre directament una seqüència; per comptar amb nombres s’usa range():

Java

for (int i = 1; i <= 5; i++) {
    System.out.println(i);
}

int n = 0;
while (n < 3) {
    System.out.println(n);
    n++;
}

Python

for i in range(1, 6):
    print(i)

n = 0
while n < 3:
    print(n)
    n += 1

Compte amb range()

range(1, 6) genera 1, 2, 3, 4, 5: el primer valor s’inclou i l’últim s’exclou, igual que passava amb nextInt(n). És el mateix parany de límits inclòs/exclòs que ja coneixes.

F.5 Funcions

El que en Java són mètodes, en Python (fora de classes) són funcions, definides amb def i sense declarar tipus:

Java

public static int sumar(int a, int b) {
    return a + b;
}

Python

def sumar(a, b):
    return a + b

Cridar-les és igual en tots dos: sumar(3, 4).

F.6 Col·leccions

Python porta estructures de dades molt còmodes integrades al llenguatge, que s’assemblen a les col·leccions de Java:

Concepte	Java	Python
Array / llista	`int[] v = {1, 2, 3};`	`v = [1, 2, 3]`
Llista dinàmica	`new ArrayList<>()`	`[]` (les llistes ja creixen)
Parells clau-valor	`HashMap<String,Integer>`	`{"a": 1, "b": 2}` (diccionari)
Conjunt sense repetits	`HashSet<>()`	`{1, 2, 3}`
Mida	`v.length` / `list.size()`	`len(v)`

Exemple. Recórrer una llista i sumar-ne els elements:

nombres = [10, 20, 30]
total = 0
for n in nombres:
    total += n
print("Total:", total)   # Total: 60

F.7 Classes

La programació orientada a objectes també existeix en Python.

El constructor es diu __init__ i el “this” es diu self:

Java

public class Gos {
    private String nom;

    public Gos(String nom) {
        this.nom = nom;
    }

    public void bordar() {
        System.out.println(nom + ": Bup!");
    }
}

Python

class Gos:
    def __init__(self, nom):
        self.nom = nom

    def bordar(self):
        print(f"{self.nom}: Bup!")

L’herència també hi és: class Gos(Animal): equival al class Gos extends Animal de Java.

f"{...}": cadenes formatades

En l’exemple de Python has vist f"{self.nom}: Bup!". És una f-string: dins de les claus { } pots posar variables i s’hi insereixen. És l’equivalent còmode de la concatenació amb + de Java (nom + ": Bup!").

F.8 Diferències clau d’un cop d’ull

Aspecte	Java	Python
Tipatge	estàtic (declares tipus)	dinàmic (infereix tipus)
Blocs de codi	claus `{ }`	indentació
Fi d’instrucció	punt i coma `;`	salt de línia
Punt d’entrada	mètode `main` en una classe	qualsevol línia del fitxer
Booleans / buit	`true`/`false` / `null`	`True`/`False` / `None`
Operadors lògics	`&&` `\\|\\|` `!`	`and` `or` `not`
Velocitat d’escriptura	més verbós	més compacte
On brilla	apps grans, Android, empresa	scripts, dades, IA, prototips

F.9 Resum

Els conceptes de programació (variables, condicions, bucles, funcions, classes) són els mateixos en Java i en Python; només canvia la sintaxi.
Python té tipatge dinàmic (no declares tipus), fa servir indentació en comptes de claus i no necessita punt i coma.
elif és l’else if; els operadors lògics són paraules (and, or, not); els booleans van amb majúscula (True, False).
Les col·leccions (llistes, diccionaris, conjunts) estan integrades al llenguatge amb una sintaxi molt breu.
La POO existeix igualment: constructor __init__, referència self, herència amb class Filla(Pare).
Aprendre un segon llenguatge confirma la idea central del curs: el que domines no és un llenguatge, és programar.

F.10 Per practicar

Traducció inversa. Agafa un dels teus programes Java del Capítol 6 i reescriu-lo en Python. Fixa’t en què canvia i què no.
Parells i senars. Escriu en Python un bucle que mostri els nombres parells de l’1 al 20 amb range().
Diccionari d’inventari. Crea un diccionari amb noms de productes i quantitats, i recorre’l per mostrar cada parell.
Classe Compte. Fes una classe Compte en Python amb saldo, ingressar() i retirar(), i compara-la amb la versió Java del Capítol 12.
Mateixa lògica, dos idiomes. Tria un exercici del “Per practicar” del Capítol 7 i resol-lo en tots dos llenguatges, un al costat de l’altre.