Week 1

Certainly! Python is a popular high-level programming language known for its simplicity,
readability, and versatility. It's widely used for web development, data analysis, scientific
computing, automation, artificial intelligence, and more. Here's a brief introduction to some
key aspects of Python:

1. Syntax and Readability: Python emphasizes clean and readable code by using
indentation (whitespace) to define blocks of code, rather than relying on curly braces
or other symbols. This forces programmers to write code that is consistent and easy to
understand.
2. Variables and Data Types: In Python, you can create variables without explicitly
declaring their types. Common data types include integers, floating-point numbers,
strings (text), lists, tuples, dictionaries, and more.
3. Control Structures: Python supports common control structures like if statements,
for and while loops. These structures allow you to control the flow of your program
based on conditions and iterate through data.
4. Functions: Functions in Python allow you to group code into reusable blocks. You
define functions using the def keyword and can pass arguments to them. Functions
can also return values using the return keyword.
5. Lists, Tuples, and Dictionaries:
• Lists are ordered collections of elements, and they can contain elements of
different data types.
• Tuples are similar to lists but are immutable, meaning their contents cannot be
changed after creation.
• Dictionaries are collections of key-value pairs. They allow you to access
values using their associated keys.
6. Object-Oriented Programming (OOP): Python supports OOP principles like
classes and objects. You can define your own classes with attributes (variables) and
methods (functions) that operate on those attributes.
7. Modules and Libraries: Python has an extensive standard library that provides built-
in modules for various purposes. Additionally, there is a vast ecosystem of third-party
libraries and frameworks that extend Python's capabilities. For example, numpy for
numerical computations, pandas for data manipulation, and matplotlib for data
visualization.
8. File Handling: Python can read and write files easily using built-in functions. You
can read text files, manipulate their content, and write new data to them.
9. Exception Handling: Python provides a way to handle exceptions (errors) using try
and except blocks. This helps to gracefully handle unexpected situations in your code.
10. Interactivity: Python can be run interactively using an interpreter or a Jupyter
Notebook. This allows you to experiment with code snippets, test ideas, and see
immediate results.

