The body of a function is simply a Python script. When the
function is called, its arguments are passed as elements of the
list args; named arguments are also passed
as ordinary variables to the Python script. Use of named arguments
is usually more readable. The result is returned from the Python
code in the usual way, with return or
yield (in case of a result-set statement).
If you do not provide a return value, Python returns the default
None. PL/Python translates Python's None into the SQL null value.

For example, a function to return the greater of two integers
can be defined as:

The Python code that is given as the body of the function
definition is transformed into a Python function. For example, the
above results in:

def __plpython_procedure_pymax_23456():
if a > b:
return a
return b

assuming that 23456 is the OID assigned to the function by
PostgreSQL.

The arguments are set as global variables. Because of the
scoping rules of Python, this has the subtle consequence that an
argument variable cannot be reassigned inside the function to the
value of an expression that involves the variable name itself,
unless the variable is redeclared as global in the block. For
example, the following won't work:

because assigning to x makes x a local variable for the entire block, and so the
x on the right-hand side of the assignment
refers to a not-yet-assigned local variable x, not the PL/Python function parameter. Using the
global statement, this can be made to
work: