Python für Java-Entwickler: Lerne Python mit dem, was du schon weißt

Java und Python im direkten Vergleich

Jedes Paar unten erledigt dieselbe Aufgabe. Lies das Java, das du kennst, und sieh dann, wie Python es ausdrückt.

Variablen, Typen und Funktionen

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 kennt keine Typdeklarationen: Ein Name verweist einfach auf einen Wert. Typannotationen dokumentieren die Absicht und helfen Editoren und Tools, aber Python erzwingt sie während der Programmausführung nicht.

Listen, Maps und Dictionaries

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"]

Listen und Dictionaries sind fest in die Sprache eingebaut – mit Literal-Syntax, ohne Importe und ohne Generics. Der Zugriff auf einen fehlenden Schlüssel mit [] löst KeyError aus; mit ages.get(name) erhältst du stattdessen None, ähnlich wie bei Map.get in Java.

Schleifen und Iteration

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 läuft direkt über die Elemente. Brauchst du zusätzlich die Position, liefert enumerate Index und Wert zusammen – einen Zähler musst du nicht verwalten.

Klassen und Objekte

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 ist ein expliziter erster Parameter statt eines impliziten this, und Objekte erzeugst du ohne new. Python hat keine Zugriffsmodifizierer; ein führender Unterstrich wie in _x kennzeichnet per Konvention etwas Internes.