Python Bootcamp: A 6 Week Learning Program

Welcome to Python Bootcamp: A Weekly Guide, your ultimate guide to mastering Python over the next six weeks. Whether you’re a complete novice or someone with a little coding experience, this bootcamp is designed to take you from the basics to a pro level, equipping you with the skills and knowledge to tackle real-world programming challenges.

Over the course of six weeks, we’ll cover a comprehensive range of topics, from the fundamental building blocks of Python to advanced concepts and practical applications. Each week, we’ll dive deep into different aspects of Python, ensuring a solid understanding and hands-on practice with each topic. By the end of this bootcamp, you’ll have a robust foundation in Python programming and be well-prepared to continue your journey in any Python-related field.

Bootcamp Schedule

Week 1: Basics

• Introduction
• Getting Started
• Syntax
• Comments
• Variables
• Data Types
• Numbers
• Practice Exercises

Week 2: Fundamental Concepts

• Strings
• Booleans
• Operators
• Lists
• Practice Exercises

Week 3: Collections and Control Flow

• Tuples
• Sets
• Dictionaries
• If…Else
• While Loops
• For Loops
• Functions
• Practice Exercises

Week 4: Advanced Concepts

• Lambda
• Arrays
• Classes/Objects
• Inheritance
• Iterators
• Polymorphism
• Scope
• Modules
• Dates

Week 5: Specialized Topics

• Math
• JSON
• RegEx
• PIP
• Error Handling
• User Input
• String Formatting

Week 6: File Handling and Beyond

• File Handling
• Working with External Libraries
• Working with APIs
• Final Practice Project Ideas

Join us on this exciting journey and transform your Python skills from beginner to professional. Let’s embark on this quest to become a proficient Python programmer together!

WEEK 1:

Welcome to the first week of Python Bootcamp: A Weekly Guide! This week, we’ll focus on the fundamental building blocks of Python programming. You’ll learn new concepts and practice them through hands-on exercises. Let’s dive in!

Introduction to Python

What is Python?

Python is a high-level, interpreted programming language known for its readability and simplicity. Created by Guido van Rossum and first released in 1991, Python has evolved into one of the most popular programming languages in the world. It emphasizes code readability with its use of significant indentation and clear syntax, making it accessible for both beginners and experienced developers.

What Can Python Do?

Python is a versatile language with a wide range of applications:

• Web Development: With frameworks like Django and Flask, Python is commonly used to build web applications and services.
• Data Science and Machine Learning: Libraries like Pandas, NumPy, SciPy, and Scikit-Learn make Python a go-to language for data analysis and machine learning.
• Automation: Python’s simplicity allows for easy scripting and automation of repetitive tasks.
• Software Development: Python can be used to develop both desktop and web-based software applications.
• Game Development: Libraries such as Pygame allow for game development in Python.
• Networking: Python’s standard library and external packages support network programming and server-client applications.
• Scientific Computing: Python supports scientific computing with libraries such as Matplotlib for plotting and TensorFlow for deep learning.

Why Python?

Python is chosen by developers for several reasons:

• Readability: Python’s syntax is designed to be easy to read and understand, which improves code quality and maintainability.
• Versatility: Python supports multiple programming paradigms, including procedural, object-oriented, and functional programming.
• Extensive Libraries: Python has a vast ecosystem of libraries and frameworks, reducing the need to reinvent the wheel.
• Community Support: Python has a large and active community, offering extensive documentation, tutorials, and forums.
• Cross-Platform Compatibility: Python runs on various operating systems, including Windows, macOS, and Linux.
• Ease of Learning: Its straightforward syntax makes Python an excellent choice for beginners learning to program.

Good to Know

• Interactive Mode: Python provides an interactive mode that allows you to test code snippets quickly.
• Dynamic Typing: Python is dynamically typed, meaning you don’t need to declare variable types explicitly.
• Garbage Collection: Python handles memory management automatically with its built-in garbage collector.
• Indentation: Python uses indentation to define code blocks, which enforces a clean and consistent coding style.

Python Syntax Compared to Other Programming Languages

Python’s syntax is often compared to other programming languages:

• Compared to C/C++: Python is more concise and readable, using indentation instead of braces {} to define code blocks. It avoids the need for explicit type declarations and pointers.
• Compared to Java: Python has simpler syntax and less boilerplate code. Java requires explicit type declarations and more code to achieve similar functionality.
• Compared to JavaScript: Python is generally used for server-side programming, while JavaScript is used for client-side scripting. Python’s syntax is more consistent and less verbose compared to JavaScript’s.

Python Install

To get started with Python, follow these installation steps:

1. Download Python:
   • Go to the official Python website and download the latest version of Python suitable for your operating system.
2. Run the Installer:
   • For Windows: Run the installer and ensure you check the box “Add Python to PATH” before proceeding.
   • For macOS: Use the .pkg installer and follow the prompts.
   • For Linux: Use your package manager (e.g., sudo apt-get install python3 for Debian-based systems).
3. Verify Installation:
   • Open a terminal or command prompt and type python --version or python3 --version to verify that Python is installed correctly.

Python Version

Python has two major versions: Python 2.x and Python 3.x.

• Python 2.x: The older version, which reached its end of life on January 1, 2020. It is no longer supported or maintained.
• Python 3.x: The latest version, with many improvements and new features. It is recommended for all new projects. Python 3.x introduced several backward-incompatible changes from Python 2.x, so it’s important to use Python 3.x for modern development.

To ensure compatibility and take advantage of the latest features, always use the latest stable release of Python 3.x.

Getting started with Python

At first launch your Python terminal as explained in the above part.

The >>> means that Python is ready and we can enter a command. The basic idea is really simple: we enter a command, press Enter, enter another command, press Enter and keep going.

You probably don’t know any Python commands yet. Let’s see what happens if we just write something and press Enter.

>>> hello

Oops! That didn’t work. But we get an error message that tells us what’s wrong.

Let’s move further.

Maybe we can press Enter without typing anything?

>>>
>>>

That worked. How about numbers?

>>> 123
123
>>> -123
-123
>>> 3.14
3.14
>>> -12.3
-12.3
>>>

As we can see the echoes come back. Hence it worked!

Python Syntax

Python syntax defines the structure and rules for writing Python code. It emphasizes readability and simplicity, making it accessible for both beginners and experienced programmers. Here’s a detailed look at the key aspects of Python syntax:

Indentation

Python uses indentation to define code blocks instead of braces or keywords. Consistent indentation is crucial as it determines the grouping of statements. Indentation levels must be uniform within the same block.

# Example of indentation

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

greet("Alice")

In this example, the print statement is indented to show that it is part of the greet function.

Comments

Comments in Python are used to annotate code, explain its functionality, and improve readability. They are ignored by the Python interpreter and have no effect on the program’s execution. Here’s a detailed look at Python comments:

1. Single-Line Comments

Single-line comments begin with the # symbol. Everything following the # on that line is considered a comment and is not executed.

# This is a single-line comment
print("Hello, World!") # This comment is after a statement

Single-line comments are often used for brief explanations or notes about specific lines of code.

2. Multi-Line Comments

