Unit II:Flow Control: Decision Making – Loops – Nested Loops –
Types of Loops. Functions: Function Definition – Function Calling –
Function Arguments – Recursive Functions – Function with more
than one return value.
Decision making statement
decision making statement if, if else , if elif else, Nested if statement
definition with example and syntax
1. If Statement
The if statement is the most basic decision-making statement. It
executes block of code only if the specified condition evaluates to True.
Syntax
if condition:
# code block to execute if condition is True
Example
a = 10
if a > 5:
print("a is greater than 5")
Output:
a is greater than 5
2. If-Else Statement
The if-else statement executes one block of code if the condition
is True, otherwise it executes the else block.
Syntax
if condition:
# code when True
else:
# code when False
Example
a = 10
if a > 20:
print("a is greater than 20")
else:
print("a is 20 or less")
Output:
a is 20 or less
3. If-Elif-Else Statement (Chained Conditionals)
The if-elif-else statement checks multiple conditions sequentially. The first
True condition’s block executes, or else block if none match.
Syntax
if condition1:
# code if condition1 True
elif condition2:
# code if condition2 True
else:
# code if all above False
Example
number = -5
if number > 0:
print("Positive number")
elif number == 0:
print("Zero")
else:
print("Negative number")
Output:
Negative number
4. Nested If Statement
A nested if statement is an if statement inside another if
statement, allowing checking multiple conditions in a hierarchical manner.
Syntax
if condition1:
if condition2:
# code if both condition1 and condition2 True
else:
# code if condition1 True but condition2 False
else:
# code if condition1 False
Example
var = 100
if var == 100:
print("The number is 100")
if var % 2 == 0:
print("The number is even")
else:
print("The number is odd")
else:
print("The number is not 100")
Output:
The number is 100
The number is even
Loops
1. For Loop
A for loop in Python is used to iterate over a sequence (like a list,
tuple, string, or range) and executes a block of code for each element in
the sequence.
Syntax
for variable in sequence:
# code block to execute for each element
Example
fruits = ['apple', 'banana', 'cherry']
for fruit in fruits:
print(fruit)
Output:
apple
banana
cherry
2. While Loop
A while loop runs a block of code repeatedly as long as a
specified condition evaluates to True.
Syntax
while condition:
# code block to execute while condition is True
Example
count = 1
while count <= 5:
print(count)
count += 1
Output:
3. Nested Loops
A nested loop is a loop inside another loop. The inner loop is
executed completely every time the outer loop runs once.
Syntax
for outer_variable in outer_sequence:
for inner_variable in inner_sequence:
# code block to execute nested
Example
for i in range(1, 4):
for j in range(1, 4):
print(f'i={i}, j={j}')
Output:
i=1, j=1
i=1, j=2
i=1, j=3
i=2, j=1
i=2, j=2
i=2, j=3
i=3, j=1
i=3, j=2
i=3, j=3
Control Statements
1. Break Statement
The break statement terminates the loop prematurely when a
specified condition is met and transfers control to the statement
immediately following the loop.
Syntax
for variable in sequence:
if condition:
break
# other code
Example
for i in range(10):
if i == 5:
break
print(i)
Output:
2. Continue Statement
The continue statement skips the current iteration of the loop
and proceeds to the next iteration, effectively ignoring the remaining code
in the loop body for that iteration.
Syntax
For variable in sequence:
if condition:
continue
# other code
Example
for i in range(10):
if i % 2 == 0:
continue
print(i)
Output:
3. Pass Statement
The pass statement is a null operation; it does nothing when
executed. It is commonly used as a placeholder in code blocks where
syntax requires a statement but no action is needed or planned yet.
Syntax
for variable in sequence:
if condition:
pass
else:
# other code
Example
for i in range(5):
if i == 3:
pass # placeholder for future code
print(i)
Output:
Function
A function in Python is a reusable block of code designed to
perform a specific task. Functions help organize code, make it modular,
and improve readability and maintainability. A function runs only when it is
called.
Syntax
Def function_name(parameters):
“””Docstring (optional): Describe the function.”””
# function body (code block)
Return value # optional return statement
- `def`: Keyword to define a function
- `function_name`: The name of the function (should follow Python
naming rules)
- `parameters`: Optional inputs to the function inside parentheses,
comma-separated
- The function body is indented and contains the code executed when the
function is called
- `return`: Optional statement to send back a result from the function (if
needed)
Examples
1. Basic Function Without Parameters
Def greet():
Print(“Hello, World!”)
Greet()
Output:
Hello, World!
2. Function With Parameters
Def greet(name):
Print(“Hello, “ + name + “!”)
Greet(“Alice”)
Greet(“Bob”)
Output:
Hello, Alice!
Hello, Bob!
3. Function With Return Value
Def add(a, b):
Return a + b
Result = add(5, 3)
Print(result)
Output:
4. Function With Docstring
Def square(num):
“””Returns the square of a number.”””
Return num * num
Print(square(4))
Output:
16
Function calling
Function calling in Python is the process of executing a function that
has been defined earlier. When a function is called, the control transfers to
the function, its code block is executed, and then control returns to the
point from where the function was called.
Syntax
function_name(arguments)
- `function_name`: The name of the function to call.
- `arguments`: Optional values passed to the function parameters inside
parentheses.
Examples
1. Calling Function Without Arguments
def greet():
print("Hello, World!")
greet() # Calling the function
Output:
Hello, World!
2. Calling Function With Arguments
def greet(name):
print("Hello, " + name + "!")
greet("Alice") # Passing argument during call
Output:
Hello, Alice!
3. Calling Function and Using Return Value
def add(a, b):
return a + b
result = add(5, 3) # Function call with arguments
print(result)
Output:
4. Calling One Function From Another
def first():
print("First function called")
second()
def second():
print("Second function called")
first() # Calls first(), which calls second()
Output:
First function called
Second function called
Function Arguments
Python functions can accept different types of arguments to
provide flexibility in passing values. Here are the main types with
examples:
1. Positional Arguments
Arguments passed in the correct positional order. The number of
arguments must match the parameters.
Example:
def greet(name, age):
print(f"Hello {name}, you are {age} years old.")
greet("Alice", 25)
Output:
Hello Alice, you are 25 years old.
2. Default Arguments
Arguments that have a default value if not provided during the
function call.
Example:
def greet(name, age=18):
print(f"Hello {name}, you are {age} years old.")
greet("Bob") # Uses default age=18
greet("Charlie", 30) # Overrides default
Output:
Hello Bob, you are 18 years old.
Hello Charlie, you are 30 years old.
3. Keyword Arguments
Arguments passed by explicitly specifying parameter names,
allowing argument order to vary.
Example:
def greet(name, age):
print(f"Hello {name}, you are {age} years old.")
greet(age=22, name="David")
Output:
Hello David, you are 22 years old.
4. Arbitrary Positional Arguments (`*args`)
Allows passing a variable number of positional arguments as a
tuple.
Example:
def add(*numbers):
total = 0
for num in numbers:
total += num
return total
print(add(1, 2))
print(add(4, 5, 6))
Output:
15
5. Arbitrary Keyword Arguments (`**kwargs`)
Allows passing a variable number of keyword arguments as a
dictionary.
Example:
def person_info(**info):
for key, value in [Link]():
print(f"{key}: {value}")
person_info(name="Eva", age=29, city="London")
Output:
name: Eva
age: 29
city: London
Recursive Functions
A recursive function is a function that calls itself directly or
indirectly in order to solve a problem by breaking it down into simpler or
smaller subproblems. It continues to call itself until it reaches a **base
case** which stops the recursion.
Syntax
def recursive_function(parameters):
if base_case_condition:
return base_case_value
else:
return recursive_function(modified_parameters)
- The base case is the exit condition that prevents infinite recursion.
- The recursive case is where the function calls itself with modified
arguments.
Examples
1. Factorial Using Recursion
Calculates factorial of a positive integer $$ n $$.
def factorial(n):
if n == 0:
return 1 # Base case
else:
return n * factorial(n-1) # Recursive call
print(factorial(5))
Output:
120
2. Fibonacci Sequence Using Recursion
Calculates the $$ n^{th} $$ Fibonacci number.
def fibonacci(n):
if n == 0:
return 0 # Base case 1
elif n == 1:
return 1 # Base case 2
else:
return fibonacci(n-1) + fibonacci(n-2) # Recursive calls
print(fibonacci(10))
Output:
55
Function with More Than One Return Value in Python:
A Python function can return multiple values simultaneously by
separating them with commas. Internally, Python packs these values into
a tuple and returns it. This feature allows more than one piece of data to
be returned and used by the caller function.
Syntax
def function_name(parameters):
# code
return value1, value2, ..., valueN
When calling, multiple return values can be unpacked into individual
variables like:
val1, val2, ..., valN = function_name(arguments)
Examples
1. Returning Multiple Values as a Tuple
def multiple_returns():
return "Sum", 15
operation, total = multiple_returns()
print(operation)
print(total)
Output:
Sum
15
2. Returning Multiple Values Using List
def multiple_returns():
return ["Sum", 15]
values = multiple_returns()
print(values)
Output:
['Sum', 15]
3. Returning Multiple Values Using Dictionary
def multiple_returns():
return {"operation": "Sum", "total": 15}
values = multiple_returns()
print(values)
Output:
{'operation': 'Sum', 'total': 15}
4. Example: Return Quotient and Remainder
def div_with_remainder(num, div):
quotient = num // div
remainder = num % div
return quotient, remainder
q, r = div_with_remainder(17, 3)
print("Quotient:", q)
print("Remainder:", r)
Output:
Quotient: 5
Remainder: 2
Multiple return values improve a function’s versatility by enabling it to
output related pieces of data in a single call, using tuples, lists,
dictionaries, or objects .A Python function can return more than one value
at a time by separating the return values with commas. These values are
returned as a tuple, which can be unpacked into separate variables for
use.
Syntax
def function_name(parameters):
# computation
return value1, value2, ..., valueN
Examples
1. Returning multiple values as tuple
def multiple_returns():
return "Sum", 15
operation, total = multiple_returns()
print(operation) # Output: Sum
print(total) # Output: 15
2. Returning quotient and remainder
def div_with_remainder(num, div):
quotient = num // div
remainder = num % div
return quotient, remainder
q, r = div_with_remainder(17, 3)
print("Quotient:", q) # Output: Quotient: 5
print("Remainder:", r) # Output: Remainder: 2
3. Returning multiple values as dictionary
def func():
return {"operation": "Sum", "total": 15}
result = func()
print(result) # Output: {'operation': 'Sum', 'total': 15}