Java to Python in 2026: The Migration Guide for Senior EU Engineers

If you've written Java for 5+ years and you're picking up Python — probably because your Berlin / Amsterdam / Paris company is moving data + ML workloads to Python, and the JVM team is being asked to bridge — this is the migration guide.

It's not "here's how Python syntax works". It's the harder question: what do you STOP doing from Java that will otherwise make your Python code read as amateur to reviewers?

What transfers (most of your Java brain works)

Type-thinking. Modern Python (3.9+) has type hints — list[User], dict[str, int], X | None. Turn on mypy --strict or pyright and you get the Java-style compile-check safety net you're used to. Skip this and Python's late-bound looseness will bite you eventually.

Testing culture. pytest ≈ JUnit 5. Same shape: unit tests in a tests/ folder, one test per behavior, fixtures via @pytest.fixture (like @BeforeEach). Coverage tooling is roughly equivalent (coverage.py + pytest-cov).

Dependency injection thinking. FastAPI's Depends() is DI in Python (constructor-based, no annotations magic). If you did Spring, this reads familiar.

Package + module structure. Python packages ≈ Java packages. A pyproject.toml is your pom.xml (Maven) or build.gradle. uv or poetry is your Maven/Gradle for install + build.

Streams thinking. Java Streams (.map, .filter, .collect) map cleanly to Python's comprehensions + map / filter. You'll write LESS boilerplate.

What doesn't transfer — and where seniors trip

1. Everything is mutable by default

Java's final, immutable Collections, defensive copies — none of that exists in Python. A function that takes a list can modify it. A dict passed around can grow. This is FINE if you write idiomatic Python, but if you carry Java habits ("everyone respects my invariants"), you'll be surprised.

Idiomatic fix: use tuple where you'd use immutable list. Use frozenset. Use @dataclass(frozen=True). Type-hint arguments as Sequence[X] (read-only) instead of list[X] (mutable).

2. There is no new — and no separation of instantiation vs call

Python calls ClassName(...) to create an instance. The same syntax invokes a function. Both are "callables". Once you internalize this, higher-order code becomes trivial. Java's rigid distinction disappears; the tradeoff is that a random foo(x) in Python could be creating an object OR invoking a function, and the reader has to know which.

3. Duck typing beats interfaces

Java: "does this thing implement Iterable<T>?" — checked at compile time.

Python: "does this thing have __iter__?" — checked when you try to iterate.

Modern Python has Protocol (typing.Protocol) which is closer to Go interfaces than Java interfaces — structural typing. Something implements a Protocol if it has the right shape, no implements declaration needed. Use these instead of trying to recreate Java's inheritance-based hierarchies.

4. No overloading

You can't define def process(x: int) and def process(x: str) as separate signatures. You have ONE def process(x) and dispatch inside. functools.singledispatch gives you type-based dispatch back — it's the idiomatic replacement.

5. GIL — the single biggest performance surprise

Python's Global Interpreter Lock means only one thread executes Python bytecode at a time. Threading is useful for I/O-bound work (the thread releases the GIL during syscalls), but NOT for CPU-bound work. For CPU parallelism you need multiprocessing (separate processes, IPC overhead) or Python 3.13's experimental free-threaded build.

Coming from JVM (which has real thread parallelism), this is the biggest culture shock. Don't write CPU-heavy hot loops in pure Python — call out to NumPy / Rust extensions / C.

The idioms that make you look like you know Python

• List comprehension over map + filter. [x2 for x in xs if x > 0] beats list(map(lambda x: x2, filter(lambda x: x > 0, xs))).
• f-strings (3.6+). Not "%d" % x, not "{}".format(x), and definitely not "x = " + str(x).
• Context managers (with open(...) as f:). Python's try-with-resources. Use them for anything that needs cleanup.
• dataclass / Pydantic. Your Java POJOs / Records translate directly. @dataclass for internal types, Pydantic for anything that touches API boundaries (validation + JSON serialization included).
• Modern match statement (3.10+). Python's pattern matching is closer to Scala's than Java's switch. Use it for structural dispatch.

The stack most EU teams are on in 2026

• Web APIs: FastAPI (not Django unless legacy). Similar to Spring Boot in shape, faster to write.
• Data: pandas → polars migration in progress across teams. Pandas still dominant, polars gaining fast (Rust-backed, 5-10x faster).
• Async I/O: asyncio (native) + httpx. If you did Netty / Vert.x, this reads familiar.
• Package manager: uv (the 2024-2026 replacement for pip + poetry, 10-100x faster).
• Type checker: mypy or pyright (VS Code default). Astral's ty is coming and will likely win.
• ORM: SQLAlchemy 2.0 (comparable to Hibernate). For lighter shapes: SQLModel.

The 4-week migration plan for a senior Java dev

• Week 1: syntax + type hints + one small script. Enable mypy --strict from day 1.
• Week 2: FastAPI + Pydantic — build a small CRUD API. This mirrors your Spring muscle memory.
• Week 3: asyncio + httpx + pytest. Rewrite the API to be fully async.
• Week 4: dataclasses, Protocols, match/case. Refactor your week-2 code to use idiomatic Python. Compare with the initial version — you'll see how "Java-flavored Python" reads to a reviewer.

By end of week 4 you're not senior in Python (that takes 12+ months) but you're productive and won't embarrass yourself in code review.

FAQ

Should I skip pandas and go straight to polars?

If you're new to the data ecosystem: yes, learn polars first (it's cleaner API and modern). If your team is on pandas, learn pandas — the mental model transfers to polars easily but not the other direction.

Django or FastAPI?

FastAPI for anything new. Django is fine for legacy or admin-heavy CRUD apps (its admin UI has no equivalent). Modern EU startups almost universally FastAPI.

Is Python 3.13 free-threaded ready for prod?

No. Experimental in 3.13, likely stable in 3.15 (Oct 2027). For CPU parallelism today: multiprocessing or shell out to numpy / a Rust extension.

What's the equivalent of Maven Central?

PyPI (pypi.org). Install via uv add or pip install. Same ecosystem shape, less strict on version compatibility.

Do EU employers value Python certificates?

The pattern from Berlin / Amsterdam / Paris hiring managers: nobody rejects a candidate for having no cert, some reject for having a cert without a portfolio (reads as bootcamp-only). Portfolio + real GitHub commits > any certificate. LinkedIn credentials are neutral signal.

Start with the Senior track if you're 5+ years experienced — it skips beginner content and jumps into architecture patterns. Or FastAPI Production if you want to hit an API-first project immediately.