Python does not have a specific syntax for multi-line comments. Instead, multi-line comments are typically created using triple quotes (""" or '''). While these are technically string literals, they are often used for comments when not assigned to a variable.

"""
This is a multi-line comment.
It spans multiple lines.
Python does not have a dedicated multi-line comment syntax, so triple quotes are used.
"""

print("Hello, World!")

Note: If triple quotes are used within code blocks, it’s crucial to understand that Python treats them as string literals. They will not be ignored if used incorrectly.

def example_function():
     """
     This is a docstring, not a multi-line comment.
     Docstrings are used to describe modules, classes, and functions.
     """
pass

Best Practices for Comments

1. Be Clear and Concise: Comments should clearly explain the purpose and functionality of the code. Avoid unnecessary comments that do not add value.
2. Keep Comments Up-to-Date: Ensure that comments accurately reflect the code, especially after modifications.
3. Use Comments to Explain Why, Not What: Focus on why certain decisions were made rather than what the code is doing. The latter should be evident from the code itself.
4. Avoid Over-Commenting: Too many comments can clutter code and make it harder to read. Aim for balance and clarity.

Python Variables

Variables in Python are used to store data that can be referenced and manipulated throughout a program. They are essential for handling data and performing operations. Here’s a detailed look at Python variables:

Defining Variables

Variables in Python are created by assigning a value to a name. Python is dynamically typed, so you don’t need to declare the variable type explicitly. The type is inferred from the value assigned.

# Variable definitions
age = 25 # Integer
name = "John Doe" # String
height = 5.6 # Float
is_student = True # Boolean

print(age, name, height, is_student)

Variable Naming Rules

• Names can include letters (a-z, A-Z), digits (0-9), and underscores (_).
• Names must start with a letter or an underscore, not a digit.
• Names are case-sensitive (e.g., myVar and myvar are different).
• Avoid using Python reserved words (keywords) as variable names.

Example of valid and invalid names:

# Valid variable names
my_var = 10
_var123 = 20
myVar = 30

# Invalid variable names
2nd_var = 40 # Starts with a digit
my-var = 50 # Contains a hyphen
class = 60 # Reserved keyword

Variable Types

Python variables can hold data of various types. Here are some common types:

• Integer: Whole numbers (int)
• Float: Decimal numbers (float)
• String: Text (str)
• Boolean: True or False values (bool)
• List: Ordered, mutable collection (list)
• Tuple: Ordered, immutable collection (tuple)
• Dictionary: Key-value pairs (dict)

These will be our topic of learning for later, for now sharing an example of how they look like:

# Different types of variables
integer_var = 100 # Integer
float_var = 3.14 # Float
string_var = "Hello, Python!" # String
boolean_var = False # Boolean
list_var = [1, 2, 3, 4] # List
tuple_var = (1, 2, 3, 4) # Tuple
dict_var = {"name": "John Doe", "age": 25} # Dictionary

print(integer_var, float_var, string_var, boolean_var)
print(list_var, tuple_var, dict_var)

Variable Assignment and Reassignment

Variables can be assigned a value and then reassigned to a new value. Python allows for multiple variable assignments in a single line.

# Variable assignment
x = 10
y = 5

# Variable reassignment
x = x + y # x is now 15

# Multiple assignment
a, b, c = 1, 2, 3 # Here a=1,b=2 and c = 3

print(x) # Output: 15
print(a, b, c) # Output: 1 2 3

Output Variables

You can use the print() function to output the values of variables. This function is versatile and can handle multiple variables in a single statement.

# Outputting variables
name = "John Doe"
age = 25
height = 5.6

print("Name:", name)
print("Age:", age)
print("Height:", height)

Python Data Types

Python data types define the kind of data that variables can hold. Understanding data types is crucial for effective programming, as it influences how data is stored, manipulated, and processed. This guide covers the fundamental data types in Python, their characteristics, and usage.

Built-in Data Types

Python has several built-in data types that are essential for most programming tasks. These include:

• Integer (int): Represents whole numbers.
• Float (float): Represents decimal numbers.
• String (str): Represents sequences of characters.
• Boolean (bool): Represents True or False.
• List (list): Represents an ordered, mutable collection of items.
• Tuple (tuple): Represents an ordered, immutable collection of items.
• Dictionary (dict): Represents a collection of key-value pairs.
• Set (set): Represents an unordered collection of unique items.
• None (NoneType): Represents the absence of a value.

Here is an example again:

# Integer
num = 10

# Float
price = 99.99

# String
message = "Hello, World!"

# Boolean
is_active = True

# List
numbers = [1, 2, 3, 4, 5]

# Tuple
coordinates = (10, 20)

# Dictionary
person = {"name": "John Doe", "age": 25}

# Set
unique_numbers = {1, 2, 3, 4}

# None
result = None

Understanding and correctly using data types is fundamental to effective programming in Python. Each type has its own properties and methods, and knowing when and how to use them will help you write more efficient and reliable code.

Getting the Data Type

To determine the type of a variable, use the type() function. This function returns the class type of the argument passed to it.

# Integer 
num = 10 

# Float 
price = 99.99 

# String 
message = "Hello, World!" 

# Boolean 
is_active = True 

# List 
numbers = [1, 2, 3, 4, 5] 

# Tuple 
coordinates = (10, 20) 

# Dictionary 
person = {"name": "John Doe", "age": 25} 

# Set 
unique_numbers = {1, 2, 3, 4} 

# None 
result = None

# Getting the type of variables
print(type(num)) # Output: <class 'int'>

print(type(price)) # Output: <class 'float'>

print(type(message)) # Output: <class 'str'>

print(type(is_active)) # Output: <class 'bool'>

print(type(numbers)) # Output: <class 'list'>

print(type(coordinates)) # Output: <class 'tuple'>

print(type(person)) # Output: <class 'dict'>

print(type(unique_numbers)) # Output: <class 'set'>

print(type(result)) # Output: <class 'NoneType'>

You can test the above example above and see the direct outputs.

Type Conversion

You can explicitly convert a variable to a specific data type using built-in functions. This is known as type casting or type conversion.

# Converting between types

# String to Integer
str_num = "123"
int_num = int(str_num)
print(int_num) # Output: 123
print(type(int_num)) # Output: <class 'int'>

# Integer to Float
int_num = 456
float_num = float(int_num)
print(float_num) # Output: 456.0
print(type(float_num)) # Output: <class 'float'>

# Float to String
float_num = 78.9
str_float = str(float_num)
print(str_float) # Output: "78.9"
print(type(str_float)) # Output: <class 'str'>

# List to Tuple
list_data = [1, 2, 3]
tuple_data = tuple(list_data)
print(tuple_data) # Output: (1, 2, 3)
print(type(tuple_data)) # Output: <class 'tuple'>

Practical Usage and Best Practices

1. Understand Type Requirements: Knowing the data types you work with helps ensure that operations and functions behave as expected.
2. Use Type Conversion Wisely: Convert data types when necessary, but be cautious of potential data loss or errors during conversion.
3. Leverage Python’s Dynamic Typing: Python’s flexibility with types can simplify coding, but it also requires careful handling to avoid type-related bugs.

Python Numbers

In Python, numbers are a fundamental data type used for performing arithmetic operations and representing numerical values. There are three numeric types in Python:

Integer (int): Represents whole numbers without a decimal point. Python integers are of arbitrary precision, meaning they can be as large as the memory allows.

age = 25
population = 7830000000

Float (float): Represents floating-point numbers, which are numbers with a decimal point. Floats are represented in double-precision (64-bit) format.

price = 19.99
temperature = -5.5

Complex (complex): Represents complex numbers, which consist of a real part and an imaginary part. The imaginary part is denoted by j.

z1 = 2 + 3j
z2 = -1 - 4j

Understanding Python’s numeric types and their operations will help you perform mathematical calculations and handle numerical data effectively in your programs.

Practice Exercises

• Write a Python script that prints “Hello, World!” to the console.
• Write a Python script that prints your name and your favorite hobby.
• Write a Python script with comments explaining the purpose of each line of code.
• Declare variables of different types and print their values.
• Assign multiple values to variables in one line and print them.
• Convert a string to an integer and a float, and print the results.

These exercises should help you get comfortable with Python basics and prepare you for more complex topics.

Note: Solutions will be available by the end of this week, so make sure you practice before to tally your work and understanding. 

Solution

You can follow to github branch:
https://github.com/shahzaibkhan/6WeeksPythonBootCamp/

WEEK 2:

Welcome to Week 2 of our Python Bootcamp! After getting your feet wet with Python basics in Week 1, we’re now ready to dive into some of the fundamental concepts that form the backbone of Python programming. This week is all about understanding and manipulating data, as well as getting a grip on the various types and structures that Python offers.

What’s in Store This Week?

Python is a versatile language known for its simplicity and readability, but what makes it truly powerful is its ability to handle data in various forms with ease. Whether you’re working with text, numbers, or collections of items, Python provides the tools you need to manage and manipulate that data efficiently.

• Strings are everywhere in Python programming, and this week you’ll learn how to manipulate them to extract, format, and manage textual data effectively.
• Booleans play a crucial role in decision-making processes within your code. Understanding how to work with true and false values will enable you to write more dynamic and responsive programs.
• Operators in Python allow you to perform calculations, comparisons, and logical operations, laying the groundwork for more complex programming tasks.
• Lists, tuples, and sets are essential data structures that enable you to group items together, manage collections of data, and perform operations like sorting, slicing, and filtering.

By the end of this week, you’ll have a deeper understanding of these core Python concepts and how they are used in real-world programming. Whether you’re handling numbers, strings, or collections, you’ll be equipped with the knowledge and skills to manage data effectively and prepare for more advanced topics in the weeks to come.

Why These Concepts Matter

Understanding these fundamental concepts is crucial for any Python developer. As you progress in your coding journey, you’ll find that these concepts are the building blocks for more complex programs and algorithms. Mastering them will not only make you more proficient in Python but also help you approach problems with a clear and structured mindset.

So, let’s get started! Dive into this week’s lessons with curiosity and determination, and by the end of the week, you’ll be well on your way to becoming a more confident and capable Python programmer.

Python Strings

Strings are one of the most commonly used data types in Python, and they are essential for handling text. In Python, a string is a sequence of characters enclosed in either single quotes (') or double quotes ("). Strings are immutable, meaning that once they are created, their content cannot be changed. However, Python provides a variety of methods and techniques to manipulate strings effectively.

Creating Strings

You can create a string in Python by simply enclosing text in quotes:

# Single quotes
greeting = 'Hello, World!'

# Double quotes
quote = "Python is awesome!"

Python allows both single and double quotes for strings, giving you flexibility, especially when your string contains quotes.

String Operations

Python offers many operations that can be performed on strings:

Concatenation: You can combine strings using the + operator

first_name = "John"
last_name = "Doe"
full_name = first_name + " " + last_name
print(full_name) # Output: John Doe

Repetition: You can repeat a string using the * operator.

laugh = "Ha" * 3
print(laugh) # Output: HaHaHa

Indexing: Strings are indexed starting from 0, allowing you to access specific characters.

word = "Python"
first_letter = word[0]
last_letter = word[-1]
print(first_letter) # Output: P
print(last_letter) # Output: n

Slicing: You can extract a substring by specifying a range of indices.

text = "Hello, World!"
sliced_text = text[7:12]
print(sliced_text) # Output: World

Slicing can be done with the syntax string[start:stop:step]. If step is omitted, it defaults to 1.

Length: You can find the length of a string using the len() function.

message = "Python programming"
print(len(message)) # Output: 18

String Methods

Python provides several built-in methods to manipulate strings:

.upper() and .lower(): Convert the string to uppercase or lowercase.

text = "Python"
print(text.upper()) # Output: PYTHON
print(text.lower()) # Output: python

.strip(): Remove leading and trailing spaces.

spaced_text = " Hello, World! "
print(spaced_text.strip()) # Output: Hello, World!

.replace(): Replace parts of a string with another string.

text = "I love Python"
print(text.replace("love", "like")) # Output: I like Python

.split(): Split a string into a list of substrings.

sentence = "Python is fun"
words = sentence.split()
print(words) # Output: ['Python', 'is', 'fun']

.find(): Find the first occurrence of a substring.

text = "Hello, World!"
position = text.find("World")
print(position) # Output: 7

.startswith() and .endswith(): Check if a string starts or ends with a specific substring.

text = "Python programming"
print(text.startswith("Python")) # Output: True
print(text.endswith("ing")) # Output: True 

String Formatting

String formatting allows you to create dynamic strings by embedding variables or expressions within a string. There are several ways to format strings in Python:

Old-style (%) formatting:

name = "Alice"
age = 25
print("My name is %s and I am %d years old." % (name, age))

str.format() method:

name = "Alice"
age = 25
print("My name is {} and I am {} years old.".format(name, age))

F-strings (Python 3.6+):

name = "Alice"
age = 25
print(f"My name is {name} and I am {age} years old.")

F-strings are the most modern and convenient way to format strings, allowing you to directly embed expressions within string literals.

Escape Characters

Escape characters are used to insert characters that are illegal in a string, such as a newline or tab, or to include quotes inside a string.

• Newline: \n
• Tab: \t
• Backslash: \\
• Quotes: \' or \"

Example:

text = "She said, \"Python is awesome!\"\nAnd then she smiled."
print(text)

Output:

She said, "Python is awesome!"
And then she smiled. 

Multiline Strings

Python allows you to create multiline strings using triple quotes (''' or """).

Example:

message = """This is a multiline
string that spans
several lines."""
print(message)

Output:

This is a multiline
string that spans
several lines. 

Conclusion

Understanding strings is crucial because they are used in almost every Python program. Whether you’re processing text data, creating user interfaces, or building web applications, mastering string manipulation techniques will make your code more effective and versatile. Keep practicing with these concepts, and you’ll find yourself more confident in handling text in Python!

Understanding Python Booleans

Booleans are a fundamental concept in programming, representing the two possible states: True or False. In Python, Boolean values are essential for controlling the flow of your program, making decisions, and performing logical operations.

What is a Boolean?

A Boolean is a data type that can only have one of two values: True or False. These values are often used in conditional statements to determine which blocks of code should be executed.

is_sunny = True
is_raining = False

In Python, True and False are keywords and must be capitalized.

Boolean Expressions

Boolean expressions are expressions that evaluate to a Boolean value (True or False). They are typically used with comparison operators and logical operators.

Comparison Operators: Comparison operators compare two values and return a Boolean value:

x = 10
y = 5

print(x > y) # Output: True
print(x < y) # Output: False
print(x == 10) # Output: True
print(x != y) # Output: True

Logical Operators: Logical operators are used to combine Boolean expressions:

a = True
b = False

print(a and b) # Output: False
print(a or b) # Output: True
print(not a) # Output: False

Note:

• and: Returns True if both expressions are true.
• or: Returns True if at least one expression is true.
• not: Inverts the Boolean value (True becomes False, and vice versa).

Boolean Functions

Python provides built-in functions that return Boolean values. For instance:

bool() Function: Converts a value to a Boolean. This function returns True for most values except None, 0, False, empty sequences ('', [], ()), and empty dictionaries ({}).

print(bool(1)) # Output: True
print(bool(0)) # Output: False
print(bool("")) # Output: False
print(bool("Hello")) # Output: True 

Conclusion

Booleans are the foundation of decision-making in programming. By understanding how to work with Boolean values, expressions, and operators, you can control the flow of your programs and create more dynamic, responsive code. Mastering Booleans will significantly enhance your ability to write complex programs that can handle various scenarios based on different conditions.

Python Operators

Operators are symbols in Python that perform specific operations on variables and values. They are the building blocks of most expressions in Python and are used to manipulate data, perform calculations, compare values, and more. Understanding how to use operators effectively is crucial for writing efficient and concise Python code.

Types of Operators in Python

Python supports several types of operators, each serving a different purpose:

1. Arithmetic Operators
2. Assignment Operators
3. Comparison Operators
4. Logical Operators
5. Identity Operators
6. Membership Operators
7. Bitwise Operators

Let’s explore each type in detail:

1. Arithmetic Operators

Arithmetic operators are used to perform mathematical operations:

