Chapter 4: Functions and Modules

 

4.1 Introduction to
Functions 4.1.1 Defining functions with def and function syntax Explanation:
Functions allow you to encapsulate a block of code into a reusable entity. The
def keyword is used to define a function, followed by the function name and
parameters. Example:

python

///Example

def greet(name):

    print("Hello, " + name +
"!")

 

greet("Alice")

 

4.1.2 Function
arguments: parameters and arguments passing Explanation: Functions can accept
parameters, which act as placeholders for values passed to the function.
Arguments are the actual values passed to the function when it is called.
Example:

python

///Example

def add(a, b):

    return a + b

 

result = add(5, 3)

print(result)

 

4.1.3 Returning values
from functions Explanation: Functions can return values using the return
statement. The returned value can be assigned to a variable or used directly.
Example:

python

///Example

def multiply(a, b):

    return a * b

 

result = multiply(4, 5)

print(result)

 

4.2 Function Parameters
4.2.1 Positional parameters and keyword arguments Explanation: Function
parameters can be passed by position or using keyword arguments. Keyword
arguments allow you to specify the parameter name when calling the function.
Example:

python

///Example

def
describe_person(name, age):

    print("Name:", name)

    print("Age:", age)

 

describe_person("Alice",
25)

describe_person(age=30,
name="Bob")

 

4.2.2 Default parameter
values and optional arguments Explanation: Function parameters can have default
values assigned, making them optional. If an argument is not provided for a
parameter with a default value, the default value is used. Example:

python

///Example

def greet_person(name,
greeting="Hello"):

    print(greeting + ", " + name +
"!")

 

greet_person("Alice")

greet_person("Bob",
"Hi")

 

4.2.3 Variable-length
argument lists (*args and **kwargs) Explanation: Functions can accept a
variable number of arguments using *args and **kwargs. *args collects
positional arguments, and **kwargs collects keyword arguments. Example:

python

///Example

def sum_numbers(*args):

    total = 0

    for num in args:

        total += num

    return total

 

result = sum_numbers(1,
2, 3, 4)

print(result)

 

4.3 Function Scope and
Global Variables 4.3.1 Local scope and variable visibility Explanation:
Variables defined inside a function are scoped locally and can only be accessed
within the function. They are not visible outside the function. Example:

python

///Example

def greet():

    message = "Hello"

    print(message)

 

greet()

print(message)  # Raises an error

 

4.3.2 Global variables
and the global keyword Explanation: Global variables are defined outside of any
function and can be accessed from any part of the program. The global keyword
allows you to modify a global variable from within a function. Example:

python

///Example

count = 0

 

def increment_count():

    global count

    count += 1

 

increment_count()

print(count)

 

4.3.3 Avoiding naming
conflicts and shadowing Explanation: It's important to avoid naming conflicts
between local and global variables. Shadowing occurs when a local variable has
the same name as a global variable, hiding the global variable. Example:

python

///Example

total = 10

 

def calculate_total():

    total = 0 
# Shadowing the global variable

    # Perform calculations using local total

    return total

 

print(calculate_total())  # Outputs the local total, not the global
total

 

4.4 Modules and Importing
4.4.1 Introduction to modules and the import statement Explanation: Modules are
files containing Python code that can be used in other programs. The import
statement allows you to use code from modules in your program. Example:

python

///Example

import math

 

radius = 5

area = math.pi *
math.pow(radius, 2)

print(area)

 

4.4.2 Importing
specific items from a module Explanation: You can import specific functions or
variables from a module using the from ... import statement. Example:

python

///Example

from math import sqrt

 

result = sqrt(25)

print(result)

 

4.4.3 Creating and
using your own modules Explanation: You can create your own modules by writing
Python code in separate files. These modules can be imported and used in other
programs. Example: Module: mymodule.py

python

///Example

def greet(name):

    print("Hello, " + name +
"!")

 

Program: main.py

python

///Example

import mymodule

 

mymodule.greet("Alice")

 

This chapter covers the
concepts of functions and modules in Python. Functions allow you to encapsulate
code into reusable blocks, and modules provide a way to organize and reuse code
across multiple programs. The examples provided demonstrate the usage and
syntax of each topic, helping readers understand how to apply these concepts in
their own programs.