Python pour les développeurs Java : apprends Python à partir de ce que tu sais déjà

Java et Python, côte à côte

Chaque paire ci-dessous fait le même travail. Lis le Java que tu connais, puis vois comment Python l'exprime.

Variables, types et fonctions

int total = 0;
String name = "Ada";

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

total = 0
name = "Ada"

def add(a: int, b: int) -> int:
    return a + b

Python n'a pas de déclaration de type : un nom référence simplement une valeur. Les annotations de type documentent l'intention et aident les éditeurs et les outils, mais Python ne les impose pas pendant l'exécution du programme.

Listes, maps et dictionnaires

List<String> langs = new ArrayList<>(List.of("Java", "Python"));
langs.add("SQL");

Map<String, Integer> ages = new HashMap<>();
ages.put("Ada", 36);
int age = ages.get("Ada");

langs = ["Java", "Python"]
langs.append("SQL")

ages = {"Ada": 36}
age = ages["Ada"]

Les listes et les dictionnaires sont intégrés au langage, avec une syntaxe littérale, sans import ni génériques. Lire une clé absente avec [] lève KeyError ; utilise ages.get(name) pour obtenir None à la place, comme avec Map.get en Java.

Boucles et itération

for (int i = 0; i < names.size(); i++) {
    System.out.println(i + ": " + names.get(i));
}

for i, name in enumerate(names):
    print(f"{i}: {name}")

Python parcourt directement les éléments. Quand tu as aussi besoin de la position, enumerate fournit l'indice et la valeur ensemble, sans compteur à gérer.

Classes et objets

public class Point {
    private final int x;
    private final int y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public double distanceToOrigin() {
        return Math.sqrt(x * x + y * y);
    }
}

import math

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def distance_to_origin(self):
        return math.hypot(self.x, self.y)

self est un premier paramètre explicite plutôt qu'un this implicite, et on crée les objets sans new. Python n'a pas de modificateurs d'accès ; un tiret bas initial, comme dans _x, indique par convention qu'un élément est interne.