• Addition (+): Adds two operands.
• Subtraction (-): Subtracts the second operand from the first.
• Multiplication (*): Multiplies two operands.
• Division (/): Divides the first operand by the second (always returns a float).
• Floor Division (//): Divides the first operand by the second and returns the largest integer smaller than or equal to the result.
• Modulus (%): Returns the remainder of the division of the first operand by the second.
• Exponentiation (**): Raises the first operand to the power of the second.

x = 5
y = 3
print(x + y) # Output: 8
print(x - y) # Output: 2
print(x * y) # Output: 15
print(x / y) # Output: 1.6666666666666667
print(x // y) # Output: 1
print(x % y) # Output: 2
print(x ** y) # Output: 125

2. Assignment Operators

Assignment operators are used to assign values to variables. They can also perform operations before assigning the result:

• =: Assigns the value on the right to the variable on the left.
• +=: Adds the right operand to the left operand and assigns the result to the left operand.
• -=: Subtracts the right operand from the left operand and assigns the result to the left operand.
• *=: Multiplies the left operand by the right operand and assigns the result to the left operand.
• /=: Divides the left operand by the right operand and assigns the result to the left operand.
• %=: Takes the modulus of the left operand with the right operand and assigns the result to the left operand.
• //=: Performs floor division on the left operand by the right operand and assigns the result to the left operand.
• **=: Raises the left operand to the power of the right operand and assigns the result to the left operand.

x = 5
x += 3 # Equivalent to x = x + 3
x -= 2 # Equivalent to x = x - 2
x *= 4 # Equivalent to x = x * 4
x /= 2 # Equivalent to x = x / 2
x %= 3 # Equivalent to x = x % 3
x //= 2 # Equivalent to x = x // 2
x **= 3 # Equivalent to x = x ** 3

3. Comparison Operators

Comparison operators compare two values and return a Boolean value (True or False):

• ==: Equal to
• !=: Not equal to
• >: Greater than
• <: Less than
• <=: Less than or equal to

print(x == y) # Output: False
print(x != y) # Output: True
print(x > y) # Output: True
print(x < y) # Output: False
print(x >= y) # Output: True
print(x <= y) # Output: False

4. Logical Operators

Logical operators are used to combine conditional statements:

• and: Returns True if both statements are true.
• or: Returns True if at least one statement is true.
• not: Reverses the result, returns False if the result is true.

print(x > y and y > 2) # Output: True
print(x > y or y < 2) # Output: True
print(not(x > y)) # Output: False 

5. Identity Operators

Identity operators compare the memory locations of two objects:

• is: Returns True if both variables point to the same object.
• is not: Returns True if both variables do not point to the same object.

a = [1, 2, 3]
b = a
print(a is b) # Output: True

b = [1, 2, 3]
print(a is not b) # Output: True

6. Membership Operators

Membership operators test whether a sequence contains a certain value:

• in: Returns True if a specified value is found in the sequence.

not in: Returns True if a specified value is not found in the sequence.

a = [1, 2, 3]
print(2 in a) # Output: True
print(4 not in a) # Output: True  

7. Bitwise Operators

Bitwise operators are used to perform operations on binary numbers:

• &: Bitwise AND
• |: Bitwise OR
• ^: Bitwise XOR
• ~: Bitwise NOT
• <<: Left Shift
• >>: Right Shift

x = 10 # Binary: 1010
y = 4 # Binary: 0100

print(x & y) # Output: 0 (Binary: 0000)
print(x | y) # Output: 14 (Binary: 1110)
print(x ^ y) # Output: 14 (Binary: 1110)
print(~x) # Output: -11 (Binary: ...11110101)
print(x << 2) # Output: 40 (Binary: 101000)
print(x >> 2) # Output: 2 (Binary: 0010)

Conclusion

Operators are at the core of Python programming, enabling you to perform a wide range of operations, from simple arithmetic to complex logical expressions. By mastering these operators, you’ll be able to write more powerful and efficient code. Understanding how to use them correctly is essential as you progress in your Python journey and tackle more complex programming challenges.

Working with Python Lists

Lists are one of the most versatile and widely used data structures in Python. They allow you to store an ordered collection of items, which can be of different types. Lists are mutable, meaning you can modify their contents after they have been created. Understanding how to work with lists is essential for any Python programmer, as they are fundamental to managing collections of data.

What is a List?

A list in Python is a collection of elements enclosed in square brackets [], separated by commas. Each element in a list can be of any data type, and lists can even contain other lists (nested lists).

# Creating a list of integers
numbers = [1, 2, 3, 4, 5]

# Creating a list with mixed data types
mixed_list = [1, "Hello", 3.14, True]

# Creating a nested list
nested_list = [1, [2, 3], [4, 5]]

Accessing List Elements

You can access individual elements in a list by their index. Python uses zero-based indexing, so the first element of a list is at index 0.

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

# Accessing the first element
print(fruits[0]) # Output: apple

# Accessing the last element
print(fruits[-1]) # Output: cherry

# Accessing elements in a nested list
nested_list = [1, [2, 3], [4, 5]]
print(nested_list[1][1]) # Output: 3

Modifying List Elements

Since lists are mutable, you can change the value of specific elements by assigning a new value to an index.

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

# Changing the second element
fruits[1] = "orange"
print(fruits) # Output: ['apple', 'orange', 'cherry'] 

Adding Elements to a List

Python provides several methods to add elements to a list:

• append(): Adds an element to the end of the list.
• insert(): Adds an element at a specified index.
• extend(): Adds multiple elements to the end of the list.

#append
fruits.append("kiwi")
print(fruits) # Output: ['apple', 'orange', 'cherry', 'kiwi']

#insert
fruits.insert(1, "mango")
print(fruits) # Output: ['apple', 'mango', 'orange', 'cherry', 'kiwi']

#extend 
fruits.extend(["grape", "watermelon"])
print(fruits) # Output: ['apple', 'mango', 'orange', 'cherry', 'kiwi', 'grape', 'watermelon']

Removing Elements from a List

You can remove elements from a list using several methods:

• remove(): Removes the first occurrence of a specified value.
• pop(): Removes and returns the element at a specified index (if no index is provided, it removes the last element).
• del: Deletes an element at a specified index or the entire list.
• clear(): Removes all elements from the list.

# remove
fruits.remove("orange")
print(fruits) # Output: ['apple', 'mango', 'cherry', 'kiwi', 'grape', 'watermelon']

# pop
last_fruit = fruits.pop()
print(last_fruit) # Output: watermelon
print(fruits) # Output: ['apple', 'mango', 'cherry', 'kiwi', 'grape']

# del
del fruits[2]
print(fruits) # Output: ['apple', 'mango', 'kiwi', 'grape']

# clear 
fruits.clear()
print(fruits) # Output: []

List Operations

Lists support various operations:

• Concatenation: Combine two lists using the + operator.
• Repetition: Repeat a list using the * operator.

# concatenation example 
list1 = [1, 2, 3]
list2 = [4, 5, 6]
combined = list1 + list2
print(combined) # Output: [1, 2, 3, 4, 5, 6]

# repetition
repeated_list = list1 * 3
print(repeated_list) # Output: [1, 2, 3, 1, 2, 3, 1, 2, 3]

List Slicing

Slicing allows you to access a range of elements in a list. The syntax is list[start:stop:step], where:

• start: The index to start the slice (inclusive).
• stop: The index to end the slice (exclusive).
• step: The step size (optional).

Example:

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# Slicing elements from index 2 to 5
print(numbers[2:6]) # Output: [2, 3, 4, 5]

# Slicing with a step
print(numbers[::2]) # Output: [0, 2, 4, 6, 8]

# Reversing a list
print(numbers[::-1]) # Output: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

List Comprehensions

List comprehensions provide a concise way to create lists. They consist of brackets containing an expression followed by a for clause, and can also include if clauses.

Example:

# Creating a list of squares of numbers from 0 to 9
squares = [x**2 for x in range(10)]
print(squares) # Output: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Common List Methods

• len(): Returns the number of elements in the list.
• sort(): Sorts the list in place.
• reverse(): Reverses the order of the list.
• index(): Returns the index of the first occurrence of a value.
• count(): Returns the number of times a value appears in the list.

# len example
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(len(numbers)) # Output: 10

# sort example
fruits = ["banana", "apple", "cherry"]
fruits.sort()
print(fruits) # Output: ['apple', 'banana', 'cherry']

# reverse example
fruits.reverse()
print(fruits) # Output: ['cherry', 'banana', 'apple']

# index example
print(fruits.index("banana")) # Output: 1

# count example
print(numbers.count(1)) # Output: 3

Conclusion

Lists are a powerful tool in Python, allowing you to store and manipulate collections of data with ease. Whether you’re adding, removing, or modifying elements, understanding how to work with lists will enable you to handle a wide variety of programming tasks. Mastering lists is a key step toward becoming proficient in Python and will serve as a foundation for learning more advanced data structures and algorithms.

Practice Exercises

Strings

1. Basic String Operations:
   • Create a string text with the value "Hello, World!".
   • Extract and print the substring "World" from text.
   • Convert the entire string to uppercase and print it.
   • Replace "World" with "Python" in the string and print the result.
   • Check if the substring "Hello" is present in text and print the result.
2. String Formatting:
   • Define variables name and age with the values "Alice" and 25, respectively.
   • Use f-strings or the format() method to create a string "Alice is 25 years old." and print it.
3. String Methods:
   • Create a string with multiple spaces, e.g., " Python is fun ".
   • Remove leading and trailing spaces and print the cleaned string.
   • Count the number of occurrences of the letter "o" in the string "Hello, World!".

Booleans

1. Basic Boolean Operations:
   • Create two boolean variables a and b with values True and False, respectively.
   • Perform and print the result of the following operations: a and b, a or b, not a.
2. Boolean Expressions:
   • Write a boolean expression to check if a variable x is between 10 and 20 (inclusive).
   • Test the expression with different values for x and print the results.
3. Comparisons:
   • Compare two variables num1 and num2 and print whether num1 is greater than num2, num1 is less than or equal to num2, and whether they are equal.

Operators

1. Arithmetic Operators:
   • Define two variables a and b with values 15 and 4, respectively.
   • Perform and print the results of addition, subtraction, multiplication, division, floor division, and modulus.
2. Comparison Operators:
   • Create variables x and y with values 7 and 10, respectively.
   • Use comparison operators to check if x is equal to y, x is not equal to y, x is greater than y, and x is less than or equal to y.
3. Logical Operators:
   • Write boolean expressions using and, or, and not operators with the variables True and False.
   • Print the results of these expressions.

Lists

1. Basic List Operations:
   • Create a list of integers numbers = [1, 2, 3, 4, 5].
   • Append the value 6 to the list and print the updated list.
   • Insert the value 0 at the beginning of the list and print the updated list.
   • Remove the value 3 from the list and print the updated list.
2. List Indexing and Slicing:
   • Create a list colors = ["red", "green", "blue", "yellow"].
   • Print the first element, the last element, and a slice of the list containing the second and third elements.
3. List Comprehensions:
   • Use a list comprehension to create a new list of squares of the numbers from 0 to 9 and print the list.

WEEK 3:

Welcome to Week 3 of our Python Bootcamp! In Week 3, we’re stepping up the complexity of our Python journey by focusing on two crucial aspects of the language: Collections and Control Flow. This week, you’ll learn how to efficiently manage groups of related data and dictate the execution flow of your programs. Understanding these concepts is key to writing code that is not only powerful but also organized and easy to understand.

Collections like tuples, sets, and dictionaries are fundamental data structures in Python. They allow you to store and manipulate data in various ways, each with its own strengths. Tuples provide a way to store immutable sequences of elements, making them perfect for situations where data integrity is crucial. Sets, on the other hand, are ideal for operations that require uniqueness and mathematical set operations like unions and intersections. Dictionaries are invaluable when you need to associate unique keys with values, allowing for rapid data retrieval.

Control Flow structures, including if...else statements and loops, are the backbone of decision-making in your code. By mastering these, you’ll be able to create programs that react dynamically to different inputs and conditions. If...else statements enable your code to make decisions based on conditions, while loops allow you to repeat code execution efficiently, saving you from writing repetitive code blocks.

By the end of Week 3, you’ll have the ability to:

• Organize and manipulate data effectively using Python’s versatile collection types.
• Control the execution flow of your programs, making them more dynamic and responsive to varying conditions.
• Write modular and reusable code through the use of functions, enhancing the maintainability and scalability of your programs.

This week’s content is designed to deepen your understanding and give you hands-on practice with these essential tools. By mastering these concepts, you’ll be well on your way to handling more complex programming challenges with confidence.

Let’s Start.

Tuples in Python

Tuples are an essential data structure in Python, designed to store an ordered collection of items. Unlike lists, tuples are immutable, meaning that once a tuple is created, its elements cannot be modified. This immutability makes tuples useful for storing data that should not be altered throughout the lifecycle of a program. They are often used to group related data, ensuring the integrity and consistency of that data.

1. Creating Tuples

Tuples can be created by placing a sequence of values separated by commas inside parentheses. A tuple can hold elements of different data types.

# Creating a tuple
my_tuple = (1, 2, 3, "apple", "banana")

# Single-element tuple (note the comma)
single_element_tuple = ("only element",)

If you create a tuple without parentheses, Python can still recognize it as a tuple based on the comma:

# Tuple without parentheses
another_tuple = 1, 2, 3, "orange"

2. Accessing Tuple Elements

You can access elements in a tuple by indexing, just like with lists. Indexing in Python starts from 0, and negative indexing allows you to access elements from the end of the tuple.

# Accessing elements
print(my_tuple[0]) # Output: 1
print(my_tuple[3]) # Output: "apple"

# Accessing last element using negative indexing
print(my_tuple[-1]) # Output: "banana"

Tuples support slicing, which allows you to retrieve a subset of elements:
print(my_tuple[1:4]) # Output: (2, 3, 'apple')

3. Tuple Operations

Although tuples are immutable, there are still several operations you can perform with them:

• Concatenation: You can combine two tuples using the + operator.
• Repetition: You can repeat the elements of a tuple using the * operator.
• Membership: You can check if an element exists within a tuple using the in keyword.

tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
combined_tuple = tuple1 + tuple2
print(combined_tuple) # Output: (1, 2, 3, 4, 5, 6)

repeated_tuple = tuple1 * 2
print(repeated_tuple) # Output: (1, 2, 3, 1, 2, 3)

print(3 in tuple1) # Output: True
print(7 in tuple1) # Output: False

4. Nested Tuples

Tuples can contain other tuples as elements, which is known as nesting. This allows you to create complex data structures.

# Nested tuple
nested_tuple = (1, (2, 3), (4, 5, 6))
print(nested_tuple[1]) # Output: (2, 3)
print(nested_tuple[2][1]) # Output: 5

5. Unpacking Tuples

Python allows you to extract the elements of a tuple into separate variables, a process known as unpacking.

# Unpacking a tuple
person = ("John", 30, "Engineer")
name, age, profession = person

print(name) # Output: John
print(age) # Output: 30
print(profession) # Output: Engineer

You can also unpack nested tuples:

# Unpacking nested tuples
nested_tuple = (1, (2, 3), 4)
a, (b, c), d = nested_tuple

print(a) # Output: 1
print(b) # Output: 2
print(c) # Output: 3
print(d) # Output: 4

Tuple unpacking is especially useful when returning multiple values from a function.

Summary: Understanding tuples and their operations is vital for working with Python effectively, especially when you need to manage data that should remain constant throughout your program’s execution. As you continue to explore Python, you’ll find tuples useful in a variety of scenarios, from data organization to function returns.

Sets in Python

Sets are a built-in data structure in Python that represent an unordered collection of unique elements. Unlike lists or tuples, sets do not allow duplicate values, making them ideal for tasks that require uniqueness. Sets are also mutable, meaning you can add or remove elements after the set has been created. They are particularly useful for performing common mathematical set operations such as union, intersection, and difference.

1. Creating Sets

You can create a set by placing a comma-separated sequence of elements within curly braces {} or by using the set() function.

# Creating a set with curly braces
my_set = {1, 2, 3, 4, 5}

# Creating a set using the set() function
another_set = set([1, 2, 3, 2, 1])
print(another_set) # Output: {1, 2, 3} (duplicates are removed)

Note that an empty set must be created using set() since {} creates an empty dictionary.

2. Adding and Removing Elements

Sets are mutable, allowing you to add or remove elements after the set is created.

• Adding Elements: Use the add() method to add a single element, or update() to add multiple elements.
• Removing Elements: Use the remove() method to remove a specific element (raises an error if the element is not found) or discard() (doesn’t raise an error if the element is not found). You can also use pop() to remove and return an arbitrary element.

# Adding elements
my_set.add(6)
print(my_set) # Output: {1, 2, 3, 4, 5, 6}

# Adding multiple elements
my_set.update([7, 8])
print(my_set) # Output: {1, 2, 3, 4, 5, 6, 7, 8}

# Removing elements
my_set.remove(3)
print(my_set) # Output: {1, 2, 4, 5, 6, 7, 8}

# Discarding an element
my_set.discard(10) # No error, even though 10 is not in the set

# Popping an element
popped_element = my_set.pop()
print(popped_element) # Output: 1 (or another element, since sets are unordered)

3. Set Operations (Union, Intersection, Difference)

Sets support various operations that mirror common mathematical set operations.

• Union: Combines elements from both sets, removing duplicates.
• Intersection: Returns elements that are common to both sets.
• Difference: Returns elements that are in the first set but not in the second.
• Symmetric Difference: Returns elements that are in either of the sets but not in both

set1 = {1, 2, 3}
set2 = {3, 4, 5}
union_set = set1.union(set2)
print(union_set) # Output: {1, 2, 3, 4, 5}

intersection_set = set1.intersection(set2)
print(intersection_set) # Output: {3}

difference_set = set1.difference(set2)
print(difference_set) # Output: {1, 2}

symmetric_diff_set = set1.symmetric_difference(set2)
print(symmetric_diff_set) # Output: {1, 2, 4, 5}

4. Set Comprehensions

Like list comprehensions, set comprehensions provide a concise way to create sets.

# Set comprehension example
squared_set = {x**2 for x in range(10)}
print(squared_set) # Output: {0, 1, 4, 9, 16, 25, 36, 49, 64, 81}

Summary: Set comprehensions are especially useful when you want to generate a new set based on an existing iterable with some transformation or condition applied.

Dictionaries in Python

Dictionaries are powerful and flexible data structures in Python used to store data in key-value pairs. They allow for fast lookups, modifications, and deletions, making them ideal for cases where you need to associate unique keys with specific values.

1. Creating Dictionaries

Dictionaries are created by placing a comma-separated sequence of key-value pairs within curly braces {}, with each key and value separated by a colon :.

# Creating a dictionary
my_dict = {
"name": "Alice",
"age": 30,
"city": "New York"
}

# Using the dict() function
another_dict = dict(name="Bob", age=25, city="Los Angeles")

Keys in a dictionary must be immutable types (like strings, numbers, or tuples), while values can be of any type.

2. Accessing and Modifying Values

You can access a dictionary’s value by referencing its key. You can also add, update, or delete key-value pairs.

# Accessing a value
print(my_dict["name"]) # Output: Alice

# Modifying a value
my_dict["age"] = 31

# Adding a new key-value pair
my_dict["email"] = "[email protected]"

# Deleting a key-value pair
del my_dict["city"]

print(my_dict) # Output: {'name': 'Alice', 'age': 31, 'email': '[email protected]'}

3. Dictionary Methods

Dictionaries come with several useful methods for interacting with the stored data:

• .keys(): Returns a view object containing all keys in the dictionary.
• .values(): Returns a view object containing all values in the dictionary.
• .items(): Returns a view object containing tuples of key-value pairs.
• .get(): Safely retrieves the value associated with a key, returning None if the key is not found (or a specified default).

keys = my_dict.keys()
print(keys) # Output: dict_keys(['name', 'age', 'email'])

values = my_dict.values()
print(values) # Output: dict_values(['Alice', 31, '[email protected]'])

items = my_dict.items()
print(items) # Output: dict_items([('name', 'Alice'), ('age', 31), ('email', '[email protected]')])

email = my_dict.get("email", "Not Provided")
print(email) # Output: [email protected]

4. Nested Dictionaries

Dictionaries can be nested, allowing for complex data structures. This is useful for representing hierarchical data.

# Nested dictionary
nested_dict = {
"name": "Alice",
"job": {
"title": "Engineer",
"company": "TechCorp"
}
}

print(nested_dict["job"]["company"]) # Output: TechCorp

Nested dictionaries provide a way to structure data in layers, making it easier to manage and retrieve.

5. Dictionary Comprehensions

Similar to set comprehensions, you can use dictionary comprehensions to create dictionaries from an iterable.

# Dictionary comprehension example
squared_dict = {x: x**2 for x in range(5)}
print(squared_dict) # Output: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

Dictionary comprehensions are powerful tools for generating dictionaries programmatically, applying transformations, or filtering data.

Summary: Understanding sets and dictionaries in Python equips you with the tools to handle a wide range of data manipulation tasks efficiently. While sets allow for fast membership tests and unique collections, dictionaries provide a way to map and organize data using keys, both of which are invaluable in various programming scenarios.

Conditional Statements in Python: If…Else

Conditional statements are a core feature of programming that allows you to control the flow of execution based on conditions. In Python, the if...else statement is a primary tool for making decisions in your code. By evaluating conditions, you can execute specific code blocks depending on whether those conditions are met or not.

1. Basic If Statements

The most straightforward conditional statement is the if statement, which checks whether a condition is True. If it is, the code block under the if statement is executed.

# Basic if statement example
x = 10

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

In the above example, the condition x > 5 is evaluated. Since the condition is True, the code block inside the if statement is executed.

2. If…Else Statements

The if...else statement adds an alternative path. If the if condition is False, the code block under else is executed.

# If...else statement example
x = 3

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

Here, since x > 5 is False, the code block under else is executed instead.

3. Elif Statements

The elif (short for “else if”) statement allows you to check multiple conditions sequentially. If the first if condition is not met, Python evaluates the elif condition. If none of the if or elif conditions are True, the else block is executed.

# If...elif...else statement example
x = 7

if x > 10:
print("x is greater than 10")
elif x > 5:
print("x is greater than 5 but less than or equal to 10")
else:
print("x is 5 or less")
# Output: x is greater than 5 but less than or equal to 10

The code block under the first True condition is executed, and no further conditions are checked.

4. Nested If Statements

You can nest if statements within each other to create more complex decision structures. This allows for checking multiple levels of conditions.

# Nested if statement example
x = 15

if x > 10:
print("x is greater than 10")
if x > 20:
print("x is also greater than 20")
else:
print("x is not greater than 20")
# Output:
# x is greater than 10
# x is not greater than 20

In this example, the inner if...else is only evaluated if the outer if condition is True.

5. Ternary Operator

The ternary operator in Python is a one-liner alternative to the if...else statement. It provides a concise way to assign a value based on a condition.

# Ternary operator example
x = 10
y = 20

result = "x is greater" if x > y else "y is greater or equal"
print(result)
# Output: y is greater or equal

The expression "x is greater" if x > y else "y is greater or equal" assigns the result based on whether x > y is True or False.

Summary: Conditional statements are fundamental to controlling the flow of your Python programs. By using if, else, elif, nested if statements, and the ternary operator, you can create flexible and powerful decision-making structures that allow your programs to respond dynamically to different situations.

While Loops in Python

A while loop in Python repeatedly executes a block of code as long as a specified condition remains True. It is particularly useful in scenarios where the number of iterations is not known beforehand and depends on dynamic conditions, such as user input or real-time data processing.

1. Basic While Loop

The structure of a basic while loop is straightforward. The loop runs as long as the given condition is True. When the condition becomes False, the loop stops.

# Basic while loop example
count = 0

while count < 5:
print("Count is:", count)
count += 1
# Output:
# Count is: 0
# Count is: 1
# Count is: 2
# Count is: 3
# Count is: 4

In this example, the loop continues to execute until count reaches 5. On each iteration, count is incremented by 1.

2. Break and Continue Statements

• Break Statement: The break statement is used to exit the loop immediately, regardless of the condition.

# Break statement example
count = 0

while count < 10:
print("Count is:", count)
if count == 5:
break
count += 1
# Output:
# Count is: 0
# Count is: 1
# Count is: 2
# Count is: 3
# Count is: 4
# Count is: 5

In this case, the loop stops as soon as count equals 5, even though the condition count < 10 is still True.

• Continue Statement: The continue statement skips the rest of the current loop iteration and moves directly to the next iteration.

# Continue statement example
count = 0

while count < 5:
count += 1
if count == 3:
continue
print("Count is:", count)
# Output:
# Count is: 1
# Count is: 2
# Count is: 4
# Count is: 5

Here, when count equals 3, the continue statement causes the loop to skip printing count and proceed with the next iteration.

3. While-Else Loop

A while loop can have an optional else clause. The else block is executed when the loop condition becomes False. If the loop is terminated by a break statement, the else block will not be executed.

# While-else loop example
count = 0

while count < 5:
print("Count is:", count)
count += 1
else:
print("Loop ended naturally")
# Output:
# Count is: 0
# Count is: 1
# Count is: 2
# Count is: 3
# Count is: 4
# Loop ended naturally

In this example, once the loop condition count < 5 becomes False, the else block is executed.

4. Infinite Loops and How to Avoid Them

An infinite loop occurs when the loop’s condition never becomes False, causing the loop to run indefinitely. This is usually due to a logical error where the terminating condition is never met.

# Example of an infinite loop (Do not run)
while True:
print("This loop runs forever")

To avoid infinite loops, ensure that the loop’s condition will eventually become False. Here are some tips:

• Update the Condition: Make sure the loop variable is being modified in a way that it will eventually fail the condition.
• Use Break Statement: Implement a break statement if you need an emergency exit condition.

# Correctly exiting the loop
x = 10

while x > 0:
print("x is", x)
x -= 1

 

while True:
user_input = input("Enter 'exit' to stop the loop: ")
if user_input == 'exit':
break

Summary: While loops are a powerful tool in Python for executing a block of code repeatedly based on a condition. By understanding the basic structure, using break and continue statements appropriately, leveraging the while-else construct, and being mindful of potential infinite loops, you can effectively control the flow of your programs.

For Loops in Python

For loops in Python are an essential tool for iterating over sequences like lists, tuples, dictionaries, sets, and even strings. They allow you to execute a block of code repeatedly for each item in the sequence, making them invaluable for tasks that involve processing collections of data.

1. Basic For Loop

The most basic form of a for loop iterates over each item in a sequence, executing the loop’s code block for each element.

# Basic for loop example
fruits = ["apple", "banana", "cherry"]

for fruit in fruits:
print(fruit)
# Output:
# apple
# banana
# cherry

In this example, the loop iterates through the fruits list, printing each item.

2. Looping Through Sequences

You can use for loops to iterate over different types of sequences, including lists, tuples, sets, and dictionaries.

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

for num in numbers:
print(num * 2)
# Output:
# 2
# 4
# 6
# 8
# 10

coordinates = (10, 20, 30)

for coordinate in coordinates:
print(coordinate)
# Output:
# 10
# 20
# 30

unique_numbers = {1, 2, 3}

for num in unique_numbers:
print(num)
# Output:
# 1
# 2
# 3

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

for key, value in person.items():
print(key, ":", value)
# Output:
# name : John
# age : 30
# city : New York

3. Nested For Loops

A nested for loop is a loop inside another loop. This is useful for working with multi-dimensional data structures like lists of lists.

# Nested for loop example
matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]

for row in matrix:
for num in row:
print(num, end=" ")
print()
# Output:
# 1 2 3
# 4 5 6
# 7 8 9

In this example, the outer loop iterates over each row in the matrix, and the inner loop iterates over each number in the row.

4. Using the Range Function

The range() function generates a sequence of numbers, making it useful for creating loops that need to iterate a specific number of times.

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

#custom start stop
for i in range(2, 10): print(i) # Output: # 2 # 3 # 4 # 5 # 6 # 7 # 8 # 9

#step value

for i in range(0, 10, 2):
print(i)
# Output:
# 0
# 2
# 4
# 6
# 8

The range() function is particularly useful for iterating a specific number of times or generating sequences of numbers with a defined step.

5. Break and Continue in For Loops

Break Statement: The break statement exits the loop entirely, skipping any further iterations.

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

When i equals 5, the loop breaks, and no further numbers are printed.

Continue Statement: The continue statement skips the rest of the current iteration and moves to the next one.

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

Here, when i equals 2, the loop skips the print statement and continues with the next iteration.

Summary: For loops are a fundamental aspect of Python programming, enabling you to iterate over and process collections of data efficiently. Understanding how to use basic for loops, iterate through different sequences, work with nested loops, utilize the range() function, and control loop flow with break and continue is crucial for developing more complex and powerful Python programs.

Functions in Python

Functions are one of the most powerful features in Python, allowing you to group code into reusable blocks. They help you write more organized, modular, and maintainable programs by breaking down complex tasks into smaller, manageable pieces.

1. Defining Functions

In Python, you define a function using the def keyword followed by the function name and parentheses (). Inside the parentheses, you can specify parameters that the function can accept. The function body is indented and contains the code that the function will execute.

# Defining a simple function
def greet():
print("Hello, welcome to Python functions!")

# Calling the function
greet()
# Output:
# Hello, welcome to Python functions!

This function, greet, takes no parameters and simply prints a message when called.

2. Function Arguments

Functions can take arguments (parameters), which are values you pass to the function when calling it. These arguments are used within the function to perform operations.

# Function with parameters
def greet_user(name):
print("Hello, " + name + "!")

greet_user("Alice")
greet_user("Bob")
# Output:
# Hello, Alice!
# Hello, Bob!

Here, the greet_user function takes one parameter, name, and prints a personalized greeting.

3. Return Statement

The return statement allows a function to send a result back to the caller. This is how functions can produce output that can be used elsewhere in your code.

# Function that returns a value
def add_numbers(a, b):
return a + b

result = add_numbers(5, 3)
print("The sum is:", result)
# Output:
# The sum is: 8

In this example, the add_numbers function returns the sum of two numbers, which is then printed.

4. Default Parameters

Python allows you to define default values for parameters. If an argument is not provided when the function is called, the default value is used.

# Function with default parameter
def greet_user(name="Guest"):
print("Hello, " + name + "!")

greet_user("Alice")
greet_user()
# Output:
# Hello, Alice!
# Hello, Guest!

5. Keyword Arguments

When calling a function, you can specify arguments by the name of the parameter rather than by position. This is especially useful when a function has many parameters or when you want to make your code more readable.

# Function with keyword arguments
def describe_pet(animal_type, pet_name):
print("I have a " + animal_type + " named " + pet_name + ".")

describe_pet(animal_type="dog", pet_name="Rex")
describe_pet(pet_name="Whiskers", animal_type="cat")
# Output:
# I have a dog named Rex.
# I have a cat named Whiskers.

In this example, the order of arguments doesn’t matter because they are passed by keyword.

6. Anonymous Functions (Lambda)

Python provides a way to create small, anonymous functions using the lambda keyword. Lambda functions are often used for short, simple operations and are defined inline.

# Lambda function example
add = lambda x, y: x + y

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

This lambda function takes two arguments and returns their sum. It’s equivalent to a simple function defined with def.

7. Recursive Functions

A recursive function is a function that calls itself to solve a smaller instance of the same problem. Recursion is useful for tasks that can be broken down into smaller, similar sub-tasks.

# Recursive function example: Factorial
def factorial(n):
if n == 1:
return 1
else:
return n * factorial(n - 1)

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

In this example, the factorial function calls itself to compute the factorial of a number. The recursion ends when n equals 1.

Summary: Functions are a cornerstone of Python programming, enabling you to encapsulate and reuse code efficiently. Understanding how to define functions, use arguments, return values, and leverage advanced features like default parameters, keyword arguments, lambda functions, and recursion is essential for writing clean, effective Python code.

Practice Exercises

Sets

Exercise 1: Creating and Modifying Sets

1. Create a set called fruits containing the following items: “apple”, “banana”, “cherry”.
2. Add the item “orange” to the set.
3. Remove “banana” from the set.
4. Check if “apple” is in the set and print the result.

Exercise 2: Set Operations

1. Create two sets: set1 with values {1, 2, 3, 4} and set2 with values {3, 4, 5, 6}.
2. Find the union of set1 and set2.
3. Find the intersection of set1 and set2.
4. Find the difference between set1 and set2 (elements in set1 but not in set2).

Dictionaries

Exercise 1: Creating and Accessing Dictionaries

1. Create a dictionary called person with the following key-value pairs: name: "John", age: 30, city: "New York".
2. Access and print the value of name.
3. Change the value of age to 31.
4. Add a new key-value pair: job: "Engineer"

Exercise 2: Looping Through Dictionaries

1. Loop through the dictionary person from the previous exercise and print all the keys and values.

If…Else

Exercise 1: Basic If Statements

1. Write a script that checks if a number is positive, negative, or zero and prints an appropriate message.

Exercise 2: Nested If Statements

1. Write a script that takes two numbers as input and prints which one is greater. If they are equal, print that they are equal.

While Loops

Exercise 1: Basic While Loop

1. Write a while loop that prints numbers from 1 to 10.

Exercise 2: While Loop with Break

1. Write a script that takes user input in a loop until the user types “stop”. Print each input.

For Loops

Exercise 1: Looping Through a List

1. Write a for loop that iterates through a list of numbers and prints only the even numbers.

Exercise 2: Looping Through a Dictionary

1. Write a for loop that iterates through a dictionary and prints the keys and values.

Functions

Exercise 1: Writing a Simple Function

1. Write a function called calculate_square that takes a number as a parameter and returns its square.

Exercise 2: Function with Multiple Parameters

1. Write a function called calculate_area that takes two parameters: length and width. The function should return the area of a rectangle.

Exercise 3: Function with Default Parameters

1. Write a function greet_user that takes one optional parameter name with a default value of “Guest”. The function should print a greeting message.

These exercises should help solidify your understanding of sets, dictionaries, if…else statements, while loops, for loops, and functions in Python.

WEEK 4:

Welcome to Week 4 of our Python Bootcamp! This week, we’re diving into some of the more advanced and powerful features of Python. We’re focusing on essential concepts such as Lambda functions, Arrays, Classes and Objects, Inheritance, Iterators, and Polymorphism. These concepts will help you write more efficient, organized, and reusable code, and prepare you for complex programming tasks.

By the end of Week 4, you’ll be equipped to:

• Use Lambda functions to create concise and efficient code.
• Work with Arrays to manage collections of data effectively.
• Create and manage Classes and Objects to leverage the power of object-oriented programming.
• Apply Inheritance to build on existing code and create more complex data structures.
• Implement Iterators to handle sequences of data in a custom manner.
• Utilize Polymorphism to make your code more flexible and maintainable.
• Understand Scope to manage variable visibility and avoid conflicts.
• Work with Modules to organize and reuse code efficiently.
• Handle Dates and Times to manage time-related operations in your applications.

This week’s content is designed to build on the foundations you’ve established and introduce more sophisticated techniques and structures. Mastering these concepts will pave the way for tackling advanced programming challenges and developing robust Python applications.

Let’s get started!

Python Lambda

Why Use Lambda Functions?

Lambda functions are a powerful feature in Python that allow you to create
small, anonymous functions without the need for formally defining a function
using the def keyword. These functions are often used for short,
simple operations that are passed as arguments to higher-order functions like
map(), filter(), and reduce().

Key Characteristics:

• Anonymous: Lambda functions don’t require a name.
• Single Expression: They are limited to a single expression,
  which is evaluated and returned.
• Concise: Lambdas are compact and can replace simple
  functions defined using def.

Syntax:

lambda arguments: expression

Example:

# Regular function
def add(x, y):
return x + y

# Equivalent lambda function
add_lambda = lambda x, y: x + y
print(add_lambda(3, 4))  # Output: 7

Use Cases:

Sorting a List of Tuples:

students = [('John', 23), ('Alice', 25), ('Bob', 22)]
# Sort by age
sorted_students = sorted(students, key=lambda student: student[1])
print(sorted_students)  # Output: [('Bob', 22), ('John', 23), ('Alice', 25)]

Filtering with filter():

numbers = [1, 2, 3, 4, 5, 6]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)  # Output: [2, 4, 6]

