Functions in Python

In Python, functions are blocks of reusable code that perform specific tasks. They enhance
code readability, modularity, and reusability.

Defining a Function:

To define a function, you use the def keyword followed by the function name and
parentheses:

Python
def function_name():
# Function body

Function Parameters:

You can pass values to a function through parameters. These parameters act as variables
within the function's scope:

Python
def greet(name):
print("Hello, " + name + "!")

greet("Alice") # Output: Hello, Alice!

Return Values:

Functions can return values using the return statement:

Python
def square(x):
return x * x

result = square(5)
print(result) # Output: 25

Function Arguments:

Python supports various ways to pass arguments to functions:

1. Positional Arguments:
o Arguments are assigned to parameters based on their position.
2. Keyword Arguments:
o Arguments are assigned to parameters by keyword, regardless of their
position.
3. Default Arguments:
o Parameters can have default values assigned to them.
4. Variable-Length Arguments:
o You can use *args to accept an arbitrary number of positional arguments and
**kwargs to accept an arbitrary number of keyword arguments.

Example:
Python
def calculate_area(length, width, shape="rectangle"):
if shape == "rectangle":
return length * width
elif shape == "square":
return length * length
else:
return "Invalid shape"

area1 = calculate_area(5, 4) # Positional arguments

area2 = calculate_area(width=3, length=6) # Keyword arguments
area3 = calculate_area(5, shape="square") # Default and positional
arguments

print(area1, area2, area3)

Key Points:

 Functions can be defined anywhere in your code, but they are typically defined at the
beginning of a module or script.
 Functions can be called from other functions.
 Functions can be recursive, meaning they can call themselves.
 Functions can be used to organize your code into smaller, more manageable pieces.
 Functions can be used to create libraries of reusable code.

Built-in Functions in Python

Python comes with a rich set of built-in functions that you can use to perform various tasks
without having to write your own code. Here are some of the most commonly used ones:

Basic Functions:

 abs(x): Returns the absolute value of a number.

 divmod(a, b): Returns a tuple containing the quotient and remainder of integer
division.
 max(iterable, *args): Returns the largest item in an iterable or the largest of two
or more arguments.
 min(iterable, *args): Returns the smallest item in an iterable or the smallest of
two or more arguments.
 pow(base, exp[, mod]): Returns the value of base to the power of exp.
 round(number[, ndigits]): Rounds a number to a specified number of decimal
places.
 sum(iterable, start=0): Returns the sum of items in an iterable.

Type Conversion Functions:

 int(x): Converts a number or string to an integer.

 float(x): Converts a number or string to a floating-point number.
 str(x): Converts an object to a string representation.
 bool(x): Converts an object to a Boolean value.

Input/Output Functions:
  print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False):
Prints objects to the console.
 input(prompt=''): Reads a line from input, converts it to a string, and returns it.

Mathematical Functions:

 math.sqrt(x): Returns the square root of a number.

 math.pi: Returns the value of pi.
 math.e: Returns the value of Euler's number.
 math.sin(x), math.cos(x), math.tan(x): Trigonometric functions.

String Manipulation Functions:

 len(s): Returns the length of a string.

 str.upper(), str.lower(), str.capitalize(): Case conversion functions.
 str.strip(), str.lstrip(), str.rstrip(): Removes whitespace from strings.
 str.split(sep=None): Splits a string into a list of substrings.
 str.join(iterable): Joins elements of an iterable into a string.

List and Tuple Functions:

 len(list): Returns the length of a list or tuple.

 list.append(x): Adds an element to the end of a list.
 list.insert(i, x): Inserts an element at a specific index in a list.
 list.remove(x): Removes the first occurrence of an element from a list.
 tuple(iterable): Converts an iterable to a tuple.

Date and Time Functions in Python

Python offers a robust module named datetime to handle date and time operations
effectively. Here are some common functions and methods within this module:

Importing the datetime Module:

Python
import datetime

Getting Current Date and Time:

Python
# Get current date and time
now = datetime.datetime.now()
print(now) # Output: 2023-11-18 16:33:22.234123

Extracting Components:

Python
year = now.year
month = now.month
day = now.day
hour = now.hour
minute = now.minute
second = now.second
microsecond = now.microsecond

print(year, month, day, hour, minute, second, microsecond)

Creating Date and Time Objects:

