Python for Java Developers

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello");
    }
}

# The whole file: no class, no main, no semicolon.
print("Hello")  # Hello

def main():
    print("Hello")  # Hello


# __name__ is the name of the current module. If the file was run
# directly, it holds "__main__". If it was imported, the file name,
# so main() is not called.
if __name__ == "__main__":
    main()

int price = 150;

// A one-line comment
if (price > 100) {
    System.out.println("expensive");  // expensive
} else {
    System.out.println("cheap");
}

/* Python has no multi-line comment */

price = 150

# A one-line comment
# No parentheses around the condition, a colon at the end,
# and the body is indented by 4 spaces.
if price > 100:
    print("expensive")  # expensive
else:
    print("cheap")

/**
 * Computes the total with tax.
 */
int total(int price, int tax) {
    return price
        + tax;
}

System.out.println(total(100, 20));  // 120

def total(price, tax):
    """Computes the total with tax."""

    # A line break is allowed inside parentheses.
    return (price
            + tax)


print(total(100, 20))  # 120

# The docstring is available at run time too.
print(total.__doc__)  # Computes the total with tax.

void todo() {
}

class Empty {
}

def todo():
    pass


class Empty:
    pass

int age = 30;  # Java
age = 30  # Python

var name = "Ann";  # Java
name = "Ann"  # Python

# There is no final. UPPER_CASE means "do not change", but only by convention.
final int MAX_SIZE = 100;  # Java
MAX_SIZE = 100  # Python

# In Java this is a compile error; in Python age now holds a string.
age = "thirty"  # Python

# Assign several values at once.
int a = 1, b = 2;  # Java
a, b = 1, 2  # Python

# Swap: Java needs a temporary variable.
int tmp = a; a = b; b = tmp;  # Java
a, b = b, a  # Python

a + " " + b  # Java: 2 1
f"{a} {b}"  # Python: 2 1

int count = 0;  # Java
count: int = 0  # Python

String title = "Report";  # Java
title: str = "Report"  # Python

# Python does not object: a hint is only a note for tools.
count = "many"  # Python

int number = 42;  # Java
number = 42  # Python

Object text = "Ann";  # Java
text = "Ann"  # Python

# Get the class of a value. In Python a number has one too.
text.getClass().getSimpleName()  # Java: String
type(text).__name__  # Python: str
type(number).__name__  # Python: int

# Check the type.
text instanceof String  # Java: true
isinstance(text, str)  # Python: True

# A number has methods; only a literal needs the parentheses.
Integer.bitCount(255)  # Java: 8
(255).bit_count()  # Python: 8

(int) 3.7  # Java: 3
int(3.7)  # Python: 3

(double) 3  # Java: 3.0
float(3)  # Python: 3.0

Integer.parseInt("42")  # Java: 42
int("42")  # Python: 42

Double.parseDouble("3.5")  # Java: 3.5
float("3.5")  # Python: 3.5

String.valueOf(42)  # Java: 42
str(42)  # Python: 42

# A character and its code.
(int) 'A'  # Java: 65
ord("A")  # Python: 65

(char) 65  # Java: A
chr(65)  # Python: A

# A trap: in Python a non-empty string is always true, even "false".
Boolean.parseBoolean("false")  # Java: false
bool("false")  # Python: True

int age = 30;  # Java
age = 30  # Python

"Age: " + age  # Java: Age: 30

# In Python "Age: " + age raises TypeError. f-strings are covered below.
"Age: " + str(age)  # Python: Age: 30
f"Age: {age}"  # Python: Age: 30

7 / 2  # Java: 3
7 // 2  # Python: 3

7.0 / 2  # Java: 3.5
7 / 2  # Python: 3.5

7 % 2  # Java: 1
7 % 2  # Python: 1

# Python has an operator for powers, and the result stays whole.
Math.pow(2, 10)  # Java: 1024.0
2 ** 10  # Python: 1024

int counter = 0;  # Java
counter = 0  # Python

# counter++ does not work in Python.
counter++;  # Java
counter += 1  # Python

var first = new ArrayList<>(List.of(1, 2));  # Java
first = [1, 2]  # Python

var second = new ArrayList<>(List.of(1, 2));  # Java
second = [1, 2]  # Python