Transforming Data with map():

numbers = [1, 2, 3, 4, 5]
squares = list(map(lambda x: x ** 2, numbers))
print(squares)  # Output: [1, 4, 9, 16, 25]

Benefits:

• Improved Readability: When used appropriately, lambda
  functions can make your code cleaner and more readable by eliminating the
  need for temporary functions.
• Functional Programming: Lambdas are a key part of Python’s
  support for functional programming, where functions are treated as
  first-class citizens.

Python Arrays

What is an Array?

In Python, arrays are implemented using lists, a versatile data structure that can store a collection of elements. Arrays (lists) in Python are mutable, meaning their elements can be changed, added, or removed after the array has been created. Arrays can hold elements of any data type, making them a flexible option for storing various types of data.

Syntax:

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

Example:

my_array = [1, 2, 3, 4, 5]
print(my_array)  # Output: [1, 2, 3, 4, 5]

Access the Elements of an Array

You can access elements in an array using indexing. Python supports both
positive and negative indexing, allowing you to access elements from the start
or the end of the list.

Example:

# Accessing elements by positive index
print(my_array[0])  # Output: 1
print(my_array[3])  # Output: 4

# Accessing elements by negative index
print(my_array[-1])  # Output: 5 (last element)
print(my_array[-2])  # Output: 4 (second last element)