To get started with Python, you need to install it on your system. You can download the
Python interpreter from the official website (https://www.python.org/downloads/) and follow
the installation instructions for your operating system.

Once installed, you can write Python code in a text editor or integrated development
environment (IDE) and run it using the Python interpreter. Start with simple programs,
gradually exploring the language's features and syntax. There are also numerous online
resources, tutorials, and courses available to help you learn Python effectively.

Why Python:

Python is a popular choice for programming due to several reasons:

1. Readability and Simplicity: Python's syntax is clear and easy to understand, making
it a great language for beginners and experienced programmers alike. Its use of
indentation enforces clean and consistent code.
2. Versatility: Python can be used for a wide range of applications, from web
development and data analysis to scientific research and artificial intelligence. Its
extensive library ecosystem provides tools for various tasks.
3. Community and Support: Python has a large and active community of developers,
which means you can find a wealth of resources, tutorials, and help online. This
community also contributes to the development of new libraries and tools.
4. Cross-Platform: Python is available on multiple operating systems, including
Windows, macOS, and Linux, ensuring your code can run on different platforms
without major modifications.
5. Integration: Python can be easily integrated with other programming languages,
allowing you to leverage existing code written in different languages.
6. Rapid Development: Python's high-level abstractions and dynamic typing make it
suitable for rapid prototyping and development, helping you bring your ideas to life
quickly.

Installation:

To start working with Python, you need to install it on your computer. Here's a basic guide to
installing Python:

1. Download Python: Go to the official Python website

(https://www.python.org/downloads/) and download the latest version of Python for
your operating system.
2. Installation: Run the installer and follow the prompts. Make sure to check the option
to add Python to your system's PATH environment variable. This allows you to run
Python from the command line without specifying the full path.
3. Verify Installation: Open a command prompt (Windows) or terminal
(macOS/Linux) and type python --version or python3 --version to verify that Python
is installed. You should see the version number displayed.

Working with Python IDLE:

Python comes with a built-in Integrated Development and Learning Environment (IDLE) that
provides a simple way to write and execute Python code. Here's how you can use Python
IDLE:

1. Opening IDLE: After installing Python, you can open IDLE by searching for "IDLE"
in your operating system's search bar and selecting the appropriate option.
 2. Writing Code: In the IDLE window, you can start writing Python code directly.
Simply type your code and press Enter to execute it.
3. Running Code: To run a block of code, you can highlight it with your cursor and
press F5 or select "Run Module" from the "Run" menu.
4. Interactive Mode: IDLE also supports an interactive mode where you can enter
Python commands one by one and see their immediate results. This is useful for
experimenting with code.
5. Saving Files: You can save your code as Python files with the .py extension. Use the
"File" menu to create new files, open existing ones, and save your work.

Remember that while IDLE is a simple environment for learning and experimenting, as you
become more comfortable with Python, you might want to explore more feature-rich code
editors and integrated development environments (IDEs) like Visual Studio Code, PyCharm,
or Jupyter Notebook for more complex projects.
Week Two
PYTHON SYNTAX AND VARIABLES

Certainly! Let's dive into the basics of Python syntax and how to work with
variables:

Python Syntax: Python's syntax is designed to be clear and readable.

Indentation is used to define blocks of code, and colons are used to
indicate the start of an indented block. Here are some fundamental
elements of Python syntax:

1. Indentation: Unlike many programming languages that use curly

braces, Python uses indentation to define blocks of code. Consistent
indentation is crucial for correct program execution.
2. Statements: Instructions in Python are called statements. Each
statement ends with a newline character. For example:

print("Hello, world!")

3. Comments: Comments are used to annotate your code and provide explanations.
Single-line comments start with # , and multi-line comments are enclosed within triple
quotes (''' or """).
# This is a single-line comment

'''
This is a multi-line comment.
It can span multiple lines.
'''
 4. Indentation Blocks: Control structures, functions, and classes are
defined using indentation blocks. A colon is used to indicate the start
of an indented block.
if x > 10:
print("x is greater than 10")

Variables in Python:

Variables are used to store and manage data in a program. In Python, you
don't need to declare the type of a variable explicitly; Python determines
the type based on the value assigned. Variable names should follow certain
rules:

• They can contain letters (both uppercase and lowercase), digits, and
underscores.
• They must start with a letter or an underscore.
• They are case-sensitive (e.g., ‘myVariable’ and ‘myvariable’ are different).

Here's how you can work with variables in Python:

1. Variable Assignment: You assign a value to a variable using the =

operator.
age = 25
name = "Alice"

2. Data Types: Python supports various data types, including integers,

floating-point numbers, strings, lists, tuples, dictionaries, and more.
The data type is determined by the assigned value.
num = 42 # integer
pi = 3.14159 # floating-point number
message = "Hello" # string
my_list = [1, 2, 3] # list
my_tuple = (10, 20) # tuple
my_dict = {"key": "value"} # dictionary

3. Variable Naming Convention: It's a good practice to follow naming

conventions to make your code more readable. Common convention
is using lowercase letters with underscores for variable names
(snake_case).
 total_amount = 100.50
user_name = "JohnDoe"
4. Variable Reassignment: You can change the value of a variable after
it's been assigned.

age = 25
age = age + 1 # Now age is 26

Remember that Python is dynamically typed, so variables can change their

data type during execution. It's important to be mindful of the data type
when performing operations on variables.

WEEK THREE

PYTHON DATA TYPES

Python supports a variety of built-in data types that allow you to represent different
kinds of information. Here are some of the most common data types in Python:

1. Numeric Types:
• int: Represents integers (whole numbers) like -3, 0, 42.
• float: Represents floating-point numbers (numbers with decimal
points) like 3.14, -0.5.
2. Text Type:
• str: Represents strings of characters. Strings are enclosed in single ( ' )
or double (") quotes.

message = "Hello, World!"

3. Sequence Types:
• list: Represents ordered collections of items, which can be of different
data types. Lists are mutable (modifiable).

my_list = [1, "apple", 3.14, True]

• tuple: Similar to lists, but tuples are immutable (cannot be modified

after creation).

my_tuple = (1, "banana", 2.71, False)

 • range: Represents a sequence of numbers. It's often used in loops to
iterate over a range of values.

my_range = range(5) # Produces 0, 1, 2, 3, 4

0, 1, 2, 3, 4
4. Mapping Type:
• dict: Represents key-value pairs, where keys are unique and used to
access corresponding values. Dictionaries are enclosed in curly braces
{}.

my_dict = {"name": "Alice", "age": 30, "city": "New York"}

5. Set Types:
• set: Represents an unordered collection of unique elements. Sets are
enclosed in curly braces {}.

my_set = {1, 2, 3, 4}

6. Boolean Type:
• bool: Represents Boolean values True or False . Used in logical
operations and conditions.

is_student = True
has_car = False

7. None Type:
• None: Represents the absence of a value. It's often used to indicate the
absence of a meaningful result.

result = None

These are the fundamental built-in data types in Python. Understanding these types
and their characteristics is crucial for writing effective and correct programs.
Additionally, Python allows you to create your own custom data types using classes,
which is a fundamental concept in object-oriented programming.

To determine the data type of a variable, you can use the type() function:

age = 25
print(type(age)) # Output: <class 'int'>

name = "Alice"
print(type(name)) # Output: <class 'str'>
Remember that Python is dynamically typed, so variables can change their data type
during execution if you reassign them to different values.

WEEK FOUR

PYTHON CASTING
Casting, also known as type conversion or type casting, is the process of changing the data
type of a value from one type to another. Python provides built-in functions to perform type
casting between different data types. Here's how you can perform casting in Python:

1. Implicit Type Conversion: Python performs some automatic type conversions based
on the context. For example, when performing operations involving different numeric
types, Python may automatically convert them to a common type:

int_num = 5
float_num = 3.14

result = int_num + float_num # Implicitly converts int_num to float

print(result) # Output: 8.14

2. Explicit Type Conversion: Sometimes you need to explicitly convert values from
one type to another. Python provides built-in functions for explicit type conversion:
• int(): Converts a value to an integer.

float_num = 3.14
int_num = int(float_num) # Converts float to int

• float(): Converts a value to a floating-point number.

int_num = 5
float_num = float(int_num) # Converts int to float

• str(): Converts a value to a string.

num = 42
num_str = str(num) # Converts int to string

• list(), tuple(), set(): Converts a sequence type (like a list or tuple) to another
sequence type.

my_list = [1, 2, 3]
my_tuple = tuple(my_list) # Converts list to tuple

my_set = set(my_list) # Converts list to set

• bool(): Converts a value to a Boolean value.

 num = 0
bool_value = bool(num) # Converts 0 to False

non_empty_list = [1, 2, 3]
bool_list = bool(non_empty_list) # Converts non-empty list to True

It's important to note that not all type conversions are valid. For example, converting a non-
numeric string to an integer will raise a ‘ValueError’ unless the string contains a valid
representation of an integer. Similarly, some conversions might lead to loss of information
(e.g., converting a floating-point number to an integer truncates the decimal part).

Always be cautious when performing type conversions to ensure that the resulting value
retains its intended meaning and behaviour.

WEEK FIVE

PYTHON STRINGS
In Python, strings are used to represent sequences of characters. They can contain letters,
digits, symbols, and whitespace. Strings are widely used for text processing, manipulation,
and representation. Here's an overview of working with strings in Python:

Creating Strings: Strings in Python can be created using single quotes (‘'’), double quotes
(‘"’), or triple quotes (‘'''’ or ‘"""’ ). Triple quotes are used for multi-line strings.

single_quoted = 'Hello, world!'

double_quoted = "Python is fun."
multi_line = '''This is a
multi-line string.'''

String Concatenation: Strings can be concatenated (joined together) using the + operator.

greeting = "Hello"
name = "Alice"
message = greeting + " " + name
print(message) # Output: Hello Alice

String Methods: Python provides a variety of built-in methods to manipulate and work with
strings. Some commonly used string methods include:

• len(): Returns the length of the string.

text = "Hello, world!"

length = len(text) # Returns 13

• upper (), lower(): Converts the string to uppercase or lowercase.

 text = "Python"
uppercase_text = text.upper() # Returns "PYTHON"
lowercase_text = text.lower() # Returns "python"

• strip(): Removes leading and trailing whitespace characters.

text = " Python "

stripped_text = text.strip() # Returns "Python"

• replace(): Replaces occurrences of a substring with another substring.

sentence = "I like apples."

new_sentence = sentence.replace("apples", "bananas") # Returns "I like bananas."

• split(): Splits a string into a list of substrings based on a delimiter.

sentence = "This is a sentence."

words = sentence.split() # Returns ["This", "is", "a", "sentence."]

• join(): Joins elements of a list into a single string using a specified delimiter.

words = ["Hello", "world"]

sentence = " ".join(words) # Returns "Hello world"

• format (): Formats a string by replacing placeholders with values.

name = "Alice"
age = 30
greeting = "Hello, my name is {} and I am {} years old.".format(name, age)

• startswith(), endswith(): Checks if a string starts or ends with a specified substring.

text = "Python is fun!"

starts_with_python = text.startswith("Python") # Returns True
ends_with_fun = text.endswith("fun!") # Returns True

These are just a few examples of the many string methods available in Python. Strings are a
fundamental part of Python programming, and understanding how to manipulate and work
with them is crucial for various applications, including text processing, formatting, and more.

WEEK SIX
PYTHON LISTS, PYTHON TUPLES
Sure, let's explore Python lists and tuples, two common sequence data types used to store
collections of items.
Python Lists: A list is a mutable, ordered collection of items, which can be of different data
types. Lists are created using square brackets ‘[]’.

fruits = ["apple", "banana", "orange"]

numbers = [1, 2, 3, 4, 5]
mixed_list = [1, "hello", 3.14, True]

Lists allow you to:

• Access elements by index: Elements in a list are ordered, starting from index 0.

print(fruits[0]) # Output: "apple"

• Modify elements: Lists are mutable, so you can change the value of elements.

fruits[1] = "grape"

• Add elements: You can append, insert, or extend elements in a list.

fruits.append("pear")
fruits.insert(1, "watermelon")
new_fruits = ["cherry", "kiwi"]
fruits.extend(new_fruits)

• Remove elements: You can remove elements by index or value.

del fruits[0] # Removes the first element

fruits.remove("banana") # Removes "banana"

Python Tuples: A tuple is an immutable, ordered collection of items, similar to a list but its
elements cannot be changed after creation. Tuples are created using parentheses () .

point = (3, 4)
coordinates = (-1.5, 2.7)
mixed_tuple = (1, "hello", 3.14, False)

Tuples are often used when you have a collection of items that should not be modified after
creation. They provide structural integrity to the data.

# Accessing elements
print(point[0]) # Output: 3

# Unpacking tuples
x, y = point
print(x) # Output: 3
print(y) # Output: 4
Tuples are commonly used in situations where the position of each item has significance,
such as representing coordinates, dates, or other structured data.

Key Differences:

• Lists are mutable, while tuples are immutable.

• Lists use square brackets ‘[]’, while tuples use parentheses ‘()’ .
• Lists have a variety of methods to modify them, while tuples have limited methods
due to their immutability.

Both lists and tuples are important data types in Python, and your choice between them will
depend on whether you need the ability to modify the data or if you want to ensure the data
remains unchanged.

WEEK SEVEN
PYTHON SETS

A set in Python is an unordered collection of unique elements. Sets are used to store multiple
items, but unlike lists or tuples, sets don't allow duplicate values. Sets are created using curly
braces ‘{}’ or the built-in ‘set()’ constructor.

Here's an introduction to working with sets in Python:

Creating Sets:

fruits = {"apple", "banana", "orange"}

numbers = {1, 2, 3, 4, 5}

mixed_set = {1, "hello", 3.14, True}

Adding and Removing Elements:

fruits.add("pear”) # Adds "pear" to the set.

fruits.remove("banana") # Removes "banana" from the set (raises an error if not found)
fruits.discard("banana") # Removes "banana" if present, but doesn't raise an error if not found
fruits.pop() # Removes and returns an arbitrary element from the set

Set Operations: Sets support various operations, such as union, intersection, and difference.

• Union (‘|’): Combines elements from two sets without duplicates.

set1 = {1, 2, 3}
set2 = {3, 4, 5}
union_set = set1 | set2 # Returns {1, 2, 3, 4, 5}
 • Intersection (‘&’): Returns elements that are common in both sets.

intersection_set = set1 & set2 # Returns {3}

• Difference (‘-‘): Returns elements in the first set but not in the second set.

difference_set = set1 - set2 # Returns {1, 2}

• Symmetric Difference (‘^’): Returns elements that are in either of the sets, but not in
both.

symmetric_difference_set = set1 ^ set2 # Returns {1, 2, 4, 5}

Membership and Set Operations:

"apple" in fruits # Checks if "apple" is in the set (returns True or False)

set1.issubset(set2) # Checks if set1 is a subset of set2 (returns True or False)
set1.union(set2) # Returns a new set with elements from both set1 and set2 (no duplicates)
set1.intersection(set2) # Returns a new set with common elements

Sets are particularly useful when you want to maintain a collection of unique elements and
perform operations like intersection, union, and difference. They are often used for tasks
involving membership testing and handling distinct items in a dataset.

WEEK EIGHT
PYTHON DICTIONARIES

A dictionary in Python is an unordered collection of key-value pairs. Each

key is unique and associated with a value. Dictionaries are created using
curly braces ‘{}’ and key-value pairs separated by colons ‘:’.

Here's an overview of working with dictionaries in Python:

Creating Dictionaries:

person = {
"name": "Alice",
"age": 30,
"city": "New York"
}

grades = {
 "math": 95,
"science": 85,
"history": 70
}

Accessing and Modifying Values: You can access values in a dictionary by

referring to the key.

name = person["name”] # Access the value associated with the key "name"

person["age"] = 31 # Modify the value associated with the key "age"

Adding and Removing Key-Value Pairs:

person["occupation"] = "Engineer” # Adds a new key-value pair

del person["city”] # Removes the key-value pair with the key "city"

Dictionary Methods:

• ‘keys()’, ‘values()’, ‘items()’:

These methods return views of the keys,
values, and key-value pairs in the dictionary, respectively.

keys = person.keys() # Returns a view of keys

values = person.values() # Returns a view of values
items = person.items() # Returns a view of key-value pairs

• ‘get()’: Retrieves the value associated with a key. If the key doesn't
exist, it returns a default value (or ‘None’ if not provided).

age = person.get("age") # Returns 31

occupation = person.get("occupation", "Unknown") # Returns "Engineer"

• ‘pop()’: Removes a key-value pair by key and returns the value.

age = person.pop("age”) # Removes the key "age" and returns the value 31

• ‘update()’:
Updates the dictionary with new key-value pairs from
another dictionary.

additional_info = {"hobbies": ["reading", "traveling"]}

person.update(additional_info) # Adds new key-value pairs to the dictionary
Looping Through Dictionaries: You can loop through dictionaries using
‘for’ loops to iterate through keys or key-value pairs.

for key in person:

print(key, person[key])

for key, value in person.items():

print(key, value)

Dictionaries are commonly used to store structured data where each piece
of information is associated with a specific key. They are particularly useful
when you want to quickly access values using a descriptive label (the key)
rather than an index.

WEEK NINE
PYTHON CONDITIONS

Conditions in Python are used to control the flow of a program based on whether certain
conditions are met or not. Python provides various conditional statements and control
structures to implement conditions. Here's an overview of how conditions work in Python:

If Statement: The basic building block of conditions is the if statement. It allows you to
execute a block of code if a specified condition is true.

x = 10

if x > 5:
print("x is greater than 5")

If-Else Statement: You can extend the if statement with an else block to execute different
code when the condition is false.

x=3

if x > 5:
print("x is greater than 5")
else:
print("x is not greater than 5")

Elif Statement: The ‘elif’ (short for "else if") statement allows you to check multiple
conditions in a single block.

x=5
if x > 5:
print("x is greater than 5")
elif x == 5:
print("x is equal to 5")
else:
print("x is less than 5")

Nested Conditions: You can nest conditional statements within each other to create more
complex branching logic.

x = 10
y=5

if x > 5:
if y > 2:
print("Both x and y are greater than their respective thresholds.")
else:
print("x is greater than 5, but y is not greater than 2.")
else:
print("x is not greater than 5.")

Logical Operators: Python also provides logical operators (and , or , not) to combine
conditions.

x = 10
y=5

if x > 5 and y > 2:

print("Both conditions are true.")

if x > 5 or y > 2:
print("At least one condition is true.")

if not x > 20:

print("x is not greater than 20.")

Ternary Operator: Python supports a concise way to write conditional expressions using
the ternary operator x if condition else y.

age = 15

status = "minor" if age < 18 else "adult"

print(status) # Output: "minor"

Conditional statements are essential for controlling program execution based on different
conditions, making your code more dynamic and responsive. They are used extensively for
decision-making, error handling, and creating different branches of logic within your code.
WEEK ELEVEN
PYTHON LOOPS

In Python, loops are used to repeat a certain block of code multiple times.
Python provides two main types of loops: for loops and while loops. Here's
an overview of how loops work in Python:

For Loops: A for loop is used to iterate over a sequence (like a list, tuple, or
string) or other iterable objects. It runs a block of code a fixed number of
times, iterating through each element in the sequence.

fruits = ["apple", "banana", "cherry"]

for fruit in fruits:

print(fruit)

You can also use the range() function to generate a sequence of numbers
and iterate over it:

for i in range(5):
print(i) # Output: 0, 1, 2, 3, 4

While Loops: A while loop is used to execute a block of code repeatedly as

long as a given condition is true.

count = 0

while count < 5:

print(count)
count += 1

Loop Control Statements:

• break: Terminates the loop prematurely.

for i in range(10):
if i == 5:
break
print(i) # Output: 0, 1, 2, 3, 4
 • continue: Skips the rest of the current iteration and moves to the next
iteration.

for i in range(5):
if i == 2:
continue
print(i) # Output: 0, 1, 3, 4

• else with Loops: The else block can be used with loops to execute
code after the loop finishes normally (without encountering a break
statement).

for i in range(5):
print(i)
else:
print("Loop finished")

Nested Loops: You can nest one loop inside another to create complex
iterations.

for i in range(3):
for j in range(2):
print(i, j)

Looping Through Containers: Python provides the enumerate() function to

loop through a sequence while tracking the index.

fruits = ["apple", "banana", "cherry"]

for index, fruit in enumerate(fruits):
print(index, fruit)

Infinite Loops: A loop that continues indefinitely until explicitly terminated

is called an infinite loop. You can create one using a while True condition.

while True:
user_input = input("Enter 'quit' to exit: ")
if user_input == 'quit':
break
Loops are essential for automating repetitive tasks and processing
sequences of data. They allow you to efficiently execute the same block of
code multiple times, enhancing the functionality and interactivity of your
programs.

SECOND TERM

WEEK ONE

Python Functions

A function is a block of code that is executed when it is called. Functions can be

used to perform a specific task, such as calculating the Fibonacci sequence or
finding the maximum value in a list.

Functions are a powerful tool that can help you to write more organized and reusable
code. They can also help to improve the readability and maintainability of your code.

In Python, a function is a reusable block of code that performs a specific

task or set of tasks. Functions are fundamental to modular programming,
allowing you to break down complex problems into smaller, more
manageable pieces. Here's a comprehensive guide to Python functions:

Function Syntax
In Python, you define a function using the def keyword, followed by the
function name, a pair of parentheses (), and a colon :. The function body is
indented, and it contains the code to be executed when the function is
called.

def my_function():
# Function body
print("Hello, world!")

Function Calling
To execute a function, you call it by its name followed by parentheses ().

my_function() # Calling the function

Function Parameters
Functions can accept parameters (also known as arguments), which are
values that the function can use when it's called. Parameters are defined
inside the parentheses when declaring the function.

def greet(name):
print(f"Hello, {name}!")

greet("Alice") # Calling the function with an argument

Return Statement
Functions can return values using the return statement. This allows you to
compute a result inside the function and pass it back to the caller.

def add(a, b):

result = a + b
return result

sum_result = add(5, 3)
print(sum_result) # Output: 8

Default Parameters
You can provide default values for function parameters. If a value is not
provided when calling the function, it will use the default.

def greet(name="Guest"):
print(f"Hello, {name}!")

greet() # Output: Hello, Guest!

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

Variable Scope
Variables defined inside a function have local scope, meaning they are only
accessible within that function. Variables defined outside of any function
have global scope and can be accessed from anywhere in the program.

global_variable = "I'm global"

def my_function():
local_variable = "I'm local"
 print(global_variable) # Accessing a global variable
print(local_variable) # Accessing a local variable

my_function()
print(global_variable) # Still accessible
# print(local_variable) # This would result in an error; local_variable is not defined
here

Docstrings
It's good practice to include docstrings (documentation strings) in your
functions to explain their purpose and usage. Docstrings are enclosed in
triple quotes """.

def add(a, b):

"""
This function adds two numbers and returns the result.
"""
result = a + b
return result

Lambda Functions (Anonymous Functions)

Python supports lambda functions, which are small, anonymous functions
defined using the lambda keyword. They are often used for short, simple
operations.

square = lambda x: x ** 2
print(square(4)) # Output: 16

Function Decorators
Python allows you to use function decorators to modify or enhance the
behavior of functions. Decorators are typically used for tasks like logging,
authentication, or modifying the return value of a function.

def my_decorator(func):
def wrapper():
print("Something is happening before the function is called.")
func()
print("Something is happening after the function is called.")
return wrapper
@my_decorator
def say_hello():
print("Hello!")

say_hello()

Recursion
A function can call itself, a behavior known as recursion. Recursive functions
are useful for solving problems that can be broken down into smaller
instances of the same problem.

def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n - 1)

print(factorial(5)) # Output: 120

Conclusion
Python functions are a fundamental part of Python programming, enabling
you to write reusable and organized code. By understanding function
syntax, parameters, scope, and advanced concepts like decorators and
recursion, you can leverage the power of functions to build complex and
efficient programs.

WEEK TWO
Python Lambda

A lambda function in Python is a small, anonymous function that is

defined using the lambda keyword. Lambda functions can take any number of
arguments but can only have one expression. They are also known as
anonymous functions because they don't have a name like regular
functions defined with def.

The general syntax of a lambda function is:

lambda arguments: expression

Here's a breakdown of the components:

• lambda: The keyword used to define a lambda function.

• arguments: The input parameters or arguments that the function takes.
• expression: The single expression or operation that the function
performs. The result of this expression is implicitly returned.

Lambda functions are often used for short and simple operations, especially
when you need to pass a small function as an argument to another function
(e.g., sorting or filtering data).

Here are some examples to illustrate how lambda functions work:

Example 1: Basic Lambda Function

# A lambda function that adds two numbers
add = lambda x, y: x + y

result = add(5, 3)
print(result) # Output: 8

Example 2: Using Lambda with map()

The map() function applies a given function to all items in an iterable (e.g., a
list) and returns a map object (an iterator). Lambda functions are often used
with map() to apply a simple operation to each element in a list.

numbers = [1, 2, 3, 4, 5]
squared = map(lambda x: x ** 2, numbers)

# Convert the map object to a list for printing

squared_list = list(squared)
print(squared_list) # Output: [1, 4, 9, 16, 25]

Example 3: Using Lambda with filter()

The filter() function filters elements from an iterable based on a given
function. Lambda functions are commonly used with filter() to select
elements that meet specific criteria.
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_numbers = filter(lambda x: x % 2 == 0, numbers)

# Convert the filter object to a list for printing

even_numbers_list = list(even_numbers)
print(even_numbers_list) # Output: [2, 4, 6, 8, 10]

Example 4: Using Lambda for Sorting

Lambda functions can be used as the key argument when sorting lists to
define custom sorting criteria.

students = [
{"name": "Alice", "age": 25},
{"name": "Bob", "age": 22},
{"name": "Charlie", "age": 28},
]

# Sort the list of dictionaries by age using a lambda function

students.sort(key=lambda x: x["age"])

print(students)
# Output:
# [{'name': 'Bob', 'age': 22},
# {'name': 'Alice', 'age': 25},
# {'name': 'Charlie', 'age': 28}]

Lambda functions are concise and convenient for short operations, but for
more complex functions, it's generally better to use regular named
functions defined with def. Lambda functions are best suited for situations
where you need a quick, throwaway function to perform a specific task.

WEEK THREE
Python Arrays

In Python, the most commonly used data structure for storing a collection
of items is the list, rather than an array. Lists in Python are versatile and
flexible, allowing you to store elements of different data types and change
their size dynamically. However, Python also provides an array module in its
standard library for working with arrays. Here's an overview of both lists
and arrays:
Lists in Python:
1. Creation: Lists are created using square brackets [], and you can
initialize them with elements.

my_list = [1, 2, 3, 4, 5]

2. Dynamic Size: Lists can grow or shrink dynamically. You can add
elements to a list using append() or extend() methods, and you can
remove elements using remove() or pop().
my_list.append(6) # Adds 6 to the end
my_list.extend([7, 8]) # Extends the list with [7, 8]
my_list.remove(4) # Removes the first occurrence of 4
my_list.pop() # Removes and returns the last element

3. Mixed Data Types: Lists can contain elements of different data

types.

mixed_list = [1, 'hello', 3.14, True]

4. Slicing: You can access elements in a list using slicing. Lists are zero-
indexed.

my_list[0] # Access the first element (1)

my_list[1:4] # Get elements at index 1, 2, and 3 ([2, 3, 4])

5. List Comprehensions: Python provides list comprehensions for

concise creation and transformation of lists.

squares = [x ** 2 for x in range(1, 6)] # [1, 4, 9, 16, 25]

Arrays in Python (array module):

1. Creation: Arrays are created using the array module, which provides
a more memory-efficient way to store data of a single data type
(unlike lists, which can store mixed data types).

import array
 int_array = array.array('i', [1, 2, 3, 4, 5])

2. Fixed Size: Arrays have a fixed size when created. You cannot change
their size dynamically by adding or removing elements.
3. Single Data Type: Unlike lists, arrays store elements of a single data
type specified when creating the array.
4. Performance: Arrays are more memory-efficient and faster for
certain operations (e.g., numerical computations) compared to lists.
However, this advantage is often negligible for most general-purpose
tasks.
5. Access: Elements in an array are accessed in the same way as lists,
using indexing and slicing.
6. Array Types: The array module supports various data types such as
integers ('i'), floating-point numbers ('f'), and characters ('u'),
among others.

float_array = array.array('f', [3.14, 2.71, 1.618])

In practice, if you need a versatile and dynamic collection, you'll typically

use lists. If you're working with a fixed-size collection of data of the same
type and need to optimize memory usage, then arrays can be useful.
However, for many common tasks, lists are sufficient and more convenient
to work with due to their flexibility.

WEEK FOUR
Python Classes/Objects

In Python, classes and objects are fundamental concepts of object-oriented

programming (OOP). They allow you to model real-world entities and
create reusable, organized code. Here's a comprehensive guide to Python
classes and objects:

Classes:
A class is a blueprint or template for creating objects. It defines the
structure and behavior that objects of the class will have. Classes
encapsulate data (attributes) and functions (methods) that operate on that
data. To define a class in Python, you use the class keyword followed by
the class name:
class MyClass:
# Class attributes and methods go here

Objects (Instances):
An object is an instance of a class, created based on the class's blueprint.
You can create multiple objects from a single class. Each object has its own
data and can call the methods defined in the class. To create an object, you
call the class as if it were a function:

my_object = MyClass() # Creating an instance of MyClass

Attributes:
Attributes are data members or variables that belong to a class or its
instances. They represent the characteristics or properties of objects.
Attributes can be either class attributes (shared by all instances) or instance
attributes (specific to each instance). You define attributes inside the class.

class MyClass:

class_attribute = "I am a class attribute" # Class attribute

def __init__(self, instance_attribute):

self.instance_attribute = instance_attribute # Instance attribute

Methods:
Methods are functions defined inside a class that operate on its data
(attributes). Methods can be class methods (operate on class-level data) or
instance methods (operate on instance-specific data). The self parameter in
instance methods refers to the instance calling the method.

class MyClass:
def instance_method(self):
return "I am an instance method"
 @classmethod
def class_method(cls):
return "I am a class method"

@staticmethod
def static_method():
return "I am a static method"

Constructor (__init__):
The __init__ method is a special method called a constructor. It is used to
initialize instance attributes when an object is created. The self parameter
refers to the instance being created, and you can assign values to instance
attributes inside this method.

class MyClass:
def __init__(self, name, age):
self.name = name
self.age = age

Using Classes and Objects:

Once you've defined a class, you can create objects from it and access
attributes and methods of those objects.

# Creating an object
my_object = MyClass("Alice", 30)

# Accessing attributes
print(my_object.name) # Output: Alice
print(my_object.age) # Output: 30

# Calling methods
result = my_object.instance_method()
print(result) # Output: I am an instance method

Inheritance:
Inheritance allows you to create a new class (subclass or derived class)
based on an existing class (base class or parent class). The subclass inherits
attributes and methods from the base class and can extend or override
them.

class ParentClass:

def method(self):

return "Parent method"

class ChildClass(ParentClass):

def method(self):

return "Child method"

child = ChildClass()

print(child.method()) # Output: Child method

Encapsulation, Abstraction, and Polymorphism:

• Encapsulation: Encapsulation is the concept of bundling data
(attributes) and methods that operate on that data within a class. It
hides the internal details of the class and exposes only what's
necessary.
• Abstraction: Abstraction is the process of simplifying complex
systems by modeling classes with essential characteristics. It allows
you to create abstract classes and methods that provide a blueprint
for subclasses.
• Polymorphism: Polymorphism allows objects of different classes to
be treated as objects of a common superclass. It enables method
overriding and dynamic method dispatch.

Python's support for OOP makes it a versatile and powerful language for
building complex software systems. Classes and objects are central to this
capability, enabling you to create organized, reusable, and maintainable
code.
WEEK FIVE
Python Dates

In Python, you can work with dates and times using the datetime module
from the standard library. The datetime module provides classes and
functions for manipulating dates, times, and time intervals. Here's an
overview of how to work with dates in Python:

Importing the datetime Module

Before you can work with dates, you need to import the datetime module:

import datetime

Current Date and Time

You can obtain the current date and time using the datetime.datetime.now()
method:

current_datetime = datetime.datetime.now()
print(current_datetime)
# Output: 2023-08-24 12:34:56.789012 (This is the date and time you run the code)

Creating a Specific Date

You can create a specific date using the datetime.datetime() constructor,
specifying the year, month, day, hour, minute, second, and microsecond (all
optional):

specific_date = datetime.datetime(2023, 8, 24)

print(specific_date)
# Output: 2023-08-24 00:00:00

specific_datetime = datetime.datetime(2023, 8, 24, 12, 30, 0)

print(specific_datetime)
# Output: 2023-08-24 12:30:00

Date Formatting
To format a datetime object as a string, you can use the strftime() method and
provide a format string:
formatted_date = current_datetime.strftime("%Y-%m-%d %H:%M:%S")
print(formatted_date)
# Output: 2023-08-24 12:34:56

formatted_date_custom = current_datetime.strftime("%A, %d %B %Y")

print(formatted_date_custom)
# Output: Wednesday, 24 August 2023

Parsing Dates from Strings

You can parse dates from strings using the strptime() method and specifying
the format of the input string:

date_string = "2023-08-24"
parsed_date = datetime.datetime.strptime(date_string, "%Y-%m-%d")
print(parsed_date)
# Output: 2023-08-24 00:00:00

Date Arithmetic
You can perform various date arithmetic operations, such as adding or
subtracting days, hours, minutes, etc., to a datetime object:

from datetime import timedelta

# Add 3 days to the current date

new_date = current_datetime + timedelta(days=3)
print(new_date)
# Output: 2023-08-27 12:34:56.789012

# Subtract 1 hour and 30 minutes

new_datetime = specific_datetime - timedelta(hours=1, minutes=30)
print(new_datetime)
# Output: 2023-08-24 11:00:00

Date Comparison
You can compare datetime objects to determine which date or time is earlier
or later:

date1 = datetime.datetime(2023, 8, 24)

date2 = datetime.datetime(2023, 8, 25)
if date1 < date2:
print("date1 is earlier than date2")
else:
print("date2 is earlier than date1")
# Output: date1 is earlier than date2

Time Zones
Python's datetime module does not handle time zones by default. To work
with time zones, you can use external libraries like pytz.

import pytz

# Create a datetime object with a specific time zone

tz = pytz.timezone('US/Eastern')
datetime_with_tz = datetime.datetime.now(tz)
print(datetime_with_tz)

Date and Time Operations

The datetime module provides various functions and methods for performing
date and time operations, including calculating time differences, extracting
specific components (year, month, day, etc.), and more. You can refer to
Python's official documentation for detailed information on these
operations.

Working with dates and times is a common requirement in many Python

applications, whether for scheduling, logging, or data analysis. The datetime
module provides a powerful and flexible way to handle date and time-
related tasks in your Python programs.

WEEK SIX
Python JSON

JSON (JavaScript Object Notation) is a lightweight data interchange

format that is easy for humans to read and write and easy for machines to
parse and generate. In Python, you can work with JSON data using the
built-in json module, which allows you to encode Python objects as JSON
strings and decode JSON strings into Python objects.
Here's a guide on how to work with JSON in Python using the json module:

Importing the json Module

Before you can use the json module, you need to import it:

import json

Encoding (Serializing) Python Objects to JSON

You can convert Python objects, such as dictionaries and lists, into JSON
format using the json.dumps() function (where "dumps" stands for "dump
string"). This process is known as serialization:

data = {
"name": "Alice",
"age": 30,
"city": "New York"
}

# Serialize a Python dictionary to a JSON string

json_string = json.dumps(data)
print(json_string)
# Output: {"name": "Alice", "age": 30, "city": "New York"}

You can also use the indent parameter to format the JSON string for better
readability:

json_string = json.dumps(data, indent=4)

print(json_string)
# Output (formatted with 4 spaces):
#{
# "name": "Alice",
# "age": 30,
# "city": "New York"
#}

Decoding (Deserializing) JSON to Python Objects

You can convert a JSON string back into a Python object using the
json.loads() function (where "loads" stands for "load string"). This process is
known as deserialization:
json_string = '{"name": "Bob", "age": 25, "city": "Los Angeles"}'

# Deserialize a JSON string to a Python dictionary

python_object = json.loads(json_string)
print(python_object)
# Output: {'name': 'Bob', 'age': 25, 'city': 'Los Angeles'}

Working with JSON Files

You can read JSON data from a file and write JSON data to a file using the
json.dump() and json.load() functions:

# Writing JSON data to a file

with open('data.json', 'w') as json_file:
json.dump(data, json_file)

# Reading JSON data from a file

with open('data.json', 'r') as json_file:
loaded_data = json.load(json_file)

print(loaded_data)
# Output: {'name': 'Alice', 'age': 30, 'city': 'New York'}

Handling JSON Errors

When working with JSON, you should handle potential errors, especially
when decoding JSON strings that may be malformed or contain
unexpected data. The json module raises exceptions like json.JSONDecodeError
for such cases.

json_string = '{"name": "Charlie", "age": }'

try:
python_object = json.loads(json_string)
except json.JSONDecodeError as e:
print(f"JSON decoding error: {e}")

Custom JSON Encoding and Decoding

The json module allows you to customize the encoding and decoding
process by providing custom functions to handle specific data types. You
can use the default and object_hook parameters for this purpose.
Working with JSON data is a common task in modern software
development, especially when dealing with web APIs or exchanging data
between different systems. Python's json module provides a straightforward
way to handle JSON data efficiently and reliably.

WEEK SEVEN
Python PIP

pip is a package manager for Python that allows you to easily install,
manage, and remove Python packages (libraries and modules) from the
Python Package Index (PyPI) and other package repositories. It's a powerful
tool for managing Python dependencies and is typically included with
Python installations from version 3.4 and higher.

Here's a guide on how to use pip to manage Python packages:

1. Installing Packages
To install a Python package using pip, open your command-line interface
(terminal or command prompt) and run the following command:

pip install package_name

Replace package_name with the name of the package you want to install. For
example, to install the popular package requests, you would run:

pip install requests

This command will download and install the package and its dependencies.

2. Verifying Installed Packages

To verify which packages are installed in your Python environment, you can
use the pip list command:

pip list

This command will list all the packages installed in your Python
environment, along with their versions.

3. Uninstalling Packages
To uninstall a package, you can use the pip uninstall command followed by
the package name:

pip uninstall package_name

For example, to uninstall the requests package, you would run:

pip uninstall requests

4. Updating Packages
To update a package to the latest version available on PyPI, you can use the
pip install --upgrade command:

pip install --upgrade package_name

For example, to update the requests package, you would run:

pip install --upgrade requests

5. Requirements Files
You can create a requirements file to list all the packages your project
depends on, along with their versions. This makes it easy to recreate the
same environment on another system or share your project's dependencies.
To generate a requirements file, you can use the pip freeze command:

pip freeze > requirements.txt

To install all the packages listed in a requirements file, you can use the -r
option:

pip install -r requirements.txt

6. Searching for Packages

You can search for Python packages available on PyPI using the pip search
command:

pip search search_term

Replace search_term with the term you want to search for. For example, to
search for packages related to web scraping, you would run:

pip search web scraping

7. Using Virtual Environments

It's a good practice to create virtual environments for your Python
projects to isolate their dependencies. You can create a virtual environment
using the venv module (available in Python 3.3 and later) or the virtualenv
tool. Here's how to create a virtual environment using venv:

# Create a virtual environment

python -m venv myenv

# Activate the virtual environment (on Windows)

myenv\Scripts\activate

# Activate the virtual environment (on macOS and Linux)

source myenv/bin/activate

Once activated, you can use pip to install packages in the virtual
environment without affecting the global Python installation.

8. Common pip Options

• --user: Install packages only for the current user (no need for
administrator privileges).
• --proxy=http://proxy.example.com:port: Specify a proxy server for
downloading packages.
• --no-cache-dir : Prevent using cached files.
• --no-binary: Force building from source (useful for packages with
binary components).

Always exercise caution when using pip, especially if you have administrative
privileges, to avoid accidentally modifying or deleting system packages.
Virtual environments can help isolate your project dependencies and
minimize conflicts.
WEEK EIGHT
File Handling Open, Read, Write, Create and Delete Files

Working with files in Python involves several fundamental operations,

including opening, reading, writing, creating, and deleting files. Here's a
guide on how to perform these operations:

1. Opening and Closing Files

Before you can perform operations on a file, you need to open it using the
open() function. The open() function takes two arguments: the file name
(including the path) and the mode in which you want to open the file.
Common file modes include:

• 'r': Read (default mode). Opens the file for reading.

• 'w': Write. Opens the file for writing (creates a new file or truncates
an existing one).
• 'a': Append. Opens the file for writing (creates a new file or appends
to an existing one).
• 'b': Binary mode. Used in combination with other modes (e.g., 'rb',
'wb' ) for binary files.

After you're done with a file, it's essential to close it using the close()
method.

# Opening a file in read mode

file = open('example.txt', 'r')

# Reading the file contents

content = file.read()
print(content)

# Closing the file

file.close()

A safer way to open and close files is to use the with statement (context
manager), which automatically closes the file when you're done:

with open('example.txt', 'r') as file:

content = file.read()
print(content) # File is automatically closed when the block is exited
2. Reading Files
To read the contents of a file, you can use various methods provided by file
objects:

• read(): Reads the entire file as a single string.

• readline(): Reads the next line from the file.
• readlines() : Reads all lines from the file into a list.

with open('example.txt', 'r') as file:

content = file.read()
print(content)

# Reading line by line

with open('example.txt', 'r') as file:
for line in file:
print(line)

3. Writing to Files
To write data to a file, open it in write ('w' ) or append ('a' ) mode, then use
the write() method to write content to the file. Be cautious when using write
mode ('w') as it overwrites the file's existing content.

# Writing to a file (creates or overwrites)

with open('new_file.txt', 'w') as file:
file.write('Hello, world!\n')
file.write('This is a new file.\n')

# Appending to a file (creates or appends)

with open('new_file.txt', 'a') as file:
file.write('Appending to the file.\n')

4. Creating and Deleting Files

To create a new file, open it in write ('w') mode. If the file already exists, it
will be overwritten. To create an empty file, open it in write mode and close
it immediately:

# Creating a new empty file

with open('new_empty_file.txt', 'w'):
 pass

To delete a file, you can use the os.remove() function from the os module:

import os

file_to_delete = 'file_to_delete.txt'
if os.path.exists(file_to_delete):
os.remove(file_to_delete)
else:
print("The file does not exist.")

5. File Handling Best Practices

• Always close files after you're done with them to free up system
resources.
• Use the with statement to ensure files are properly closed.
• Be cautious when opening files in write ('w') mode, as it can
overwrite existing content.
• Use try-except blocks to handle exceptions when working with files,
especially when reading or writing to them.

File handling is a fundamental aspect of programming, and Python

provides robust tools for performing these operations efficiently and safely.

THIRD TERM

WEEK ONE
Python Modules

In Python, a module is a file that contains Python code, including functions, variables, and
classes, that can be reused in other Python scripts. Modules are a fundamental concept in
Python, allowing you to organize and encapsulate code for better maintainability and
reusability.

Here's a guide on how to create, import, and use Python modules:

Creating a Python Module

1. Create a Python File: Start by creating a new Python file with a .py extension. This
file will serve as your module.
Example: my_module.py
2. Write Code in the Module: Add functions, variables, or classes to the module file.
Here's an example module containing a function and a variable:
# my_module.py

def greet(name):
return f"Hello, {name}!"

message = "Welcome to my module"

Importing a Python Module

Once you have created a module, you can import and use it in other Python scripts or
modules. There are several ways to import modules:

1. Import the Entire Module:

import my_module

result = my_module.greet("Alice")
print(result) # Output: Hello, Alice!

print(my_module.message) # Output: Welcome to my module

2. Import Specific Functions or Variables:

You can import specific functions or variables from a module using the from
keyword.

from my_module import greet

result = greet("Bob")
print(result) # Output: Hello, Bob!

3. Import with an Alias:

You can import a module with an alias (a custom name) using the as keyword. This
can be helpful for modules with long names or to avoid naming conflicts.

import my_module as mm

result = mm.greet("Charlie")

print(result) # Output: Hello, Charlie!

Module Search Path

Python searches for modules in specific directories defined by the module search path.
When you import a module, Python searches for it in the following order:

1. The current directory.

2. Directories specified in the PYTHONPATH environment variable.
 3. The standard library directories.

Standard Library Modules

Python comes with a rich standard library that includes a wide range of modules for various
tasks. These modules can be imported and used in your scripts without needing to install
external packages. Some common standard library modules include os , math, datetime, and
json.

Creating Your Own Packages

If your project involves multiple related modules, you can organize them into a package. A
package is a directory that contains multiple Python module files and an __init__.py file. The
__init__.py file can be empty or contain initialization code for the package.

my_package/
__init__.py
module1.py
module2.py

To import modules from a package, you can use dot notation:

from my_package import module1

result = module1.some_function()

Python modules and packages are essential for structuring and managing code in larger
projects, as they promote code reuse and maintainability. By encapsulating related code into
modules and packages, you can create more organized and modular Python applications.

WEEK TWO
Numpy

NumPy (Numerical Python) is a powerful Python library for numerical and mathematical
operations. It provides support for large, multi-dimensional arrays and matrices, along with a
vast collection of high-level mathematical functions to operate on these arrays. NumPy is a
fundamental library for data manipulation and scientific computing in Python.

Here are some key aspects of NumPy and how to use it:

1. Installing NumPy
NumPy is not included in the Python standard library, so you need to install it separately
using a package manager like pip. In your command-line interface, run the following
command:

pip install numpy

2. Importing NumPy
After installing NumPy, you can import it into your Python script or interactive session:

import numpy as np

It's a common convention to import NumPy with the alias np for brevity.

3. NumPy Arrays
At the core of NumPy is the numpy.ndarray (array) object. NumPy arrays are similar to
Python lists, but they have some distinct features:

• Homogeneous Data: NumPy arrays store elements of the same data type, unlike
Python lists, which can store mixed data types.
• Fixed Size: The size of a NumPy array is fixed upon creation, and you cannot change
it dynamically.
• Efficient: NumPy arrays are more memory-efficient and faster than Python lists for
numerical computations.

You can create NumPy arrays in various ways:

# Creating an array from a Python list

my_list = [1, 2, 3, 4, 5]

my_array = np.array(my_list)

# Creating arrays with predefined values

zeros = np.zeros(5) # Array of zeros

ones = np.ones(5) # Array of ones

rand = np.random.rand(5) # Array of random values

4. Array Operations
NumPy provides a wide range of mathematical and logical operations for arrays:

# Arithmetic operations
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
result = a + b

# Element-wise operations
squared = np.square(a)
sum_of_elements = np.sum(a)
mean_value = np.mean(a)

# Indexing and slicing

subset = a[1:3]

# Matrix operations
matrix_a = np.array([[1, 2], [3, 4]])
matrix_b = np.array([[5, 6], [7, 8]])
matrix_product = np.dot(matrix_a, matrix_b)

5. NumPy Functions
NumPy includes a plethora of mathematical and statistical functions:

# Trigonometric functions
sin_values = np.sin(np.pi / 2)
cos_values = np.cos(np.pi / 4)

# Exponential and logarithmic functions

exp_values = np.exp(2)
log_values = np.log(10)

# Statistics functions
mean = np.mean([1, 2, 3, 4, 5])
std_deviation = np.std([1, 2, 3, 4, 5])

# Linear algebra functions

eigenvalues, eigenvectors = np.linalg.eig(matrix_a)

6. Broadcasting
NumPy allows you to perform operations on arrays of different shapes through broadcasting,
which automatically expands smaller arrays to match the shape of larger ones. This makes it
easier to work with arrays of different dimensions.

7. NumPy for Data Analysis

NumPy is often used in combination with other libraries like Pandas and Matplotlib for data
analysis and visualization. Pandas provides high-level data structures for data manipulation,
while Matplotlib is used for creating plots and charts.

NumPy is a fundamental library for scientific computing and data analysis in Python. It's an
essential tool for tasks involving numerical data, linear algebra, statistics, and more. By
mastering NumPy, you can efficiently handle large datasets and perform complex
mathematical operations in Python.
WEEK THREE
Pandas

Pandas is a powerful Python library for data manipulation and analysis. It provides easy-to-
use data structures (primarily DataFrame and Series objects) and functions to work with
structured data, making it an essential tool for data scientists, analysts, and engineers working
with tabular data. Pandas is built on top of the NumPy library and integrates well with other
data analysis libraries like Matplotlib and Scikit-Learn.

Here's an overview of Pandas and how to use it:

1. Installing Pandas
You can install Pandas using pip:

pip install pandas

2. Importing Pandas
After installation, you can import Pandas into your Python script or Jupyter Notebook:

import pandas as pd

The common convention is to import Pandas with the alias pd for brevity.

3. Data Structures in Pandas

Pandas provides two primary data structures for handling data:

• DataFrame: A 2D table with rows and columns, similar to a spreadsheet or SQL

table. It can hold various data types and is suitable for most tabular data.
• Series: A 1D labeled array capable of holding any data type. It is similar to a single
column or row in a DataFrame.

4. Creating DataFrames and Series

Creating DataFrames:
You can create a DataFrame from various data sources, including dictionaries, lists, NumPy
arrays, CSV files, Excel files, and more:

import pandas as pd

# From a dictionary
data = {'Name': ['Alice', 'Bob', 'Charlie'],
'Age': [25, 30, 35]}
df = pd.DataFrame(data)

# From a CSV file

df = pd.read_csv('data.csv')
Creating Series:
You can create a Series from a list, NumPy array, or dictionary:

import pandas as pd

# From a list
my_list = [1, 2, 3, 4, 5]
series = pd.Series(my_list)

# From a dictionary
data = {'Alice': 25, 'Bob': 30, 'Charlie': 35}
series = pd.Series(data)

5. Viewing Data
Pandas provides methods for quickly inspecting and understanding your data:

• df.head(): Shows the first few rows of the DataFrame (default is 5 rows).
• df.tail(): Shows the last few rows of the DataFrame.
• df.shape: Returns the dimensions (rows, columns) of the DataFrame.
• df.info(): Provides information about the DataFrame, including data types and missing
values.
• df.describe(): Generates summary statistics for numerical columns.

6. Indexing and Slicing

You can access and manipulate data in DataFrames using various indexing methods:

# Accessing columns by name

ages = df['Age']

# Accessing multiple columns

subset = df[['Name', 'Age']]

# Slicing rows by position

df_slice = df[1:3]

# Slicing rows by condition

young_people = df[df['Age'] < 30]

7. Data Cleaning and Transformation

Pandas allows you to perform various data cleaning and transformation tasks:

• Handling missing data using methods like dropna() and fillna().

• Renaming columns using the rename() method.
• Creating new columns based on existing columns.
• Applying functions to data using apply() and map().
• Grouping and aggregating data using groupby().
8. Data Visualization
Although Pandas itself doesn't handle data visualization, it integrates well with libraries like
Matplotlib and Seaborn for creating plots and charts based on your data.

9. Data I/O
Pandas supports a wide range of data input and output formats, including CSV, Excel, SQL
databases, JSON, and more. You can use functions like read_csv(), to_csv() , read_excel(),
to_excel(), and read_sql() to work with these formats.

Pandas is an invaluable tool for data manipulation, cleaning, and analysis in Python. It
simplifies many complex data tasks and is a foundational library for any data-related project
in Python.

WEEK FOUR
scipy

SciPy is an open-source library in Python used for high-level computations and data analysis.
It builds on the functionality provided by NumPy and provides additional tools for scientific
and technical computing. SciPy is organized into sub-packages that focus on specific
scientific domains, including optimization, integration, interpolation, signal processing, linear
algebra, statistics, and more.

Here's an overview of SciPy's capabilities and how to use it:

1. Installing SciPy
You can install SciPy using pip, typically alongside NumPy:

pip install scipy

2. Importing SciPy
Once installed, you can import SciPy and its sub-packages into your Python scripts or
notebooks:

import scipy

3. Key Sub-Packages in SciPy

SciPy is organized into several sub-packages, each focusing on specific scientific and
technical computing tasks. Some of the key sub-packages include:

• scipy.optimize: Tools for optimization, including minimization and root-finding

algorithms.
 • scipy.integrate: Functions for numerical integration and solving ordinary differential
equations.
• scipy.interpolate: Interpolation and smoothing functions for working with data.
• scipy.signal: Signal processing functions for filtering, convolution, and spectral
analysis.
• scipy.linalg: Linear algebra functions that extend NumPy's capabilities.
• scipy.stats: Statistical functions and probability distributions.
• scipy.special: Special functions, such as Bessel functions and gamma functions.
• scipy.spatial: Spatial data structures and algorithms, including distance metrics and
spatial indexing.

4. Using SciPy Functions

Let's look at a few examples of how you can use SciPy functions:

Example 1: Numerical Integration

from scipy.integrate import quad

# Define a function to integrate

def integrand(x):
return x**2

# Perform numerical integration

result, error = quad(integrand, 0, 1)
print(f"Result: {result}, Error: {error}")

Example 2: Optimization

from scipy.optimize import minimize

# Define an objective function to minimize

def objective(x):
return x[0]**2 + x[1]**2

# Initial guess
initial_guess = [1, 1]

# Perform optimization
result = minimize(objective, initial_guess, method='BFGS')
print(f"Optimal solution: {result.x}")

Example 3: Interpolation

import numpy as np
from scipy.interpolate import interp1d

# Define some data points

x = np.array([0, 1, 2, 3, 4])
y = np.array([0, 1, 4, 9, 16])

# Create an interpolation function

f = interp1d(x, y, kind='linear')

# Interpolate values
x_new = 2.5
y_new = f(x_new)
print(f"Interpolated value at {x_new}: {y_new}")

These are just a few examples of the many capabilities offered by SciPy. Depending on your
specific scientific or engineering task, you can explore the appropriate sub-packages and
functions within SciPy to perform advanced computations and analyses.

SciPy is widely used in fields like physics, engineering, biology, and data science, making it
an essential library for a wide range of scientific and technical applications in Python.
WEEK FIVE

scikit-learn

scikit-learn, often abbreviated as sklearn, is an open-source machine

learning library for Python. It provides simple and efficient tools for data
analysis and modeling, including a wide range of machine learning
algorithms, model selection, feature extraction, data preprocessing, and
evaluation methods. scikit-learn is widely used for tasks like classification,
regression, clustering, dimensionality reduction, and more.

Here's an overview of scikit-learn and how to use it:

1. Installing scikit-learn
You can install scikit-learn using pip:

pip install scikit-learn

2. Importing scikit-learn
After installing, you can import scikit-learn into your Python scripts or
notebooks:

import sklearn

3. Key Features and Components

Estimators
In scikit-learn, machine learning models are represented as estimators. An
estimator is any object that learns from data; it may be a classification
algorithm, regression algorithm, clustering algorithm, or any other model.
All estimators in scikit-learn follow a consistent API with methods like fit(),
predict(), and score() .

Transformers
Transformers are a subset of estimators that perform data
transformations. They can be used for tasks like feature scaling,
dimensionality reduction, and more. Transformers are often used in
combination with estimators to preprocess data before modeling.

Datasets
scikit-learn provides several datasets for practice and experimentation. You
can load datasets directly from scikit-learn or use external data sources.

4. Common Machine Learning Tasks

Classification
Classification is the task of predicting a discrete target variable (class label).
scikit-learn provides various classification algorithms, including decision
trees, random forests, support vector machines, and more.

from sklearn.datasets import load_iris

from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier

# Load the Iris dataset

data = load_iris()
X, y = data.data, data.target

# Split the dataset into training and testing sets

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Create and train a Decision Tree Classifier

clf = DecisionTreeClassifier()
clf.fit(X_train, y_train)

# Make predictions on the test set

y_pred = clf.predict(X_test)
# Evaluate the classifier's performance
from sklearn.metrics import accuracy_score
accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy}")
Regression
Regression is the task of predicting a continuous target variable. scikit-learn
provides regression algorithms like linear regression, random forests, and
support vector regression.

Clustering
Clustering is the task of grouping similar data points together. scikit-learn
offers clustering algorithms such as K-means clustering and hierarchical
clustering.

Dimensionality Reduction
Dimensionality reduction techniques like Principal Component Analysis
(PCA) and t-Distributed Stochastic Neighbor Embedding (t-SNE) are
available in scikit-learn to help with visualization and feature selection.

5. Model Selection and Evaluation

scikit-learn provides tools for model selection, including cross-validation,
hyperparameter tuning, and model evaluation metrics. You can use
functions like GridSearchCV and cross_val_score to fine-tune your models
and assess their performance.

from sklearn.model_selection import GridSearchCV

# Define a parameter grid for hyperparameter tuning

param_grid = {
'C': [0.1, 1, 10],
'kernel': ['linear', 'rbf']
}

# Create a GridSearchCV object

grid_search = GridSearchCV(SVC(), param_grid, cv=5)

# Fit the model to the data and perform cross-validation

grid_search.fit(X, y)
# Get the best hyperparameters and estimator
best_params = grid_search.best_params_
best_estimator = grid_search.best_estimator_

6. Pipelines
Pipelines in scikit-learn allow you to combine transformers and estimators
into a single workflow. This is useful for creating a sequence of data
preprocessing steps followed by model training.

from sklearn.pipeline import Pipeline

from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC

# Create a pipeline with data scaling and support vector machine classifier
pipe = Pipeline([
('scaler', StandardScaler()),
('svm', SVC())
])

# Fit the pipeline to the data

pipe.fit(X_train, y_train)

# Make predictions
y_pred = pipe.predict(X_test)

scikit-learn is a versatile library that is widely used for machine learning

tasks and provides a consistent and user-friendly API for various modeling
and data preprocessing tasks. It is a valuable tool for both beginners and
experienced machine learning practitioners.

WEEK SIX
Matplotlib

Matplotlib is a popular and widely-used Python library for creating static,

animated, and interactive visualizations in a wide range of formats and
styles. It provides a comprehensive set of tools for creating various types of
plots and charts, making it an essential library for data visualization,
scientific plotting, and creating publication-quality graphics.

Here's an overview of Matplotlib and how to use it:

1. Installing Matplotlib
You can install Matplotlib using pip:

pip install matplotlib

2. Importing Matplotlib
After installation, you can import Matplotlib into your Python scripts or
notebooks:

import matplotlib.pyplot as plt

The common convention is to import Matplotlib with the alias plt for
brevity.

3. Basic Plotting
Matplotlib allows you to create a wide variety of plots, including line plots,
scatter plots, bar plots, histograms, pie charts, and more. Here's a simple
example of creating a line plot:

import matplotlib.pyplot as plt

# Sample data
x = [1, 2, 3, 4, 5]
y = [2, 4, 6, 8, 10]

# Create a line plot

plt.plot(x, y)

# Add labels and a title

plt.xlabel('X-axis')
plt.ylabel('Y-axis')
plt.title('Simple Line Plot')

# Show the plot

plt.show()

4. Customizing Plots
Matplotlib provides extensive customization options for plots, including
setting colors, markers, line styles, legends, and more. You can customize
various aspects of the plot using functions like plot(), xlabel(), ylabel(),
title(), and many others.

5. Creating Multiple Subplots

You can create multiple subplots within a single figure using the subplot()
function. This allows you to display multiple plots side by side or in a grid:

# Create a 2x2 grid of subplots and select the first one

plt.subplot(2, 2, 1)
plt.plot(x, y)
plt.title('Subplot 1')

# Select the second subplot

plt.subplot(2, 2, 2)
plt.scatter(x, y)
plt.title('Subplot 2')

# Select the third subplot

plt.subplot(2, 2, 3)
plt.bar(x, y)
plt.title('Subplot 3')

# Select the fourth subplot

plt.subplot(2, 2, 4)
plt.hist(y)
plt.title('Subplot 4')

# Adjust spacing between subplots

plt.tight_layout()

# Show the figure with subplots

plt.show()

6. Saving Plots
You can save your Matplotlib plots as image files (e.g., PNG, JPEG, PDF)
using the savefig() function:

plt.savefig('my_plot.png')
7. Advanced Features
Matplotlib offers advanced features for creating 3D plots, animations,
interactive plots, and more. For more complex visualizations, you can
explore libraries like Seaborn and Plotly, which are built on top of
Matplotlib and provide higher-level APIs for specific use cases.

8. Learning Resources
To become proficient in Matplotlib, you can explore the official Matplotlib
documentation and various online tutorials and books dedicated to data
visualization in Python.

Matplotlib is a versatile and powerful library for data visualization in Python.

It is widely used in data analysis, scientific research, and other fields where
visualizing data is crucial for understanding patterns and trends.

WEEK SEVEN
Keras

Keras is an open-source, high-level neural networks API written in Python.

It is designed to be user-friendly, modular, and easy to extend, making it a
popular choice for deep learning projects. Keras acts as an interface for
various deep learning frameworks, including TensorFlow, Theano, and
Microsoft Cognitive Toolkit (CNTK). However, since version 2.4.0, Keras has
been integrated directly into TensorFlow as the official high-level API.

Here's an overview of Keras and how to use it:

1. Installing Keras
If you're using TensorFlow 2.x, you don't need to install Keras separately
because it's included as part of TensorFlow. You can install TensorFlow
using pip:

pip install tensorflow

2. Importing Keras
After installing TensorFlow, you can import Keras from within TensorFlow:
import tensorflow as tf
from tensorflow import keras

3. Key Features of Keras

High-Level API
Keras provides a high-level, user-friendly API for defining, training, and
evaluating deep learning models. With Keras, you can create models with
just a few lines of code.

# Example: Creating a simple feedforward neural network

model = keras.Sequential([
keras.layers.Dense(64, activation='relu', input_shape=(784,)),
keras.layers.Dense(10, activation='softmax')
])

Modular and Extensible

Keras is designed to be modular, allowing you to build complex models by
stacking layers. You can easily add layers, activation functions, and custom
loss functions.

Support for Multiple Backends

Keras originally supported multiple backends like TensorFlow, Theano, and
CNTK. However, with its integration into TensorFlow, TensorFlow is now the
primary backend.

4. Building Neural Networks

Keras makes it straightforward to create neural network models. You can
choose from various layer types, including:

• Dense (Fully Connected) Layers

• Convolutional Layers (for image data)
• Recurrent Layers (for sequential data)
• Dropout Layers (for regularization)
• Batch Normalization Layers

Here's an example of a simple feedforward neural network built with Keras:

model = keras.Sequential([
keras.layers.Dense(128, activation='relu', input_shape=(784,)),
 keras.layers.Dropout(0.2),
keras.layers.Dense(10, activation='softmax')
])

5. Compiling and Training Models

Once you've defined your model, you need to compile it with an optimizer,
loss function, and evaluation metric. Then, you can train it on your data
using the fit() method.

model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])

