Ads and ad measurement. Disabled until you allow it.
ABOUT SITE
All open site tabs
Python · Syntax · Beginner
Functions
10 tasks
Basic exercises on functions in Python: creating functions, parameters, return statements, checking numbers and strings, working with lists, tuples, and simple calculations.
Quick topic start and explanations before exercises (exercises below):
A function is a named block of code you can call by name, from anywhere, as many times as you need. The point is not to save typing — it is to give behavior a name, and to make code testable and reusable.
Without functions, if you need to check whether a number is even in three different places, you copy the same if n % 2 == 0 check three times. When the logic changes, you fix it in three places and hope you did not miss one. With a function, you fix it once.
A function also creates a clear contract: here is what goes in (parameters), here is what comes out (return value). You can test that contract in isolation without running the whole program.
In these exercises every task is the same format: write a function that does one specific thing. This forces you to think about inputs and outputs separately from the rest of your code — which is the core skill.
Defining a function in Python:
```python
def square(n):
return n * n
result = square(5)
print(result) # 25
```
def announces the function definition. square is the name. n inside the parentheses is a parameter — a local variable that receives the value you pass when calling. return sends a value back to the caller and exits the function.
A function without a return statement (or with a bare return) returns None. This is rarely what you want in exercises — always check that you are actually returning a value.
pass is a placeholder that lets you write the function signature before implementing the body. You will see it in the starter code for every exercise here:
```python
def square(n):
pass # remove this and write the actual logic
```
Parameters are local: they exist only inside the function. Changing a parameter does not affect variables outside. If you want to communicate a result back, you return it — you do not print it inside the function (unless the function's job is printing, which is rare).
Multiple parameters work the same way:
```python
def max_of_two(a, b):
if a >= b:
return a
return b
```
Once you hit return, the function stops. You do not need else after return.
Most exercises in this topic fall into one of three patterns.
Compute and return — apply an operation and send back the result:
```python
def power(base, exp):
return base ** exp
print(power(2, 10)) # 1024
```
Check and return a boolean — test a condition, return True or False:
```python
def is_even(n):
return n % 2 == 0
print(is_even(8)) # True
print(is_even(7)) # False
```
Note that return n % 2 == 0 is a single expression. n % 2 == 0 already evaluates to True or False, so you return that directly — no need for an if.
Iterate and build — loop over a sequence inside the function, accumulate a result, return it:
```python
def multiply(sequence):
result = 1
for n in sequence:
result *= n
return result
print(multiply((3, 4, 100, 15))) # 18000
```
String operations often combine a built-in method with return:
```python
def to_upper(text):
return text.upper()
```
Short but useful — functions do not have to be long to be worth writing.
**Function syntax**
```python
def function_name(param1, param2):
# body
return value
# call:
result = function_name(arg1, arg2)
```
**Key rules**
| Rule | Detail |
|---|---|
| `return` sends a value back | without it the function returns `None` |
| `return` exits immediately | no code after it in the same branch runs |
| Parameters are local | changing them does not affect variables outside |
| `pass` is a placeholder | remove it before writing real logic |
**Three core patterns**
```python
# 1. Compute and return
def power(base, exp):
return base ** exp
# 2. Check and return a boolean
def is_even(n):
return n % 2 == 0 # expression already gives True/False
# 3. Iterate and build
def multiply_all(nums):
result = 1
for n in nums:
result *= n
return result
```
**Common mistakes**
```python
# Forgetting return — function silently returns None:
def square(n):
n * n # computed but not returned!
# Printing instead of returning:
def square(n):
print(n * n) # caller gets None, not the value
# Unnecessary if/else for booleans:
def is_even(n): # bad
if n % 2 == 0:
return True
else:
return False
def is_even(n): # good
return n % 2 == 0
```
Write a function that takes one number and
returns its square.
def square(n):
pass
result = square(5)
print(result)
result = square(2)
print(result)
result = square(25)
print(result)
Solution
def square(n):
return n * n
result = square(5)
print(result)
result = square(2)
print(result)
result = square(25)
print(result)
# or
def square(n):
result = n * n
return result
# or
def square(n):
result = n ** 2
return result
# or
def square(n):
return n ** 2
def max_of_two(a, b):
if a > b:
return a
else:
return b
print(max_of_two(10, 7))
# OR if you look carefully, you can also do it like this, else is not really needed,
# because return finishes the function if it works inside a condition or at all:
def max_of_two(a, b):
if a > b:
return a
return b
print(max_of_two(10, 7))
# or you can do this: first check equality
def bigger(a, b):
if a == b:
return a
if a > b:
return a
return b
def string_length(text):
count = 0
for _ in text:
count += 1
return count
print(string_length("python"))
# or you can name the counter more clearly
def get_length(text):
count = 0
for char in text:
count += 1
return count
Write a function that takes a number and
returns True if the number is even, otherwise False .
def is_even(n):
pass
print(is_even(8))
Solution
def is_even(n):
if n % 2 == 0:
return True
else:
return False
print(is_even(8))
# OR
def is_even(n):
if n % 2 == 0:
return True
return False
# OR
def is_even(n):
return n % 2 == 0 # immediately return the comparison result.
# or you can do this using a variable
def is_even(n):
result = n % 2 == 0
return result
Write a function that takes a string and
returns a new string with characters in uppercase.
def to_upper(text):
pass
print(to_upper("hello"))
Solution
def to_upper(text):
return text.upper()
print(to_upper("hello"))
# or you can do this: save the result first
def to_upper(text):
result = text.upper()
return result
Write a function that takes a number and
returns True if it is positive, otherwise False .
def is_positive(n):
pass
print(is_positive(-3))
Solution
def is_positive(n):
if n > 0:
return True
else:
return False
print(is_positive(-3))
# OR
def is_positive(n):
if n > 0:
return True
return False
# OR
def is_positive(n):
return n > 0
def multiply(sequence):
result = 1
for n in sequence:
result *= n
return result
print(multiply((3, 4, 100, 15)))
# OR better
def multiply(sequence):
if len(sequence) == 0: # <--- really good
return 0
result = 1
for n in sequence:
result *= n
return result
def repeat_text(text, count):
result = ""
for _ in range(count): # not cool, there is a cooler way below.
result += text
return result
print(repeat_text(")", 3))
# OR
def repeat_text(text, count):
return text * count
No split tab
Cookie preferences
We use necessary cookies to run the site. With your permission, we can also save your site preferences and use analytics and advertising cookies to understand usage and support the project.
Open tools in tabs.Exercises, IDE tools, and trainers stay available as site tabs.
Switch without losing context.Move between explanations, code, and utilities while keeping your place.
Use the sidebar as your map.The left panels hold navigation, settings, files, libraries, and tool controls.
PythonJavaScriptSQLite
One IDE, three practical modes
Python in the browser.Run small scripts, try libraries, and practice API requests without installing anything.
JavaScript for quick experiments.Test browser-friendly code and compare ideas next to your learning materials.
SQLite for data practice.Open the database explorer to inspect tables, write queries, and learn SQL workflows locally.
TopicIDE
Work side by side with split tabs
Keep instructions visible.Open an exercise or reference page beside the IDE instead of jumping back and forth.
Compare tools while you learn.Place regex checks, explanations, and code experiments next to each other when the task needs it.
Close the split when you are done.The workspace returns to a single focused tab, and your open site tabs remain available.
Code Typing Trainer
Or plain text
This trainer is designed for a physical keyboard.Open this section on a laptop or desktop with a wide screen. Touch typing practice will not work correctly on a phone.
Speed: 0 chars/min
0 words/min
Best speed (60s): 0 chars/min
0 words/min
Errors: 0
Total time: 0.0 s
To practice touch typing, avoid looking at your physical keyboard.