The Length of an Array

The len() function returns the number of elements in an array.

Example:

print(len(my_array))  # Output: 5

Looping Array Elements

You can loop through array elements using a for loop, allowing
you to perform operations on each element.

Example:

for element in my_array:
print(element)
# Output: 1 2 3 4 5

Adding Array Elements

Elements can be added to an array using the append() method (to
add an element at the end) or the insert() method (to add an
element at a specific position).

Example:

# Adding an element at the end
my_array.append(6)
print(my_array)  # Output: [1, 2, 3, 4, 5, 6]

# Inserting an element at a specific position
my_array.insert(2, 9)
print(my_array)  # Output: [1, 2, 9, 3, 4, 5, 6]

Removing Array Elements

Elements can be removed using the remove() method (to remove the first occurrence of a value) or the pop() method (to remove an
element by index).

Example:

# Removing a specific value
my_array.remove(3)
print(my_array)  # Output: [1, 2, 9, 4, 5, 6]

# Removing an element by index
my_array.pop(2)
print(my_array)  # Output: [1, 2, 4, 5, 6]

Array Methods

Python lists come with various built-in methods that allow you to manipulate the array in different ways. Some common methods include sort(), reverse(), count(), index(), and extend().

Sorting:

my_array.sort()
print(my_array)  # Output: [1, 2, 4, 5, 6]