# Whether the contents are equal.
first.equals(second)  # Java: true
first == second  # Python: True

# Whether it is the same object.
first == second  # Java: false
first is second  # Python: False

# An empty value. None is checked only with is.
String name = null;  # Java
name = None  # Python

name == null  # Java: true
name is None  # Python: True

name != null  # Java: false
name is not None  # Python: False

# Comparisons can be chained, as in maths.
int age = 30;  # Java
age = 30  # Python

age >= 18 && age < 65  # Java: true
18 <= age < 65  # Python: True

boolean active = true;  # Java
active = True  # Python

boolean admin = false;  # Java
admin = False  # Python

active && !admin  # Java: true
active and not admin  # Python: True

active || admin  # Java: true
active or admin  # Python: True

active = True
admin = False
print(active and not admin)  # True
print(active or admin)  # True

# The usual way to check that a collection is empty.
items = []
if not items:
    print("no items")  # no items

# One condition covers both None and empty.
name = None
if name:
    print(name)

String name = "";  # Java
name = ""  # Python

# or returns the first true value, here "guest".
name == null || name.isEmpty() ? "guest" : name  # Java: guest
name or "guest"  # Python: guest

# Careful: 0 is also false, so a real value gets lost.
0 or 100  # Python: 100

int score = 75;
String grade;

if (score >= 90) {
    grade = "A";
} else if (score >= 60) {
    grade = "B";
} else {
    grade = "C";
}
System.out.println(grade);  // B

String result = score >= 60 ? "pass" : "fail";
System.out.println(result);  // pass

score = 75

if score >= 90:
    grade = "A"
elif score >= 60:
    grade = "B"
else:
    grade = "C"
print(grade)  # B

# value_if_true if condition else value_if_false
result = "pass" if score >= 60 else "fail"
print(result)  # pass

String httpName(int code) {
    return switch (code) {
        case 200 -> "OK";
        case 301, 302 -> "Redirect";
        case 404 -> "Not Found";
        default -> "Unknown";
    };
}

System.out.println(httpName(302));  // Redirect
System.out.println(httpName(500));  // Unknown

def http_name(code):
    match code:
        case 200:
            return "OK"

        # The vertical bar means "or".
        case 301 | 302:
            return "Redirect"
        case 404:
            return "Not Found"

        # The underscore matches anything; this is default.
        case _:
            return "Unknown"


print(http_name(302))  # Redirect
print(http_name(500))  # Unknown

String describe(Object value) {
    return switch (value) {
        case Integer n when n > 100 -> "big number";
        case Integer n -> "number " + n;
        case String s -> "text " + s;
        case List<?> l -> "list of " + l.size();
        default -> "other";
    };
}

System.out.println(describe(500));  // big number
System.out.println(describe(List.of(1, 2)));  // list of 2

def describe(value):
    match value:

        # int(n) checks the type and binds the value to n; if is when.
        case int(n) if n > 100:
            return "big number"
        case int(n):
            return f"number {n}"
        case str(s):
            return f"text {s}"
        case list(items):
            return f"list of {len(items)}"
        case _:
            return "other"


print(describe(500))  # big number
print(describe([1, 2]))  # list of 2

# And here a pattern takes a value apart: a list of exactly two items.
match ["move", 10]:
    case ["move", distance]:
        print(distance)  # 10

var names = List.of("Ann", "Bob");

for (String name : names) {
    System.out.print(name + " ");  // Ann Bob
}

for (int i = 0; i < 3; i++) {
    System.out.print(i + " ");  // 0 1 2
}

for (int i = 10; i > 0; i -= 3) {
    System.out.print(i + " ");  // 10 7 4 1
}

names = ["Ann", "Bob"]

for name in names:
    print(name)  # Ann Bob

# range(3) gives 0, 1, 2. The right bound is excluded.
for i in range(3):
    print(i)  # 0 1 2

# range(from, to, step)
for i in range(10, 0, -3):
    print(i)  # 10 7 4 1

var names = List.of("Ann", "Bob");
var ages = List.of(30, 25);

// A value and its index
for (int i = 0; i < names.size(); i++) {
    System.out.print(i + ":" + names.get(i) + " ");  // 0:Ann 1:Bob
}

// Two lists in parallel
for (int i = 0; i < names.size(); i++) {
    System.out.print(names.get(i) + "=" + ages.get(i) + " ");  // Ann=30 Bob=25
}

// In reverse order
for (int i = names.size() - 1; i >= 0; i--) {
    System.out.print(names.get(i) + " ");  // Bob Ann
}

names = ["Ann", "Bob"]
ages = [30, 25]

# enumerate yields (index, value) pairs.
for i, name in enumerate(names):
    print(f"{i}:{name}")  # 0:Ann 1:Bob

# zip walks two lists at once and yields pairs.
for name, age in zip(names, ages):
    print(f"{name}={age}")  # Ann=30 Bob=25

for name in reversed(names):
    print(name)  # Bob Ann

int n = 0;
while (n < 10) {
    n++;
    if (n % 2 == 0) {
        continue;
    }
    if (n > 5) {
        break;
    }
    System.out.print(n + " ");  // 1 3 5
}

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

n = 0
while n < 10:
    n += 1
    if n % 2 == 0:
        continue
    if n > 5:
        break
    print(n)  # 1 3 5

# do-while is written as an endless loop with a check at the end.
tries = 0
while True:
    tries += 1
    if tries >= 3:
        break
print(tries)  # 3

var ids = List.of(1, 2, 3);
boolean found = false;

for (int id : ids) {
    if (id == 7) {
        found = true;
        break;
    }
}
if (!found) {
    System.out.println("not found");  // not found
}

ids = [1, 2, 3]

for id_ in ids:
    if id_ == 7:
        break
else:

    # We get here only if break did not fire.
    print("not found")  # not found

var names = List.of("Ann", "Bob");
int count;

if ((count = names.size()) > 1) {
    System.out.println(count);  // 2
}

names = ["Ann", "Bob"]

# Counted and checked at once. A plain = here would be a SyntaxError.
if (count := len(names)) > 1:
    print(count)  # 2

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

void greet(String name) {
    System.out.println("Hi, " + name);  // Hi, Ann
}

System.out.println(add(2, 3));  // 5
greet("Ann");

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


# The same with type hints. None here means void.
def greet(name: str) -> None:
    print(f"Hi, {name}")  # Hi, Ann


print(add(2, 3))  # 5
greet("Ann")

# A function with no return actually returns None.
print(greet("Ann"))  # None

String connect(String host, int port, boolean secure) {
    return host + ":" + port + " " + secure;
}

String connect(String host, int port) {
    return connect(host, port, false);
}

String connect(String host) {
    return connect(host, 80);
}

System.out.println(connect("a"));  // a:80 false
System.out.println(connect("a", 443, true));  // a:443 true

def connect(host, port=80, secure=False):
    return f"{host}:{port} {secure}"


print(connect("a"))  # a:80 False

# By position, as in Java.
print(connect("a", 443, True))  # a:443 True

# By name: port is skipped, and it is clear what True means.
print(connect("a", secure=True))  # a:80 True

int sum(int... numbers) {
    return Arrays.stream(numbers).sum();
}

System.out.println(sum(1, 2, 3));  // 6

int[] values = {1, 2, 3};
System.out.println(sum(values));  // 6

# numbers receives a tuple (1, 2, 3). A tuple is an immutable list.
def total(*numbers):
    return sum(numbers)


print(total(1, 2, 3))  # 6

# At the call, the star does the opposite: it spreads a list into arguments.
values = [1, 2, 3]
print(total(*values))  # 6


# options receives a dictionary {"port": 80, "secure": True}.
def connect(host, **options):
    print(host, options)  # a {'port': 80, 'secure': True}


connect("a", port=80, secure=True)

def send(message, *, retry=False):
    return f"{message} {retry}"


print(send("hi", retry=True))  # hi True

# TypeError: this way of passing is forbidden.
# send("hi", True)

record MinMax(int min, int max) {
}

MinMax minMax(List<Integer> items) {
    return new MinMax(Collections.min(items), Collections.max(items));
}

var result = minMax(List.of(3, 1, 2));
System.out.println(result.min() + " " + result.max());  // 1 3

def min_max(items):
    return min(items), max(items)


# The tuple is unpacked straight into two variables.
low, high = min_max([3, 1, 2])
print(low, high)  # 1 3