history = model.fit(x_train, y_train, epochs=10, validation_data=(x_val, y_val))

6. Evaluating and Predicting

You can evaluate your model's performance on a test dataset and make
predictions using the evaluate() and predict() methods, respectively.

test_loss, test_acc = model.evaluate(x_test, y_test)

predictions = model.predict(x_new_data)

7. Saving and Loading Models

You can save your trained models in the Hierarchical Data Format (HDF5)
using the save() method and load them using the load_model() function.

model.save('my_model.h5')
loaded_model = keras.models.load_model('my_model.h5')

8. Pretrained Models
Keras provides access to various pretrained deep learning models, such as
VGG, ResNet, and Inception, that you can fine-tune for specific tasks.

9. Learning Resources
To learn more about Keras and deep learning, you can explore the official
TensorFlow documentation, online tutorials, and books dedicated to deep
learning with Keras and TensorFlow.

Keras is an excellent choice for both beginners and experienced deep

learning practitioners due to its user-friendly interface and integration with
TensorFlow, which is one of the most widely used deep learning
frameworks.

WEEK EIGHT
Tensorflow

TensorFlow is an open-source machine learning framework developed by

the Google Brain team. It is designed to facilitate the development and
deployment of machine learning models, particularly deep learning models,
for various tasks such as classification, regression, natural language
processing, computer vision, and more. TensorFlow is known for its
flexibility, scalability, and support for both research and production-level
applications.

