Functions & Modules

Python - A Quick Start for existing Programers

3 min read

Published Sep 16 2025, updated Sep 30 2025

Python

Functions

Functions are defined using the def keyword and then the contents of the function are indented. Function names, like variables, should be lower case snake case:

def my_function():

print("My function")

And then to call the function (needs to be under where it is defined):

my_function()

Any function that doesn't return a value, will actually return a None value. To return a value you use the return keyword:

def my_function():

print("My function")

return "My return value"

Zero or many parameters can be passed to a function:

def my_function(my_parameter1, my_parameter2):

print("My function", my_parameter1, my_parameter2)

return "My return value"

Optional parameters can be defined a default value, which means you can call them with a parameter or without and it takes the default:

def my_function(my_parameter1="Default value", my_parameter2=42):

print("My function", my_parameter1, my_parameter2)

return "My return value"

result = my_function("Custom value", 100)

result2 = my_function()

When calling a function, you can specify the parameter names so that they can be added in any order:

def introduce(name, age):

print(f"My name is {name}, and I am {age} years old.")

introduce(age=25, name="Bob")

Multiple positional arguments. Allows a variable amount of positional based parameters for a function, providing the parameters as a tuple:

def add_all(*args):

return sum(args)

print(add_all(1, 2))

print(add_all(1, 2, 3, 4, 5))

Multiple keyword arguments. Allows a variable amount of keyword based parameters for a fucntion, providing the parameters as a key value pair dictionary:

def show_info(**kwargs):

for key, value in kwargs.items():

print(f"{key}: {value}")

show_info(name="Alice", age=25, job="Engineer")

Combining Normal Parameters, *args, and **kwargs:

def example(a, b, *args, c=10, **kwargs):

print("a:", a)

print("b:", b)

print("args:", args)

print("c:", c)

print("kwargs:", kwargs)

example(1, 2, 3, 4, 5, c=20, x=100, y=200)

Results in:

a: 1

b: 2

args: (3, 4, 5)

c: 20

kwargs: {'x': 100, 'y': 200}

Argument Unpacking with * and **:

def greet(name, age):

print(f"Hi, I'm {name}, {age} years old.")

# Using * to unpack a tuple

person = ("Alice", 30)

greet(*person)

# Hi, I'm Alice, 30 years old.

# Using ** to unpack a dict

person_info = {"name": "Bob", "age": 25}

greet(**person_info)

# Hi, I'm Bob, 25 years old.

Lambda functions

A lambda function is a small, anonymous function defined with the lambda keyword. They are useful for short, throwaway functions where using def would be overkill.

lambda arguments: expression

arguments → zero or more parameters.
expression → a single expression (no statements, no multiple lines).
Returns the value of the expression automatically (no return needed).

Limitations

Can only contain one expression (no statements like print, for, if as standalone).
Not a replacement for normal functions — use def for anything non-trivial.
Less readable if overused (can hurt clarity).

Examples:

# --- Basics ---

add = lambda x, y: x + y

print("add(2, 3):", add(2, 3))

# 5

# No arguments

hello = lambda: "Hello!"

print(hello())

# Hello!

square = lambda x=2: x * x

print("square():", square())

# 4

print("square(5):", square(5))

# 25

nested = lambda x: (lambda y: y**x)

print("nested power:", nested(2)(5))

# 25

# --- filter() with lambda ---

evens = list(filter(lambda n: n % 2 == 0, nums))

print("filter -> evens:", evens)

# [2, 4]

# --- sorted() with lambda ---

words = ["banana", "apple", "cherry"]

sorted_by_length = sorted(words, key=lambda w: len(w))

print("sorted by length:", sorted_by_length)

# ['apple', 'banana', 'cherry']

Function variable scopes

Local variables created in a function are only accessible in that function:

def my_func():

# local variable

x = 10

print(x)

my_func()

print(x)

# ERROR: x not defined

Global variables are accessible inside a function to read, however if you try and assign a variable a value, it will create a new local variable of that name:

# global variable

x = 100

def show():

# can read global variable but can't set

print(x)

show()

Using the global keyword inside a function will use the global variable, rather than creating a new local variable:

x = 5

def change():

global x

x = 10

change()

print(x)

# outputs 10 as the global variable is updated in the function

In nested functions, variables in the outer function are enclosing scope. Use nonlocal to modify them rather than creating a new local variable in the inner function:

def outer():

x = "outer"

def inner():

nonlocal x

x = "inner"

inner()

print(x)

outer()