Functions

Functions in Jython are defined with def, support default and keyword arguments, *args/**kwargs, and closures - exactly as in Python. Jython adds one big capability: Python functions can be called from Java code and can implement Java interfaces, which is how Jython plugs into the Java world.

Basic Functions

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

def greet(name, greeting="Hello"):
    return f"{greeting}, {name}"

print(add(2, 3))          # 5
print(greet("Ada"))       # Hello, Ada
print(greet("Ada", "Hi")) # Hi, Ada

Variable Arguments

def total(*args, **kwargs):
    s = sum(args)
    for k, v in kwargs.items():
        s += v
    return s

print(total(1, 2, 3, bonus=10))  # 16

Closures and Lambdas

def make_adder(n):
    def adder(x):
        return x + n
    return adder

add5 = make_adder(5)
print(add5(10))  # 15

squares = [x * x for x in range(5)]
print(squares)

Return Values

def classify(n):
    if n > 0:
        return "positive"
    elif n < 0:
        return "negative"
    return "zero"

# multiple return values as a tuple
def divmod2(a, b):
    return a // b, a % b

q, r = divmod2(17, 5)
print(q, r)  # 3 2

Implementing Java Interfaces

One of Jython's superpowers: a Python class can implement a Java interface and be passed to Java APIs that expect it:

import java.util

class MyComparator(java.util.Comparator):
    def compare(self, a, b):
        return int(a) - int(b)

nums = java.util.ArrayList()
for n in [3, 1, 2]:
    nums.add(n)
java.util.Collections.sort(nums, MyComparator())
print(nums)  # [1, 2, 3]

Calling Java Methods from Functions

import java.lang

def word_count(text):
    words = java.lang.String(text).split(" ")
    return words.length()

print(word_count("one two three"))  # 3

Summary

Functions in Jython are ordinary Python functions - def, defaults, *args/**kwargs, closures, lambdas, tuple returns - plus the Jython twist: Python classes can implement Java interfaces (like java.util.Comparator) and be handed to Java APIs. That bridge is what turns Python functions into JVM callbacks.