Java.CodeCompared.To/Python

Python needs no class, no main method, and no System.out — a top-level print() call is a complete program. Indentation replaces braces, and statements end at the newline rather than a semicolon.

Python f-strings interpolate values inline with {...}, replacing Java's printf format specifiers (%s, %d). There is no separate format-versus-print distinction.

Python uses # for single-line comments. It has no dedicated block-comment syntax — a triple-quoted string fills that role and also serves as a documentation string.

Python variables carry no type declaration — assignment alone creates them, and the same name can later hold a different type. The naming convention is snake_case rather than Java's camelCase.

Java's var still infers a single fixed type at compile time. Python is dynamically typed, so a variable can be rebound to any type at runtime; type(x).__name__ inspects the current type.

Python's equivalent of null is the singleton None. The idiomatic test is is None (identity), not ==. Python has no primitive-versus-object split, so any variable can be None.

Python has no final. An all-caps name signals intent only — nothing prevents reassignment, unlike Java's compiler-enforced final.

Python spells these upper() and lower(), and length comes from the len() built-in rather than a .length() method.

Python f-strings embed any expression directly in {...}, which is far more concise than Java's String.format() with positional specifiers.

Python's split() returns a list directly. Note that join() is called on the separator string ("-".join(parts)), the reverse of Java's String.join(sep, parts).

Python slices with bracket syntax and supports negative indices, so the last six characters are word[-6:] — no length() arithmetic as Java's substring() requires.

Both languages use triple-quoted text blocks for multi-line strings. Java strips incidental leading indentation relative to the closing delimiter; Python keeps the text exactly as written.

In Java, / means integer division when both operands are integers. Python flips the defaults: / is always true division (a float), and // is the explicit floor-division operator.

Python integers have unlimited precision built in, so 2 ** 100 is exact with no overflow and no BigInteger. There is no int-versus-long distinction — just one int type.

Python converts with the int() and float() built-ins. Like Java's parse methods, they raise an error (a ValueError) on malformed input.

Python splits these between built-ins (max, min, abs) and the math module (sqrt, floor), which must be imported — there is no always-available Math class.

A Python list is a built-in literal with no generic type parameter. Indexing uses brackets (fruits[0]) instead of .get(), supports negative indices, and length comes from len().

Python lists are always mutable and growable — there is no ArrayList-versus-List.of distinction. You use append() to add and pop() to remove the last element.

Python's for color in colors is the direct equivalent of Java's enhanced for loop, iterating elements without an index.

A Python list comprehension replaces the whole stream().map().collect() pipeline. It is both shorter and eager, returning a list directly rather than a lazy stream you must collect.

The if clause of a comprehension does the work of stream().filter(), and range(10) stands in for IntStream.range(0, 10) — no boxing step required.

Python's built-in sum() works on any iterable of numbers, with none of Java's mapToInt ceremony. For general folds, functools.reduce() mirrors Stream.reduce().

Python's sorted() returns a new list and takes a key function, far terser than Java's Comparator chains. The in-place variant is list.sort().

A Python dict is a built-in literal accessed with brackets (person["age"]). The dict.get(key, default) method matches Java's getOrDefault, and bracket access raises KeyError on a missing key.

Python assigns to a dict key with plain bracket syntax, and once a key exists you can use += directly — no put or merge needed.

Python's dict.items() yields key/value pairs you unpack in the loop header, replacing Java's entrySet() with getKey()/getValue(). Regular dicts preserve insertion order, like a LinkedHashMap.

Python uses the in operator to test for a key, replacing Java's containsKey(). Note Python's booleans are capitalized: True and False.

Python drops the parentheses and braces in favour of a colon and indentation, and contracts else if to the keyword elif.

Python's conditional expression reads in English order — a if condition else b — rather than Java's C-style condition ? a : b.

Python spells the boolean operators as the words and, or, and not rather than Java's &&, ||, and !.

Python's match statement (3.10+) resembles Java's arrow-style switch: no fall-through and no break. The wildcard is case _, and Python's match can also destructure structures.

Python has no C-style three-part loop. You iterate over range(3), which yields 0, 1, 2. To count manually use index += 1 — there is no ++ operator.

The while loop differs only in Python's colon and indentation. Python has no do...while construct.

Python's enumerate() hands you the index and value together, eliminating the manual index-and-get() pattern Java requires for indexed iteration.

Both break and continue behave the same. Python adds a for...else clause that runs only if the loop completed without a break — something Java lacks.

Python functions are declared with def at module level — no enclosing class, no static, and no return-type or parameter-type declarations.

Python uses default parameter values instead of method overloading, so one function covers what Java needs several overloads for. Beware: a Python default is evaluated once at definition time, so never use a mutable default like [].

Python's *numbers collects extra positional arguments into a tuple, the counterpart to Java's int... numbers varargs. The built-in sum() then totals them directly.

Python supports passing arguments by name (role="admin"), which improves call-site clarity and pairs naturally with defaults. Java has no keyword arguments — parameters are always positional.

Python returns a tuple (the comma makes one) and unpacks it on assignment, so a function returns multiple values without an array, a wrapper class, or a record.

A Python lambda is a plain callable assigned to a variable and invoked with normal call syntax (square(5)) — there is no functional-interface type or .apply(). It is limited to a single expression.

In Python functions are first-class values you pass and call directly, with no Function<> interface to declare. Any callable can be passed wherever a function is expected.

A single comprehension expresses both the filter and the transform that Java spreads across stream().filter().map().collect(). For lazy pipelines, Python offers generator expressions and the itertools module.

Python's constructor is __init__, instances are created without new, and every method takes an explicit first parameter self. Fields are not declared separately — they spring into being when assigned on self.

Python's __str__ dunder method plays the role of Java's toString(), and print() calls it automatically. A separate __repr__ provides the unambiguous developer-facing form.

Python's @dataclass decorator is the counterpart to a Java record: it generates the constructor, a readable repr, and equality. Fields are accessed as plain attributes (point.x), not accessor methods.

Python marks class-level methods with the @staticmethod decorator rather than a static keyword. It also offers @classmethod, which receives the class as its first argument.

Python declares the base class in parentheses (class Cat(Animal)) instead of extends, and calls the parent constructor as super().__init__(name). There is no @Override annotation.

Python relies on duck typing rather than declared interfaces: any object with a speak() method works, with no implements clause. When you want an explicit contract, the abc module provides abstract base classes.

Python catches with except and binds the exception via as. The pattern mirrors Java closely; division by zero raises a catchable error in both.

Python uses raise where Java uses throw. A key difference: Python has no checked exceptions, so functions never declare what they might raise and the compiler never forces a try.

The finally block runs whether or not an exception occurred, identically in both languages. For resource cleanup, Python's with statement is usually preferred over an explicit finally.

A custom Python exception subclasses Exception and often needs only pass, since the base class already stores the message. Python exceptions are all unchecked, like Java's RuntimeException family.

Python imports a whole module (import uuid) and accesses its members through the module name, rather than importing individual classes by fully-qualified package path as Java does.

A Python module is just a .py file — there is no package declaration, and every top-level name is importable with from greetings import hello. These examples span multiple files, so they cannot run in this single-file runner.