Here's an overview of TensorFlow and how to use it:

1. Installing TensorFlow
You can install TensorFlow using pip. There are two major versions of
TensorFlow:

• TensorFlow 2.x: The latest version that includes an integrated high-

level API called Keras. This version is recommended for most users.
• TensorFlow 1.x: An older version that has a slightly different API.
While it is still used in some legacy projects, it's recommended to
migrate to TensorFlow 2.x if possible.

To install TensorFlow 2.x, use the following command:

pip install tensorflow

2. Importing TensorFlow
After installation, you can import TensorFlow into your Python scripts or
notebooks:

import tensorflow as tf

3. Key Features of TensorFlow

Computational Graph
TensorFlow uses a computational graph to represent and perform
computations. In this graph, nodes represent mathematical operations, and
edges represent the flow of data between operations. This graph-based
approach allows for distributed computing and optimization of operations.

Tensors
Tensors are the fundamental data structures in TensorFlow. They are multi-
dimensional arrays that can hold both numerical data and other types of
data. Tensors flow through the computational graph, making it possible to
perform operations on them efficiently.

Eager Execution
TensorFlow 2.x introduced eager execution, which allows you to evaluate
operations immediately as they are called, similar to NumPy. This makes
TensorFlow code more intuitive and easier to debug.

Keras Integration
As of TensorFlow 2.0, Keras has been integrated as the official high-level
API for defining and training deep learning models. This simplifies the
process of building and training neural networks.