# An unneeded value traditionally goes into a variable named _ .
low, _ = min_max([3, 1, 2])

# The star takes "everything else".
head, *rest = [1, 2, 3]
print(head, rest)  # 1 [2, 3]

Function<Integer, Integer> twice = x -> x * 2;  # Java
twice = lambda x: x * 2  # Python

twice.apply(4)  # Java: 8
twice(4)  # Python: 8

# A method reference is just the function's name without parentheses.
Function<String, Integer> size = String::length;  # Java
size = len  # Python

size.apply("Ann")  # Java: 3
size("Ann")  # Python: 3

# Several parameters.
BinaryOperator<Integer> plus = (a, b) -> a + b;  # Java
plus = lambda a, b: a + b  # Python

plus.apply(2, 3)  # Java: 5
plus(2, 3)  # Python: 5

var names = new ArrayList<>(List.of("Bob", "Al", "Cindy"));  # Java
names = ["Bob", "Al", "Cindy"]  # Python

names.sort(Comparator.comparingInt(String::length));  # Java
names.sort(key=len)  # Python

names  # Java: [Al, Bob, Cindy]
names  # Python: ['Al', 'Bob', 'Cindy']

names.sort(Comparator.comparing(s -> s.charAt(s.length() - 1)));  # Java
names.sort(key=lambda s: s[-1])  # Python

names  # Java: [Bob, Al, Cindy]
names  # Python: ['Bob', 'Al', 'Cindy']

class User {
    private String name;
    private int age;

    User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    String greet() {
        return "Hi, " + this.name;
    }
}

User user = new User("Ann", 30);
System.out.println(user.greet());  // Hi, Ann

class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # You do not pass self at the call: Python supplies it.
    def greet(self):
        return f"Hi, {self.name}"


user = User("Ann", 30)
print(user.greet())  # Hi, Ann

# Exactly the same, with self passed by hand.
print(User.greet(user))  # Hi, Ann

class Money {
    static final String CURRENCY = "USD";
    int cents;

    Money(int cents) {
        this.cents = cents;
    }

    static boolean isValid(int cents) {
        return cents >= 0;
    }

    static Money ofDollars(int dollars) {
        return new Money(dollars * 100);
    }
}

System.out.println(Money.CURRENCY);  // USD
System.out.println(Money.isValid(-1));  // false
System.out.println(Money.ofDollars(2).cents);  // 200

class Money:
    CURRENCY = "USD"

    def __init__(self, cents):
        self.cents = cents

    @staticmethod
    def is_valid(cents):
        return cents >= 0

    # cls is the class Money itself. In a subclass it is the subclass.
    @classmethod
    def of_dollars(cls, dollars):
        return cls(dollars * 100)


print(Money.CURRENCY)  # USD
print(Money.is_valid(-1))  # False
print(Money.of_dollars(2).cents)  # 200

class Account {
    private int balance;

    int getBalance() {
        return balance;
    }

    void setBalance(int balance) {
        if (balance < 0) {
            throw new IllegalArgumentException("negative");
        }
        this.balance = balance;
    }
}

var account = new Account();
account.setBalance(100);
System.out.println(account.getBalance());  // 100

class Account:
    def __init__(self):
        self._balance = 0

    # The getter: read as a field, account.balance, no parentheses.
    @property
    def balance(self):
        return self._balance

    # The setter: fires on account.balance = 100.
    @balance.setter
    def balance(self, value):
        if value < 0:
            raise ValueError("negative")
        self._balance = value


account = Account()
account.balance = 100
print(account.balance)  # 100

class Point {
    int x, y;

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

    @Override
    public String toString() {
        return "Point(" + x + ", " + y + ")";
    }

    @Override
    public boolean equals(Object other) {
        return other instanceof Point p && p.x == x && p.y == y;
    }

    @Override
    public int hashCode() {
        return Objects.hash(x, y);
    }
}

System.out.println(new Point(1, 2));  // Point(1, 2)
System.out.println(new Point(1, 2).equals(new Point(1, 2)));  // true

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

    def __repr__(self):
        return f"Point({self.x}, {self.y})"

    # NotImplemented means "I cannot compare with this type".
    def __eq__(self, other):
        if not isinstance(other, Point):
            return NotImplemented
        return (self.x, self.y) == (other.x, other.y)

    def __hash__(self):
        return hash((self.x, self.y))