Reversing:

my_array.reverse()
print(my_array)  # Output: [6, 5, 4, 2, 1]

Counting Occurrences:

count = my_array.count(4)
print(count)  # Output: 1

Extending the Array:

my_array.extend([7, 8, 9])
print(my_array)  # Output: [6, 5, 4, 2, 1, 7, 8, 9]

Python Classes and Objects

Create a Class

Classes in Python are blueprints for creating objects. A class encapsulates data for the object and methods to manipulate that data. The class keyword is used to define a class.

Example:

class MyClass:
x = 5

# Creating an object of MyClass
p1 = MyClass()
print(p1.x)  # Output: 5

Create Object

Objects are instances of a class. They represent specific examples of the class and can have their attributes and methods.

Example:

class MyClass:
x = 10

# Creating two objects
obj1 = MyClass()
obj2 = MyClass()

print(obj1.x)  # Output: 10
print(obj2.x)  # Output: 10

The __init__() Function

The __init__() function is a special method in Python classes. It
is automatically invoked when a new object of the class is created. This
method is used to initialize the attributes of the object.

Example:

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

p1 = Person("John", 30)
print(p1.name)  # Output: John
print(p1.age)  # Output: 30

The __str__() Function

The __str__() method in a class defines the string representation
of the object. When you print an object, the string returned by
__str__() is displayed.

Example:

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

def __str__(self):
    return f"{self.name} is {self.age} years old."

p1 = Person("Alice", 25)
print(p1)  # Output: Alice is 25 years old.

Object Methods

Object methods are functions defined inside a class that operate on instances of the class. These methods can access and modify the attributes of the object.

Example:

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

def greet(self):
    print(f"Hello, my name is {self.name}.")

p1 = Person("Bob", 28)
p1.greet()  # Output: Hello, my name is Bob.

The self Parameter

The self parameter is a reference to the current instance of the
class. It is used to access variables that belong to the class. The
self parameter must be the first parameter of any method in a
class.

Example:

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

def greet(self):
    print(f"Hi, I'm {self.name} and I'm {self.age} years old.")

p1 = Person("Carol", 35)
p1.greet()  # Output: Hi, I'm Carol and I'm 35 years old.

Modify Object Properties

Object properties can be modified directly using the object reference followed
by the property name.

Example:

p1.age = 36
print(p1.age)  # Output: 36

Delete Object Properties

You can delete an object’s property using the del keyword.

Example:

del p1.age

Delete Objects

Entire objects can be deleted using the del keyword.

Example:

del p1

The pass Statement

The pass statement in Python is a placeholder that does nothing.
It’s useful in situations where a statement is syntactically required, but you
don’t want to execute any code.

Example:

class EmptyClass:
pass

Python Inheritance

Create a Parent Class

Inheritance allows you to define a class that inherits all the methods and properties from another class. The class being inherited from is called the parent or base class.

Example:

class Animal:
def __init__(self, name):
    self.name = name

def speak(self):
    return f"{self.name} makes a sound."

Create a Child Class

A child class is a class that inherits from a parent class. The child class
can have its own properties and methods in addition to those inherited from
the parent class.

Example:

class Dog(Animal):
def speak(self):
    return f"{self.name} barks."

Add the __init__() Function

If you add the __init__() method to the child class, it will
override the parent class’s __init__() method. You can also
extend the parent’s __init__() by calling
super().__init__() in the child class.

Example:

class Dog(Animal):
def __init__(self, name, breed):
    super().__init__(name)
    self.breed = breed

Use the super() Function

The super() function allows you to call a method from the parent
class within a child class.

Example:

class Cat(Animal):
def __init__(self, name, color):
    super().__init__(name)
    self.color = color

Add Properties

Child classes can have additional properties that are specific to them, in
addition to the properties inherited from the parent class.

Example:

class Bird(Animal):
def __init__(self, name, species):
    super().__init__(name)
    self.species = species

Add Methods

Child classes can have additional methods, specific to the child class, which are not available in the parent class.

Example:

class Parrot(Bird):
def speak(self):
    return f"{self.name} speaks!"

Python Iterators

Iterator vs Iterable

An iterable is an object that can be iterated over (e.g., lists, tuples,
dictionaries). An iterator is an object that represents a stream of data; it
returns one element at a time from the iterable.

Example:

# Iterable
my_list = [1, 2, 3]
my_iter = iter(my_list)

# Iterator
print(next(my_iter))  # Output: 1
print(next(my_iter))  # Output: 2

Looping Through an Iterator

You can loop through an iterator using a for loop or manually
using the next() function.

Example:

for item in my_list:
print(item)
# Output: 1 2 3

Create an Iterator

You can create your own iterator by defining a class with the methods __iter__() and __next__().

Example:

class MyNumbers:
def __iter__(self):
    self.a = 1
    return self

def __next__(self):
    x = self.a
    self.a += 1
    return x

myclass = MyNumbers()
myiter = iter(myclass)

print(next(myiter))  # Output: 1
print(next(myiter))  # Output: 2

StopIteration

The StopIteration exception is raised to signal the end of the
iteration. You can specify the condition under which the iteration should stop by raising this exception.

Example:

class MyNumbers:
def __iter__(self):
    self.a = 1
    return self

def __next__(self):
    if self.a <= 5:
        x = self.a
        self.a += 1
        return x
    else:
        raise StopIteration

myclass = MyNumbers()
myiter = iter(myclass)

for x in myiter:
print(x)
# Output: 1 2 3 4 5

Python Polymorphism

Function Polymorphism

Polymorphism refers to the ability of different objects to respond to the same method in a manner that is appropriate to their type. Function polymorphism means that functions can be used with different types of arguments.

Example:

print(len("Hello"))       # Output: 5
print(len([10, 20, 30]))  # Output: 3

Class Polymorphism

Class polymorphism allows objects of different classes to be treated as objects of a common base class. It enables the use of a single interface to represent different underlying forms (data types).

Example:

class Cat:
def sound(self):
    return "Meow"

class Dog:
def sound(self):
    return "Bark"

def make_sound(animal):
print(animal.sound())

cat = Cat()
dog = Dog()

make_sound(cat)  # Output: Meow
make_sound(dog)  # Output: Bark

Inheritance Class Polymorphism

Inheritance class polymorphism refers to the ability of a child class to override methods of the parent class. This allows a child class to have its own behavior while still sharing the interface of the parent class.

Example:

class Bird:
def fly(self):
    return "Bird can fly"

class Penguin(Bird):
def fly(self):
    return "Penguin can't fly"

bird = Bird()
penguin = Penguin()

print(bird.fly())    # Output: Bird can fly
print(penguin.fly())  # Output: Penguin can't fly

Python Scope

Scope refers to the region of a program where a particular variable or name is accessible. Understanding scope is crucial for avoiding issues related to variable names and for debugging code.

Types of Scope

1. Local Scope: Variables declared inside a function or block are local to that function/block. They are only accessible within that function/block.
2. Enclosing Scope: Variables in a function enclosed by another function. This is relevant for nested functions.
3. Global Scope: Variables declared outside of all functions. They are accessible from any function in the module.
4. Built-in Scope: Variables and functions that are built into Python, such as print() and len().

Examples

Local Scope:

def local_scope_example():
    x = 10  # x is local to this function
    print(x)

local_scope_example()
# print(x)  # This will raise a NameError because x is not accessible outside the function

Enclosing Scope:

def outer_function():
    x = 10  # x is in the enclosing scope
    def inner_function():
        print(x)  # Accesses x from the enclosing scope
    inner_function()

outer_function()

Global Scope:

x = 10  # x is in the global scope

def global_scope_example():
    global x
    x = 20  # Modifies the global variable x
    print(x)

global_scope_example()
print(x)  # Output: 20

Built-in Scope:

print(len("Hello"))  # len() is a built-in function

Key Points:

• Variables defined inside a function are local to that function.
• Variables defined outside any function are global.
• Use the global keyword to modify a global variable inside a function.
• Built-in scope contains Python’s standard library functions and constants.

Python Modules

Modules are files containing Python code that can define functions, classes, and variables. Modules help organize code into reusable components.

Creating and Using Modules

Creating a Module:

Create a Python file, for example, mymodule.py, with the following content:

# mymodule.py

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

PI = 3.14159

Using a Module:

To use the functions and variables from mymodule, import it into another Python script or interactive session:

import mymodule

print(mymodule.greet("Alice"))  # Output: Hello, Alice
print(mymodule.PI)  # Output: 3.14159

Importing Specific Items:

You can import specific functions or variables from a module:

from mymodule import greet, PI

print(greet("Bob"))  # Output: Hello, Bob
print(PI)  # Output: 3.14159

Renaming Modules:

You can rename a module during import using the as keyword:

import mymodule as mm

print(mm.greet("Charlie"))  # Output: Hello, Charlie

Key Points:

• Modules help in organizing code and avoiding code duplication.
• Use import to include a module in your script.
• Use from ... import ... to import specific attributes from a module.
• Modules can be reused across different Python programs.

Python Dates

Python provides several ways to work with dates and times, primarily through the datetime module.

Using the datetime Module

Importing the Module:

import datetime

Getting the Current Date and Time:

now = datetime.datetime.now()
print(now)  # Output: Current date and time

Creating Specific Dates and Times:

d = datetime.date(2024, 8, 29)
print(d)  # Output: 2024-08-29

t = datetime.time(14, 30, 45)
print(t)  # Output: 14:30:45

Formatting Dates and Times:

now = datetime.datetime.now()
formatted_date = now.strftime("%Y-%m-%d %H:%M:%S")
print(formatted_date)  # Output: 2024-08-29 14:30:45 (example)

Parsing Dates and Times:

date_string = "2024-08-29 14:30:45"
parsed_date = datetime.datetime.strptime(date_string, "%Y-%m-%d %H:%M:%S")
print(parsed_date)  # Output: 2024-08-29 14:30:45

Date Arithmetic:

today = datetime.date.today()
tomorrow = today + datetime.timedelta(days=1)
print(tomorrow)  # Output: 2024-08-30

yesterday = today - datetime.timedelta(days=1)
print(yesterday)  # Output: 2024-08-28

Key Points:

• The datetime module provides classes for manipulating dates and times.
• datetime.datetime.now() returns the current date and time.
• strftime() is used to format dates and times as strings.
• strptime() is used to parse dates and times from strings.
• timedelta allows for date arithmetic, like adding or subtracting days.

Practice Exercises

Here are practice exercises for each of the topics:

Python Lambda

1. Basic Lambda Function: Write a lambda function that takes two arguments and returns their sum. Test the function with different pairs of numbers.
2. Using Lambda with Filter: Create a list of integers from 1 to 20. Use filter() and a lambda function to get a list of only the even numbers.
3. Lambda with Map: Write a lambda function that squares each number in a list. Use map() to apply this function to a list of integers.
4. Lambda with Reduce: Use reduce() and a lambda function to calculate the product of all numbers in a list.

Python Arrays

1. Array Creation: Create an array of 10 integers. Access the 3rd and 7th elements and print them.
2. Array Length: Write a program that takes an array as input and prints its length.
3. Looping through Array: Create an array of strings and use a loop to print each element.
4. Adding/Removing Elements: Add two elements to an array and then remove one. Print the final array.
5. Array Methods: Use the append(), pop(), and reverse() methods on an array and observe the results.

Python Classes and Objects

1. Create a Class: Define a Car class with attributes like make, model, and year. Create an object of the class and print its details.
2. Object Methods: Add a method to the Car class that prints a message with the car’s details. Call this method on an object.
3. Modify Object Properties: Write a method in the Car class to update the car’s year. Test this method.
4. Delete Object Properties: Practice deleting an object property and handle the scenario where you try to access the deleted property.
5. Use the pass Statement: Create an empty class Person using the pass statement and create an object of this class.