Python
# Create a specific date
date_of_birth = datetime.date(1995, 12, 25)
print(date_of_birth)

# Create a specific time

time_of_meeting = datetime.time(10, 30, 30)
print(time_of_meeting)

# Create a specific datetime

datetime_obj = datetime.datetime(2023, 11, 18, 16, 33, 22)
print(datetime_obj)

Timedeltas:

Python
# Calculate time difference
t1 = datetime.datetime(2023, 11, 18, 12, 00)
t2 = datetime.datetime(2023, 11, 18, 18, 00)
time_difference = t2 - t1
print(time_difference) # Output: 6:00:00

Formatting Date and Time:

Python
formatted_date = now.strftime("%d/%m/%Y") # 18/11/2023
formatted_time = now.strftime("%H:%M:%S") # 16:33:22
formatted_datetime = now.strftime("%d/%m/%Y %H:%M:%S") # 18/11/2023
16:33:22
print(formatted_date, formatted_time, formatted_datetime)

Additional Tips:

 Use datetime.timedelta to represent time differences.

 Utilize datetime.datetime.strptime() to parse strings into datetime objects.
 Explore the pytz module for handling time zones.
 Consider using libraries like dateutil for advanced date and time manipulation.

By effectively using the datetime module, you can perform a wide range of date and time
operations in your Python programs.
Generating Random Numbers in Python

Python provides a built-in module named random to generate random numbers. Here are
some common functions:

1. random.random():

 Generates a random float number between 0.0 (inclusive) and 1.0 (exclusive).

Python
import random

random_float = random.random()
print(random_float) # Output: A random float between 0.0 and 1.0

2. random.uniform(a, b):

 Generates a random float number between a (inclusive) and b (inclusive).

Python
random_float = random.uniform(10, 20)
print(random_float) # Output: A random float between 10.0 and 20.0

3. random.randint(a, b):

 Generates a random integer number between a (inclusive) and b (inclusive).

Python
random_integer = random.randint(1, 10)
print(random_integer) # Output: A random integer between 1 and 10

4. random.randrange(start, stop[, step]):

 Generates a random integer from the range start to stop with the specified step.

Python
random_integer = random.randrange(0, 101, 5) # Random integer from 0, 5,
10, ..., 100
print(random_integer)

5. random.choice(sequence):

 Chooses a random element from a sequence (like a list or tuple).

Python
my_list = [1, 2, 3, 4, 5]
random_choice = random.choice(my_list)
print(random_choice) # Output: A random element from the list

6. random.shuffle(sequence):
  Shuffles the elements of a sequence in place.

Python
my_list = [1, 2, 3, 4, 5]
random.shuffle(my_list)
print(my_list) # Output: A shuffled list

Global and Local Variables in Python

In Python, variables declared inside a function are local to that function, while variables
declared outside a function are global.

Local Variables:

 Scope: Limited to the function where they are declared.

 Lifetime: Exists only during the function's execution.

Python
def my_function():
x = 10 # Local variable
print(x)

my_function() # Output: 10

Global Variables:

 Scope: Accessible from anywhere in the program.

 Lifetime: Exists throughout the program's execution.

Python
x = 20 # Global variable

def my_function():
print(x)

my_function() # Output: 20

Modifying Global Variables Inside Functions:

To modify a global variable inside a function, you need to declare it as global:

Python
x = 10

def modify_global():
global x
x = 20

modify_global()
print(x) # Output: 20
Best Practices:

 Minimize Global Variables: Excessive use of global variables can make code harder
to understand and maintain.
 Use Function Arguments and Return Values: Pass necessary data to functions as
arguments and return results.
 Consider Using Classes: For complex scenarios, encapsulate related variables and
functions within a class.

Recursion in Python
Recursion is a programming technique where a function calls itself directly or indirectly. It's
often used to solve problems that can be broken down into smaller, self-similar
subproblems.

Basic Structure of a Recursive Function:

Python
def recursive_function(input):
# Base case: If the input is simple enough, return a result directly
if base_condition(input):
return base_result

# Recursive case: Break down the problem into smaller subproblems

smaller_input = reduce_input(input)
result = recursive_function(smaller_input)

# Combine the results of the subproblems

return combine_results(result, input)

Example: Factorial Calculation

Python
def factorial(n):
if n == 0:
return 1 # Base case
else:
return n * factorial(n - 1) # Recursive case

result = factorial(5)
print(result) # Output:
120