During your journey of learning Python, you will discover an interesting phenomenon: whether you are writing small scripts or working on large projects, functions are almost everywhere. If variables are the “bricks” of a program, then functions are the “building blocks.” Learning functions is like learning how to construct a house from scattered bricks.
Many beginners may have the following questions when they learn about functions:
- What exactly is the purpose of a function?
- If I can run my code with print(), why should I bother defining functions?
- The parameters, return values, and scopes in functions seem a bit convoluted; how should I understand them?
Don’t worry, this article will take you from basics to advanced, thoroughly explaining the essence of Python functions. The article is quite long, but by the end, you will have a comprehensive understanding of functions, sufficient to handle most development scenarios.
1. What is a Function?
In a nutshell: A function is a way to “package” your code so that you can call it directly when needed.
Imagine this: if you have to write <span>print("hello world")</span> a hundred times every day, wouldn’t that be tedious? At this point, you can define a function to encapsulate the logic of “printing hello world,” and later, you just need to write the function name to run the code, making it both convenient and clean.
def say_hello():
"""Print a greeting"""
print('hello world')
# Call the function
say_hello()
say_hello()
Output:
hello world
hello world
This is the most fundamental meaning of a function: to extract repetitive logic and improve reusability.
2. The Power of Parameters: Making Functions More Flexible
Simply printing hello world is obviously not very meaningful. The true power of functions lies in their ability to accept “parameters,” making the logic flexible.
def greet(name):
"""Greet a specified person"""
print(f'Hello, {name}!')
greet('Alice')
greet('Bob')
Output:
Hello, Alice!
Hello, Bob!
This is like adding notes when ordering takeout:
- Requesting “extra spicy” is one parameter;
- Requesting “no onions” is also a parameter.
The parameters of a function are the key to changing the logic based on input.
3. Understanding the “Parameter System” of Functions
Python’s function parameters have some nuances that often trip up beginners. Let’s break them down one by one:
3.1 Positional Parameters
Passing values to a function in order is called positional parameters.
def describe_pet(animal_type, pet_name):
print(f"I have a {animal_type}.")
print(f"My {animal_type}'s name is {pet_name}.")
describe_pet('hamster', 'Harry')
Output:
I have a hamster.
My hamster's name is Harry.
3.2 Keyword Parameters
Don’t want to remember the order? Just write the parameter names:
describe_pet(pet_name='Harry', animal_type='hamster')
The effect is exactly the same.
3.3 Default Parameters
Some parameters often have similar default values, so you can give them a default value.
def describe_pet(pet_name, animal_type='dog'):
print(f"I have a {animal_type}.")
print(f"My {animal_type}'s name is {pet_name}.")
describe_pet('Willie') # If animal_type is not provided, it defaults to dog
Result:
I have a dog.
My dog's name is Willie.
It’s like ordering milk tea with a default of “half sugar,” unless you specifically say, “I want full sugar.”
4. Return Values: The “Output” of Functions
If a function can only print results, that would be too limiting. A more common requirement is: for a function to perform calculations and return the results for subsequent code to use.
4.1 Returning a Single Value
def add_numbers(a, b):
return a + b
result = add_numbers(3, 5)
print(result) # 8
4.2 Returning Multiple Values
Returning multiple values in Python is common; they are actually packed into a tuple.
def get_name():
first = 'John'
last = 'Doe'
return first, last
first_name, last_name = get_name()
print(first_name, last_name)
Result:
John Doe
5. Advanced Techniques: *args and **kwargs
Sometimes you don’t know how many parameters to pass; in that case, use variable-length parameters.
5.1 <span>*args</span> — Variable-length Positional Parameters
def make_pizza(*toppings):
print("Making a pizza with the following toppings:")
for topping in toppings:
print(f"- {topping}")
make_pizza('pepperoni')
make_pizza('mushrooms', 'green peppers', 'extra cheese')
5.2 <span>**kwargs</span> — Variable-length Keyword Parameters
def build_profile(first, last, **user_info):
user_info['first_name'] = first
user_info['last_name'] = last
return user_info
user_profile = build_profile('albert', 'einstein',
location='princeton',
field='physics')
print(user_profile)
Output:
{'location': 'princeton', 'field': 'physics', 'first_name': 'albert', 'last_name': 'einstein'}
This is like filling out a resume: the first two items are required, and you can add any other information as you like.
6. Functions Can Also Be Treated Like Variables
Functions in Python are first-class citizens and can do many things.
6.1 Assigning to Variables
def shout(text):
return text.upper()
yell = shout
print(yell('hello')) # HELLO
6.2 Passing as Parameters
def greet(func):
greeting = func('Hi, I am created by a function')
print(greeting)
greet(shout)
This is the embryonic form of functional programming.
7. Lambda Functions: Anonymous Little Tools
Sometimes, if a function is too short, you might not want to go through the trouble of writing <span>def</span>, so you can use <span>lambda</span>.
square = lambda x: x ** 2
print(square(5)) # 25
numbers = [1, 2, 3, 4]
squared_numbers = list(map(lambda x: x**2, numbers))
print(squared_numbers) # [1, 4, 9, 16]
8. Scope: How Long Do Variables Live?
8.1 Local vs Global
x = 10
def my_func():
x = 20
print("Local x:", x)
my_func()
print("Global x:", x)
Result:
Local x: 20
Global x: 10
8.2 Modifying Global Variables
x = 10
def modify_global():
global x
x = 20
modify_global()
print(x) # 20
9. Decorators: Elegant “Add-ons”
Decorators are essentially functions that wrap other functions, allowing you to add some “pre” and “post” actions without modifying the original function.
def my_decorator(func):
def wrapper():
print("Decorator: Executing before the function call")
func()
print("Decorator: Executing after the function call")
return wrapper
@my_decorator
def say_hello():
print("Hello!")
say_hello()
10. Practical Examples
10.1 Simple Calculator
def calculator(operation, a, b):
if operation == 'add':
return a + b
elif operation == 'subtract':
return a - b
elif operation == 'multiply':
return a * b
elif operation == 'divide':
if b == 0:
return "Error: Division by zero"
return a / b
else:
return "Error: Invalid operation"
print(calculator('add', 5, 3)) # 8
print(calculator('divide', 10, 2)) # 5.0
print(calculator('power', 2, 3)) # Error: Invalid operation
10.2 User Validation
def validate_user(username, password):
if len(username) < 4:
return False, "Username must be at least 4 characters"
if len(password) < 8:
return False, "Password must be at least 8 characters"
if not any(c.isdigit() for c in password):
return False, "Password must contain digits"
return True, "Validation successful"
result, message = validate_user("admin", "password123")
print(result, message)
Conclusion
The role of functions in Python is akin to that of an engine in a car. Without functions, code will eventually become chaotic; well-utilized functions lead to clear, maintainable, and easily extensible code.
From the simplest encapsulation to advanced decorators and lambdas, functions are not just syntactical tools but a way of thinking. Mastering functions means you have truly stepped into the world of Python.