3.
1 — Defining functions, Errors & Debugging
Types of Errors
Syntax Errors: When syntax is incorrect such as wrong punctuations,
invalid characters, missing quotes or parentheses etc.
Program does not run at all in the case of syntax errors.
1 # The following code has Syntax error due to missing double-quotes:
2 x = 5
3 print("Square of x is)
4 print(x ** 2)
Runtime Errors, also called Exceptions, occur when there is a problem
in the program during execution.
All code executes until an exception occurs.
1 # The following code produces NameError because
2 # variable y was not created before it is used.
3 x = 5
4 print("Value of x is", x)
5 print("Square of x is", y ** 2)
Semantic or Logic errors are said to occur when a program executes
without a problem but does not produce correct output as expected.
Debugging is the process of finding and removing errors in a program.
Using debugging in Thonny for better
understanding order of evaluation
In Thonny, we can use debugging features to understand how expressions
are evaluated:
To show variables and their values, go to menu “View -> Variables”
First, run program in debug mode by clicking the “Debug current
script” button (located next to the “Run current script” button and
looks like a bug)
Then, we have two options:
Run the program line-by-line using “Step over” button next to the
“Debug” button
Run program going inside each expression using “Step into”
button (located next to “Step over” button)
Try the following code in Thonny and use debug:
1 x = 7
2
3 # Increment value of variable x by 1
4 x = x + 1
5
6 #
7 y = x * x + 2 * (x + 1) + max(x + 1, 5)
8
9 # Calling print() with 4 arguments
10 print("x =", x, "y =", y)
11
12
13 message = "Hello"
14
15 # Calling print() with 1 argument
16 print("+" + "-" * (len(message) + 6) + "+")
17
18 # Calling print() with 3 arguments
19 print("+", "-" * (len(message) + 6), "+")
Defining a function
A function is a named block of code that performs a task.
So far we have been using (calling) functions to do specific tasks —
print() , input() , etc.
We can also define/create our own function:
1 def function_name(argument1, argument2, ..., argumentN): # function header
2 # function body
3 statement1
4 statement2
5 .
6 .
7 statementN
def is a Python keyword used to define functions
Notice how statements are indented by spaces, typically 4 spaces. In
Thonny, we can just use tab key once to indent by 4 spaces.
When we define a function using def keyword:
it is not executed.
Only the function name is created, which refers to the code block
inside the function.
When we call a function, the code block inside the function is actually
executed.
Function with no arguments
Such functions always do the same thing each time they are executed.
Output
1 # Function definition
+------------+
2 def display_greeting(): | Welcome! |
3 print("+------------+") +------------+
4 print("| Welcome! |") +------------+
| Welcome! |
5 print("+------------+")
+------------+
6
7 # Function call
8 display_greeting()
9
10 # Call it again
11 display_greeting()
Functions with arguments and return value
A function can return a value using return statement.
1 # Function that evaluates a polynomial
2 def f(x):
3 return x * x - x - 1
4
5 # Equivalently,
6 # def f(x):
7 # result = x * x - x - 1
8 # return result
9
10 # Call the function f
11 y = f(5)
12 print(y) # 19
13
14 # Call again with different argument
15 y = f(10)
16 print(y) # 89
17
18
19 # we can have more than one argument
20 def mean(x, y):
21 return (x + y) / 2
22
23
24 print(mean(3, 4)) # 3.5
25
26 print(mean(f(5), f(10))) # 54.0
Parentheses () are required to call a function. Omitting them is a
common mistake.
When a function is called, correct number of arguments must be
passed. It is an error to pass too many or too few arguments than
what a function definition expects.
Why create our own functions?
Functions allow code re-use; duplication of code can be avoided.
They help organize code into sections, which makes programs easier
to read and understand.
They make programs easier to fix.
Docstrings
A docstring (documentation string) is a multiline (triple-quoted) string
that we write after the header of a function to explain how the function
works.
It is an important part of programming to write such documentation.
You will be expected do so in your assignments.
1 def euclidean_distance(x1, y1, x2, y2):
2 """
3 Computes Euclidean distance between two 2D points.
4
5 Args:
6 x1: x-coordinate of first point (float)
7 y1: y-coordinate of first point (float)
8 x2: x-coordinate of second point (float)
9 y2: y-coordinate of second point (float)
10
11 Returns: the euclidean distance as a float
12 """
13 d = (x1 - x2) ** 2 + (y1 - y2) ** 2
14 return d ** 0.5