Python Inheritance

1. Create Parent and Child Classes: Define a Vehicle class and a Car class that inherits from Vehicle. Add some attributes and methods to both classes.
2. Add the __init__() Function: Override the __init__() function in the Car class and call the parent class’s __init__() function using super().
3. Use the super() Function: Add a method in the Vehicle class and call it from the Car class using super().
4. Inheritance and Methods: Add a method to the parent class that gets overridden in the child class. Demonstrate how to call the parent method from the child class.

Python Iterators

1. Iterator vs Iterable: Create a list (iterable) and obtain an iterator from it. Use next() to iterate over the elements.
2. Looping Through an Iterator: Write a loop to iterate over a list using an iterator instead of directly iterating over the list.
3. Create an Iterator: Create a custom iterator that returns numbers, starting from 1, and increasing by 2 until a maximum of 10.
4. Handle StopIteration: Modify the iterator to raise StopIteration when it reaches a value greater than 10.

Python Polymorphism

1. Function Polymorphism: Create two functions with the same name but different parameters and demonstrate function polymorphism.
2. Class Polymorphism: Create two different classes, each with a method named describe(). Call this method on instances of both classes to demonstrate polymorphism.
3. Inheritance Class Polymorphism: Use inheritance to demonstrate polymorphism, where a method in the child class overrides a method from the parent class.

Python Scope

1. Local vs Global Scope: Write a function that modifies a global variable. Test the function to see how the variable’s value changes.
2. Global Keyword: Use the global keyword inside a function to modify a global variable.
3. Nonlocal Keyword: Write a nested function and use the nonlocal keyword to modify a variable in the enclosing function’s scope.
4. Scope Resolution: Create a function with a variable, a global variable, and a built-in variable (like len). Show how Python resolves names using LEGB (Local, Enclosing, Global, Built-in) rule.

Python Modules

1. Create and Import a Module: Create a Python file with some functions and import it into another file to use the functions.
2. Using Standard Library Modules: Write a program that uses the math and random modules to perform some calculations.
3. Renaming a Module: Import a module with an alias using the as keyword and use it in your program.
4. From Import: Use the from keyword to import only specific functions from a module and test them.

Python Dates

1. Current Date and Time: Write a program that prints the current date and time using the datetime module.
2. Formatting Dates: Use the strftime() method to format the current date in different ways (e.g., DD-MM-YYYY).
3. Date Arithmetic: Create two dates and calculate the difference between them. Add or subtract days from a date and print the result.
4. Parsing Dates: Write a program that converts a string representing a date into a datetime object using strptime().

These exercises should help solidify understanding of each topic through practical application.

WEEK 5:

Welcome to Week 5 of our Python Bootcamp! After building a solid foundation with the basics and delving into core programming concepts, we’re now ready to explore some specialized topics that will further enhance your Python skills.

This week, we’ll be covering a range of important topics designed to round out your programming toolkit and prepare you for real-world scenarios. From working with mathematical functions and handling JSON data, to managing packages with PIP, and implementing robust error handling, we’re diving into practical aspects that every proficient Python developer should know.

Here’s what’s on the agenda for Week 5:

• Math: Learn about built-in math functions and the math module to perform advanced calculations.
• JSON: Understand how to work with JSON data, including parsing, converting, and formatting.
• PIP: Explore how to use Python’s package installer to manage external libraries and dependencies.
• Error Handling: Master techniques to handle exceptions gracefully and ensure your code is resilient.
• Python User Input: Get hands-on experience with capturing and processing user input.
• String Formatting: Discover various methods to format strings, including F-strings and the format() method.

Each topic is accompanied by practical exercises to help solidify your understanding and apply what you’ve learned. Dive in, experiment, and take your Python skills to the next level!

Let’s continue our journey and build on the skills you’ve acquired so far. Happy coding!

Python Math

In Python, working with mathematical operations and functions is essential for various programming tasks. Python provides built-in capabilities for basic arithmetic and also has a math module for more advanced mathematical functions.

Built-in Math Functions

Python’s built-in math functions cover fundamental arithmetic operations, including addition, subtraction, multiplication, and division. Here are some examples:

Basic Arithmetic Operations:

# Addition
a = 5
b = 3
result = a + b
print("Addition:", result) # Output: 8

# Subtraction
result = a - b
print("Subtraction:", result) # Output: 2

# Multiplication
result = a * b
print("Multiplication:", result) # Output: 15

# Division
result = a / b
print("Division:", result) # Output: 1.6666666666666667

# Integer Division
result = a // b
print("Integer Division:", result) # Output: 1

# Modulus
result = a % b
print("Modulus:", result) # Output: 2

# Exponentiation
result = a ** b
print("Exponentiation:", result) # Output: 125

Absolute Value:

num = -7
abs_value = abs(num)
print("Absolute Value:", abs_value) # Output: 7

The Math Module

The math module provides access to mathematical functions and constants that are not available in the basic arithmetic operations. To use it, you’ll need to import the module.

Importing the Math Module: import math

Common Functions in the math Module:

• Square Root
• Factorial
• Power Function
• Logarithms
• Constants:

number = 16
sqrt_value = math.sqrt(number)
print("Square Root:", sqrt_value) # Output: 4.0

number = 5
factorial_value = math.factorial(number)
print("Factorial:", factorial_value) # Output: 120

base = 2
exponent = 3
power_value = math.pow(base, exponent)
print("Power Function:", power_value) # Output: 8.0

value = 100
log_value = math.log(value, 10) # Base 10 logarithm
print("Logarithm Base 10:", log_value) # Output: 2.0

print("Pi:", math.pi) # Output: 3.141592653589793
print("Euler's Number:", math.e) # Output: 2.718281828459045

Working with JSON in Python

JSON (JavaScript Object Notation) is a popular data format used for data interchange between systems. In Python, you can work with JSON data easily using the json module, which provides functions for parsing JSON strings and converting them into Python objects, as well as converting Python objects into JSON strings.

JSON in Python

Importing the json Module: import json

Basic JSON Operations:

Parsing JSON – Convert from JSON to Python: JSON strings can be converted into Python dictionaries or lists. Here’s how you can parse a JSON string:

json_string = '{"name": "John", "age": 30, "city": "New York"}'
python_dict = json.loads(json_string)
print("Python Dictionary:", python_dict)

Converting from Python to JSON: Python dictionaries or lists can be converted into JSON strings:

python_dict = {"name": "Jane", "age": 25, "city": "San Francisco"}
json_string = json.dumps(python_dict)
print("JSON String:", json_string)

Formatting the Result:

You can format the JSON output for better readability by using the indent parameter:

python_dict = {"name": "Alice", "age": 28, "city": "Chicago"}
json_string = json.dumps(python_dict, indent=4)
print("Formatted JSON String:", json_string)

Ordering the Result:

To sort the keys in the JSON output, use the sort_keys parameter:

python_dict = {"name": "Bob", "age": 35, "city": "Seattle"}
json_string = json.dumps(python_dict, sort_keys=True, indent=4)
print("Sorted JSON String:", json_string)

Understanding PIP in Python

PIP is the package installer for Python. It allows you to install and manage additional packages that are not included in the standard library. This is essential for extending the functionality of your Python environment with third-party libraries.

Note: This can go little complex, so try YouTubing videos on how to install it.

Key Concepts

1. What is PIP?PIP is a command-line tool that simplifies the installation and management of Python packages. It connects to the Python Package Index (PyPI), where thousands of third-party packages are hosted.
2. What is a Package?A package is a collection of modules and libraries that can be used to extend the functionality of Python. Packages can include code, documentation, and other resources.

PIP Commands and Usage

1. Check if PIP is Installed
   • On Windows: Open Command Prompt and run: pip --version
   • On macOS/Linux: Open Terminal and run: pip3 --version

If PIP is installed, you will see the version number. If not, you’ll need to install it.

Install PIP

If PIP is not installed, you can install it by following the instructions for your operating system. Typically, PIP is included with Python installations. If it is not available, you can install it using the following methods:

On Windows/macOS/Linux (Python 3.4 and later): Download the get-pip.py script from the official site and run it:

python get-pip.py

Download a Package To install a package, use the install command followed by the package name. For example, to install the requests library: pip install requests

To install a specific version of a package: pip install requests==2.25.1

Using a Package

After installing a package, you can use it in your Python scripts. For example, using the requests library to make a simple HTTP request:

import requests

response = requests.get('https://api.github.com')
print(response.json())

Find Packages

To search for packages on PyPI, use the search command:

pip search package_name

Remove a Package

To uninstall a package:

pip uninstall requests

List Installed Packages

To see a list of installed packages:

pip list

Error Handling in Python

Error handling is crucial in programming to manage unexpected situations and errors gracefully. Python uses exceptions to handle errors that occur during runtime. This allows your program to continue running or shut down gracefully without crashing.

Key Concepts

Try Except Block

The try block lets you test a block of code for errors. The except block lets you handle the error if one occurs.

try:
  result = 10 / 0
except ZeroDivisionError:
  print("Cannot divide by zero!")

Exception Handling

You can catch multiple exceptions by specifying multiple except blocks. This allows you to handle different types of errors separately.

try:
   value = int("abc")
except ValueError:
   print("Invalid input. Please enter a number.")
except ZeroDivisionError:
   print("Cannot divide by zero!")

Else

The else block, if included, will run if no exceptions are raised in the try block.

try:
  result = 10 / 2
except ZeroDivisionError:
  print("Cannot divide by zero!")
else:
  print("Division successful. Result:", result)

Finally

The finally block will execute no matter what, whether an exception occurred or not. This is often used for cleanup actions.

try:
   file = open("example.txt", "r")
except FileNotFoundError:
   print("File not found.")
finally:
   file.close()

Raise an Exception

You can raise an exception manually using the raise keyword. This is useful for enforcing conditions within your code.

def divide(x, y):
    if y == 0:
       raise ValueError("Cannot divide by zero!")
    return x / y

try:
    result = divide(10, 0)
except ValueError as e:
    print(e)

Python User Input

User input allows you to interact with your program by accepting data from the user. Python provides the input() function to capture user input from the command line.

Key Concepts

Basic User Input

The input() function reads a line from input, converts it to a string, and returns it. You can prompt the user with a message.

name = input("Enter your name: ")
print("Hello, " + name + "!")

Converting User Input

By default, input() returns data as a string. To work with numbers or other data types, convert the input using functions like int(), float(), etc.

age = int(input("Enter your age: "))
print("You are", age, "years old.")

Handling User Input Errors

Use error handling to manage invalid input, such as non-numeric values when expecting a number.

try:
   age = int(input("Enter your age: "))
except ValueError:
   print("Invalid input. Please enter a numeric value.")

String Formatting in Python

String formatting is a technique used to insert values into strings, making them more readable and dynamic. Python provides several methods for formatting strings.

Key Concepts

F-Strings (Python 3.6+)

F-strings are a modern and convenient way to format strings. They are prefixed with f and use curly braces {} to include expressions inside strings.

name = "Alice"
age = 30
message = f"Hello, {name}! You are {age} years old."
print(message)

Placeholders and Modifiers

You can use placeholders and modifiers to format numbers, dates, and other data types

pi = 3.14159265358979
print(f"Pi rounded to two decimal places: {pi:.2f}")

Perform Operations in F-Strings

You can perform operations and call functions directly within f-strings.

width = 10
height = 5
area = width * height
print(f"The area of the rectangle is {area}.")

Execute Functions in F-Strings

You can also execute functions and expressions within f-strings.

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

print(f"{greet('Bob')} How are you?")

String format() Method

The format() method provides an alternative way to format strings. It uses curly braces {} as placeholders.

name = "Alice"
age = 30
message = "Hello, {}! You are {} years old.".format(name, age)
print(message)

Multiple Values and Indexes

You can use indexed placeholders to format multiple values or reorder them.

message = "{1} is the best programming language, according to {0}."
print(message.format("Python", "Python"))

You can also use named indexes for more readability.

message = "{name} is {age} years old."
print(message.format(name="Alice", age=30))

Practice Exercises

Python Math

1. Calculating Areas Write a Python script that calculates the area of a circle and a rectangle. Use the built-in math module for the circle’s area. Prompt the user to enter the radius of the circle and the length and width of the rectangle.
2. Quadratic Equation Solver Write a script that solves a quadratic equation of the form ax^2 + bx + c = 0. Prompt the user to enter values for a, b, and c, and use the math module to calculate the roots.