print(Point(1, 2))  # Point(1, 2)
print(Point(1, 2) == Point(1, 2))  # True

record Point(int x, int y) {
    public Point {
        if (x < 0) {
            throw new IllegalArgumentException("x");
        }
    }

    Point withX(int newX) {
        return new Point(newX, y);
    }
}

var point = new Point(1, 2);
System.out.println(point);  // Point[x=1, y=2]
System.out.println(point.x());  // 1
System.out.println(point.withX(5));  // Point[x=5, y=2]

from dataclasses import dataclass, field, replace


# Type hints are required here: the decorator finds the fields by them.
@dataclass(frozen=True)
class Point:
    x: int
    y: int = 0

    # The record's compact constructor: runs after __init__.
    def __post_init__(self):
        if self.x < 0:
            raise ValueError("x")


point = Point(1, 2)
print(point)  # Point(x=1, y=2)
print(point.x)  # 1

# replace makes a copy with a changed field, like withX.
print(replace(point, x=5))  # Point(x=5, y=2)

# point.x = 5 would raise FrozenInstanceError.


# A mutable default goes through field: each object gets its own list.
@dataclass
class Cart:
    items: list = field(default_factory=list)


print(Cart())  # Cart(items=[])

class Animal {
    String name;

    Animal(String name) {
        this.name = name;
    }

    String speak() {
        return name + " makes a sound";
    }
}

class Dog extends Animal {
    Dog(String name) {
        super(name);
    }

    @Override
    String speak() {
        return super.speak() + ": woof";
    }
}

Animal pet = new Dog("Rex");
System.out.println(pet.speak());  // Rex makes a sound: woof
System.out.println(pet instanceof Animal);  // true

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        return f"{self.name} makes a sound"


class Dog(Animal):
    def __init__(self, name):
        super().__init__(name)

    def speak(self):
        return f"{super().speak()}: woof"


pet = Dog("Rex")
print(pet.speak())  # Rex makes a sound: woof
print(isinstance(pet, Animal))  # True

abstract class Shape {
    abstract double area();

    String describe() {
        return "area " + area();
    }
}

class Square extends Shape {
    double side = 2;

    @Override
    double area() {
        return side * side;
    }
}

System.out.println(new Square().describe());  // area 4.0

from abc import ABC, abstractmethod


class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

    def describe(self):
        return f"area {self.area()}"


class Square(Shape):
    side = 2.0

    def area(self):
        return self.side * self.side


print(Square().describe())  # area 4.0

# Shape() would raise TypeError: an abstract class cannot be created.

interface Notifier {
    String send(String text);
}

class Email implements Notifier {
    public String send(String text) {
        return "email: " + text;
    }
}

String alert(Notifier notifier) {
    return notifier.send("down");
}

System.out.println(alert(new Email()));  // email: down

from typing import Protocol


class Notifier(Protocol):
    def send(self, text: str) -> str:
        ...


# No implements, no inheritance: matching methods are enough.
class Email:
    def send(self, text: str) -> str:
        return f"email: {text}"


def alert(notifier: Notifier) -> str:
    return notifier.send("down")


print(alert(Email()))  # email: down

enum Status {
    NEW("new"),
    PAID("paid");

    final String code;

    Status(String code) {
        this.code = code;
    }
}

System.out.println(Status.PAID.name());  // PAID
System.out.println(Status.PAID.code);  // paid
System.out.println(Status.valueOf("NEW").code);  // new
System.out.println(Status.values().length);  // 2

from enum import Enum, StrEnum


class Status(Enum):
    NEW = "new"
    PAID = "paid"


print(Status.PAID.name)  # PAID
print(Status.PAID.value)  # paid

# Look up by name and by value.
print(Status["NEW"].value)  # new
print(Status("paid").name)  # PAID
print(len(Status))  # 2
print(Status.PAID is Status("paid"))  # True


# A StrEnum element equals a string, handy for JSON and databases.
class Color(StrEnum):
    RED = "red"


print(Color.RED == "red")  # True

