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.
0 comments:
Post a Comment