JSON

1. Convert Python to JSON Create a Python dictionary with sample data (Name: Alex, Age: 25, Country: Singapore) and convert it to a JSON string using the json module. Print the JSON string.
2. Parse JSON Parse a JSON string {“name”: “Bob”, “age”: 25, “city”: “Los Angeles”} to a Python dictionary and access its values. Use the following JSON string for this exercise.
3. Format and Order JSON Create a Python dictionary, convert it to JSON, and format the JSON output with sorted keys. Can use: data = { “city”: “San Francisco”, “age”: 40, “name”: “Charlie” }

Error Handling

1. Basic Exception Handling Write a script that prompts the user for two numbers and divides the first by the second. Handle division by zero and invalid input errors.

Python User Input

1. User Profile Write a script that collects the user’s name, age, and favorite hobby. Print a formatted profile summary.

String Formatting

1. String Formatting with F-Strings Use f-strings to format a report card with the student’s name, subject, and grade

These exercises should give you a solid understanding of Python’s advanced topics and help you practice important concepts in a hands-on way.

WEEK 6:

Welcome to the final week of our Python Bootcamp! Over the past weeks, you’ve built a strong foundation in Python, covering everything from basic syntax to advanced topics. In Week 6, we’ll focus on practical skills that are essential for real-world programming. This includes handling files, leveraging external libraries to extend Python’s capabilities, and interacting with APIs to build powerful applications.

• File Handling
• Working with External Libraries
• Working with APIs
• Final Practice Project Ideas

File Handling

File handling is a fundamental aspect of programming, allowing you to read from and write to files on your system. Python provides built-in functions and methods to work with files efficiently.

Opening and Closing Files

• Opening a File:

file = open('example.txt', 'r') # 'r' for read mode

• Closing a File:

file.close()

Reading from Files

Reading the Entire File:

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.strip())

Reading Specific Number of Characters:

with open('example.txt', 'r') as file:
        content = file.read(100) # Reads first 100 characters
        print(content)

with open('example.txt', 'w') as file:
        file.write('Hello, World!')

Appending to a File:

with open('example.txt', 'a') as file:
        file.write('\nAppended text.')

Working with Different Modes

Modes:

• 'r': Read (default mode)
• 'w': Write (overwrites existing content)
• 'a': Append (adds to existing content)
• 'r+': Read and write

File Methods

• readline(): Reads a single line from the file.
• readlines(): Reads all lines and returns a list.

#readline()
with open('example.txt', 'r') as file:
     line = file.readline()
     print(line)

#readlines()
with open('example.txt', 'r') as file:
     lines = file.readlines()
     print(lines)

Handling Exceptions

Try-Except Blocks:

try:
   with open('nonexistent.txt', 'r') as file:
      content = file.read()
except FileNotFoundError:
   print("File not found.")

Working with File Paths

Using os Module:

import os

# Get current working directory
cwd = os.getcwd()
print("Current Working Directory:", cwd)

# Check if a file exists
if os.path.exists('example.txt'):
   print("File exists.")
else:
   print("File does not exist.")

Working with External Libraries

External libraries extend Python’s capabilities, allowing you to perform specialized tasks without reinventing the wheel. Here’s a comprehensive list of popular external libraries, along with their primary use cases, to enhance your Python projects.

1. NumPy
   • Description: Fundamental package for numerical computations in Python.
   • Use Cases:
     • Handling large, multi-dimensional arrays and matrices.
     • Performing mathematical operations on arrays.
     • Supporting advanced mathematical functions like linear algebra and Fourier transforms.
2. Pandas
   • Description: Data manipulation and analysis library.
   • Use Cases:
     • Working with structured data in the form of DataFrames.
     • Reading and writing data between in-memory data structures and different file formats (CSV, Excel, SQL databases).
     • Data cleaning and preparation.
3. Matplotlib
   • Description: Comprehensive library for creating static, animated, and interactive visualizations.
   • Use Cases:
     • Plotting data in various chart types (line, bar, histogram, scatter).
     • Customizing plots with titles, labels, legends, and annotations.
     • Saving figures in different formats (PNG, PDF).
4. Seaborn
   • Description: Statistical data visualization library based on Matplotlib.
   • Use Cases:
     • Creating attractive and informative statistical graphics.
     • Visualizing complex datasets with ease.
     • Enhancing Matplotlib plots with additional functionality and better aesthetics.
5. Requests
   • Description: Simplifies HTTP requests in Python.
   • Use Cases:
     • Interacting with web services and APIs.
     • Sending HTTP methods like GET, POST, PUT, DELETE.
     • Handling HTTP responses and errors gracefully.
6. Beautiful Soup
   • Description: Library for parsing HTML and XML documents.
   • Use Cases:
     • Web scraping and data extraction from web pages.
     • Navigating and searching through parse trees.
     • Handling poorly formatted or invalid markup.
7. Scrapy
   • Description: Fast and powerful web crawling and scraping framework.
   • Use Cases:
     • Building scalable web spiders to extract structured data.
     • Managing requests, handling concurrency, and storing scraped data.
     • Customizing scraping rules and pipelines.
8. Tkinter
   • Description: Standard Python interface to the Tk GUI toolkit.
   • Use Cases:
     • Creating graphical user interfaces (GUIs) for applications.
     • Designing windows, dialogs, buttons, menus, and other widgets.
     • Event-driven programming with callbacks.
9. PyQt / PySide
   • Description: Set of Python bindings for the Qt application framework.
   • Use Cases:
     • Developing cross-platform desktop applications with rich user interfaces.
     • Accessing Qt’s features like signals and slots, graphics, and animations.
     • Building complex GUI applications with advanced functionality.
10. OpenCV
    • Description: Open Source Computer Vision Library.
    • Use Cases:
      • Real-time computer vision applications.
      • Image and video processing, such as filtering, transformations, and feature detection.
      • Facial recognition, object identification, and motion tracking.
11. PyTorch
    • Description: Open-source machine learning library for Python.
    • Use Cases:
      • Building and training neural networks.
      • Deep learning research and development.
      • Implementing complex models for computer vision and natural language processing.
12. TensorFlow
    • Description: End-to-end open-source platform for machine learning.
    • Use Cases:
      • Developing machine learning models.
      • Training and deploying deep neural networks.
      • Serving models in production environments.
13. Flask
    • Description: Lightweight web application framework.
    • Use Cases:
      • Building simple to moderately complex web applications.
      • Creating RESTful APIs.
      • Rapid prototyping and development.
14. Django
    • Description: High-level Python web framework.
    • Use Cases:
      • Developing complex, database-driven websites.
      • Implementing authentication, content administration, and session management.
      • Following the Model-View-Template (MVT) architectural pattern.
15. SQLAlchemy
    • Description: SQL toolkit and Object-Relational Mapping (ORM) library.
    • Use Cases:
      • Interacting with databases using Python objects.
      • Writing database-agnostic code.
      • Managing database sessions and transactions.
16. Celery
    • Description: Asynchronous task queue/job queue.
    • Use Cases:
      • Running background tasks and scheduling.
      • Distributing workload across multiple workers.
      • Handling real-time processing.
17. Paramiko
    • Description: SSHv2 protocol library.
    • Use Cases:
      • Connecting to remote servers via SSH.
      • Automating remote command execution.
      • Secure file transfers (SFTP).
18. scikit-learn
    • Description: Machine learning library for Python.
    • Use Cases:
      • Implementing classification, regression, clustering algorithms.
      • Performing data preprocessing and model evaluation.
      • Building predictive data analysis applications.
19. NLTK (Natural Language Toolkit)
    • Description: Platform for building Python programs to work with human language data.
    • Use Cases:
      • Text processing and analysis.
      • Tokenization, parsing, semantic reasoning.
      • Building language models and sentiment analysis.
20. PyGame
    • Description: Set of Python modules designed for writing video games.
    • Use Cases:
      • Developing simple 2D games.
      • Handling graphics, sound, and user input.
      • Learning game development concepts.

Working with APIs

APIs (Application Programming Interfaces) allow you to interact with external services and data sources programmatically.

Understanding APIs

• APIs define rules for how applications can communicate.
• Common data formats: JSON, XML.

Making API Requests

• Use the requests library to make HTTP requests.

import requests

response = requests.get(‘https://api.example.com/data’)
data = response.json()
print(data)

Example: Fetching Weather Data

1. Sign Up for an API Key
   • Use a weather API like OpenWeatherMap.
2. Making the Request

import requests

api_key = ‘your_api_key’
city = ‘London’
url = f’http://api.openweathermap.org/data/2.5/weather?q={city}&appid={api_key}’

response = requests.get(url)
weather_data = response.json()
print(weather_data)

Parsing the Data

temp = weather_data[‘main’][‘temp’]
description = weather_data[‘weather’][0][‘description’]
print(f”Temperature: {temp}”)
print(f”Description: {description}”)

Handling API Errors

• Check the status code:

if response.status_code == 200:
# Success
else:
print(“Error fetching data:”, response.status_code)

Practice Exercises

File Handling

• Word CountWrite a program that reads a text file and counts the number of words in it.
• Copy FileCreate a script that copies the content from one file to another.
• Remove VowelsRead a file and create a new file that contains the text with all vowels removed.

Working with APIs 

•  GitHub API
  • Fetch your GitHub profile data using the GitHub API.
  • Display your public repositories.

Final Practice Project Ideas

As we wrap up the bootcamp, it’s time to apply everything you’ve learned. Here are some project ideas to help you build your skills:

Project Ideas

1. To-Do List Application
   • Description: Create a command-line to-do list application that allows users to add, view, and delete tasks. Use file handling to save tasks between sessions.
   • Skills Practiced: File handling, user input, exception handling.
2. Personal Budget Tracker
   • Description: Build a program that tracks income and expenses. Users can input transactions, and the program will calculate the balance. Optionally, use Pandas for data manipulation and Matplotlib for visualization.
   • Skills Practiced: File handling, external libraries (Pandas, Matplotlib), data analysis.
3. Weather Forecast App
   • Description: Develop a console application that fetches and displays the weather forecast for a given city using a weather API.
   • Skills Practiced: Working with APIs, JSON parsing, error handling.
4. Web Scraper for Product Prices
   • Description: Create a script that scrapes product prices from an e-commerce website and saves the data into a CSV file.
   • Skills Practiced: Web scraping (Beautiful Soup), file handling, data storage.
5. Simple Game using PyGame
   • Description: Design a simple game like “Snake” or “Pong” using the PyGame library.
   • Skills Practiced: External libraries (PyGame), event handling, game logic.
6. Contact Management System
   • Description: Build a program that allows users to add, search, and delete contacts. Store contacts in a CSV or JSON file.
   • Skills Practiced: File handling, data manipulation, user input.

Tips for Success

• Plan Your Project:
  • Outline the features you want to include.
  • Break the project into smaller, manageable tasks.
• Use Version Control:
  • Consider using Git to track changes.
• Document Your Code:
  • Write comments and docstrings for functions and classes.
• Test Thoroughly:
  • Test your program with different inputs to ensure reliability.

Conclusion

Congratulations on completing our Python Bootcamp!  You’ve journeyed through the essentials of Python programming, from fundamental concepts to advanced topics. Here’s a quick recap of what you’ve learned:

• Python Basics: Variables, data types, operators, and control flow.
• Data Structures: Lists, tuples, sets, dictionaries, and arrays.
• Functions and Modules: Defining functions, using built-in and external modules.
• Object-Oriented Programming: Classes, objects, inheritance, and polymorphism.
• Advanced Topics: Error handling, user input, string formatting, and regular expressions.
• File Handling: Reading from and writing to files.
• External Libraries: Utilizing powerful libraries to extend Python’s capabilities.
• Working with APIs: Interacting with external services and data sources.

Next Steps:

• Keep Practicing: Apply your knowledge by building projects and solving problems.
• Explore Further: Delve into specialized areas like web development, data science, or machine learning.
• Stay Updated: Follow Python communities, blogs, and updates to stay informed about new developments.
• Engage with Others: Join forums, contribute to open-source projects, and collaborate with other programmers.

Thank you for being part of this bootcamp. Your dedication and hard work have brought you to this point, and we’re excited to see where your Python journey takes you next. Keep coding, stay curious, and continue to challenge yourself!

Best of luck in all your future endeavors!