GPU and TPU Support

TensorFlow supports running computations on GPUs (Graphics Processing
Units) and TPUs (Tensor Processing Units), which significantly accelerate
training deep learning models.

4. Building and Training Models

Here's a basic example of how to create, compile, and train a deep learning
model in TensorFlow 2.x using Keras:

import tensorflow as tf
from tensorflow import keras
# Define a simple feedforward neural network
model = keras.Sequential([
keras.layers.Dense(64, activation='relu', input_shape=(784,)),
keras.layers.Dropout(0.2),
keras.layers.Dense(10, activation='softmax')
])

# Compile the model with an optimizer, loss function, and metrics

model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])

# Load and preprocess your data (x_train, y_train)

# ...

# Train the model

model.fit(x_train, y_train, epochs=10, validation_data=(x_val, y_val))

5. Model Deployment
TensorFlow provides tools and libraries for deploying trained models to
various platforms, including mobile devices and the web. TensorFlow
Serving is a dedicated system for serving machine learning models in
production.

6. Serving Models with TensorFlow Serving

# Install TensorFlow Serving
docker pull tensorflow/serving

# Start a TensorFlow Serving container

docker run -p 8501:8501 --name=tf_model_serving --mount
type=bind,source=/path/to/your/model/directory,target=/models/your_model -e
MODEL_NAME=your_model -t tensorflow/serving

7. Learning Resources
To learn more about TensorFlow, you can explore the official TensorFlow
documentation, tutorials, and online courses. TensorFlow has a large and
active community, so there are many resources available for both beginners
and experienced users.
TensorFlow is widely used in machine learning research and industry
applications, making it a valuable tool for building, training, and deploying
machine learning models. It supports a wide range of applications and has
extensive support for deep learning.