How can I add type hints to a small function's parameters and return value?

Write the input hint after the parameter name, preceded by a colon. Put the output hint after ->, just before the final colon of the function definition. For example:

def greet(name: str) -> str:
    return f"Hello, {name}!"

Here, name: str describes the expected parameter type, and -> str describes the intended return type. Python uses this colon-and-arrow form for function annotations. [S1] Check that the return annotation matches what the function actually returns.

Choose annotations that describe the function’s actual expectations and behavior, rather than what you hope callers will pass. For a small function, annotating each parameter and the return value can make the signature easy to read. For example:

def repeat_label(label: str, count: int) -> str:
    return label * count

The signature communicates that label is expected to be a string, count an integer, and the result a string. Check the function’s behavior, including every return path, so the annotations describe what it does. A hint is a description of expected types, not a substitute for understanding the function.

Not by itself. Python does not enforce function parameter or return annotations at runtime, so the annotation alone does not automatically reject an argument or verify a returned value. [S1] Type checkers, IDEs, and linters can use hints to help identify mismatches, but that is separate from runtime enforcement. [S1]

If your program must reject a value at runtime, type hints alone do not provide that validation. Consider separately whether your function needs explicit checks.

For a function that turns minutes into a label, an annotated version might look like this:

def minutes_label(minutes: int) -> str:
    return f"{minutes} minutes"

Before keeping these annotations, ask whether the function is meant to receive an integer and whether every path through its body returns a string. If it accepts other inputs or can return another kind of value, adjust the annotations to reflect its intended behavior.

A quick review:

1. List each parameter and the kind of value the function expects.
2. Add : type after each parameter name.
3. Trace the return paths and choose a truthful return type after ->.
4. Read the signature alongside the function body and check that they match.
5. Remember that hints communicate expectations; they do not automatically validate runtime calls or results. [S1]

These examples use simple parameter and return types. The annotations themselves do not establish whether a project has separate runtime validation or how its type-checking tools are configured; check those requirements separately when they matter.