Runnable task = new Runnable() {
    @Override
    public void run() {
        System.out.println("run");  // run
    }
};
task.run();

def run_task(task):
    task()


# Instead of an anonymous class, a function declared where it is needed.
def task():
    print("run")  # run


run_task(task)

List<String> names = new ArrayList<>();  # Java
names: list[str] = []  # Python

Map<String, Integer> ages = new HashMap<>();  # Java
ages: dict[str, int] = {}  # Python

# A value or null.
String nickname = null;  # Java
nickname: str | None = None  # Python

class Box<T> {
    private final T value;

    Box(T value) {
        this.value = value;
    }

    T get() {
        return value;
    }
}

<T extends Comparable<T>> T maxOf(T a, T b) {
    return a.compareTo(b) > 0 ? a : b;
}

System.out.println(new Box<>("x").get());  // x
System.out.println(maxOf(1, 2));  // 2

class Box[T]:
    def __init__(self, value: T) -> None:
        self._value = value

    def get(self) -> T:
        return self._value


# T: int | str is a bound, like T extends in Java.
def max_of[T: int | str](a: T, b: T) -> T:
    return a if a > b else b


print(Box("x").get())  # x
print(max_of(1, 2))  # 2

int parse(String text) {
    try {
        return Integer.parseInt(text);
    } catch (NumberFormatException | NullPointerException e) {
        System.out.println("bad: " + text);  // bad: abc
        return 0;
    } finally {
        System.out.println("done");  // done
    }
}

parse("abc");

def parse(text):
    try:
        return int(text)

    # Several types are listed in parentheses.
    except (ValueError, TypeError) as e:
        print(f"bad: {text}")  # bad: abc
        return 0
    finally:
        print("done")  # done


parse("abc")

class OrderException extends RuntimeException {
    OrderException(String message, Throwable cause) {
        super(message, cause);
    }
}

try {
    try {
        Integer.parseInt("abc");
    } catch (NumberFormatException e) {
        throw new OrderException("bad id", e);
    }
} catch (OrderException e) {
    System.out.println(e.getMessage());  // bad id
    System.out.println(e.getCause() instanceof NumberFormatException);  // true
}

class OrderError(Exception):
    pass


try:
    try:
        int("abc")
    except ValueError as e:
        raise OrderError("bad id") from e
except OrderError as e:
    print(e)  # bad id

    # __cause__ is the same as getCause().
    print(isinstance(e.__cause__, ValueError))  # True

try:
    value = int("42")
except ValueError:
    print("bad")
else:

    # Only if there was no error.
    print(value)  # 42

class Resource implements AutoCloseable {
    Resource() {
        System.out.println("open");  // 1. open
    }

    @Override
    public void close() {
        System.out.println("close");  // 3. close
    }
}

try (var resource = new Resource()) {
    System.out.println("work");  // 2. work
}

class Resource:
    def __enter__(self):
        print("open")  # 1. open

        # What __enter__ returns goes into the variable after as.
        return self

    def __exit__(self, exc_type, exc, tb):
        print("close")  # 3. close


with Resource() as resource:
    print("work")  # 2. work

Path path = Files.createTempFile("demo", ".txt");

try (var writer = Files.newBufferedWriter(path)) {
    writer.write("hello");
}

System.out.println(Files.readString(path));  // hello

import tempfile
from pathlib import Path

path = Path(tempfile.mkdtemp()) / "demo.txt"

# The file closes by itself. Always give the encoding, or the system one is used.
with open(path, "w", encoding="utf-8") as file:
    file.write("hello")

print(path.read_text(encoding="utf-8"))  # hello

# Importing a single name.
import java.time.LocalDate;  # Java
from datetime import date  # Python

# A static import.
import static java.lang.Math.sqrt;  # Java
from math import sqrt  # Python

# Importing everything. This is frowned upon in Python.
import java.util.*;  # Java
from math import *  # Python

# Python only: the whole module, then access through its name.
import math  # Python
math.floor(2.5)  # Python: 2

# Python only: your own short name.
import datetime as dt  # Python
dt.date(2026, 1, 2).year  # Python: 2026

# From another file in the project.
from orders.domain import Order

# From a sibling file in the same package: the dot means "this package".
from .domain import Order

# One level up.
from ..domain import Order