ISBN - VALIDATOR

Skill 1: Variable Assignment

Explanation of the Skill:

In programming, variables are used to store data that can change or be used later in the program. You can think of variables as "storage boxes" where you can keep different types of data. When you assign a value to a variable, you're essentially labeling a storage space with a name.

For example, imagine you have a box labeled "age" where you store the number 25. The box "age" now holds that value, and you can refer to it whenever you need to.

How to Write:

In Python, you assign a value to a variable using the = symbol. The variable name goes on the left side, and the value you want to store goes on the right.

Example

age = 25

name = "Alice"

is_active = True

Explanation of each line:

• age = 25: Here, age is the variable name, and 25 is the value assigned to it.

• name = "Alice": The name variable is assigned the string "Alice".

• is_active = True: This variable is a boolean type, and True is a special value representing truth.

Explanation:

• Variable names can be anything you like, but there are some rules: they must start with a letter or an underscore (_), and the rest of the name can include letters, numbers, or underscores.

• The value inside the variable can be anything like numbers (25), text ("Alice"), or even boolean values like True or False.

• Variables make it easy to store and reuse data throughout your program.

Skill 2: Data Types

Explanation of the Skill:

Data types tell the program what kind of value a variable is holding. In Python, there are several common data types such as integers (whole numbers), strings (text), and booleans (true/false values).

• Integers: Whole numbers, like 25, -5, 100.

• Strings: Text, such as "Hello", "Alice".

• Booleans: Represent truth values, either True or False.

You need to know the data types because they determine what kind of operations you can perform on the values.

How to Write:

In Python, the data type is automatically assigned when you assign a value to a variable. You don't need to specify it explicitly, but you should understand which data type you’re working with.

Example:

age = 25 # Integer

name = "Alice" # String

is_active = True # Boolean

Explanation of each line:

• age = 25: The variable age is an integer because the value is a whole number.

• name = "Alice": The variable name is a string because it contains text.

• is_active = True: The variable is_active is a boolean because it holds a truth value.

Explanation:

• Strings are always enclosed in quotation marks (" " or ' '), so "Alice" is a string, but Alice without quotes is not.

• Booleans are useful when you need to represent true or false conditions. For example, is_active = True means the user is active.

• Knowing data types helps you handle data properly, for example, you can't add a string and an integer directly.

Skill 3: Print Statements

Explanation of the Skill:

Print statements are used to output data to the console, which is very helpful for checking the results of your program or debugging. When you "print" something in Python, you show the value of variables, text, or any other data on the screen.

How to Write:

You use the print() function to display something on the screen. You place what you want to display inside the parentheses.

Example:

print("Hello, world!")

print(age)

print("Your name is", name)

Explanation of each line:

• print("Hello, world!"): This prints the string "Hello, world!" to the screen.

• print(age): This prints the value stored in the variable age, which is 25.

• print("Your name is", name): This prints the string "Your name is" followed by the value in name, which is "Alice".

Explanation:

• The print() function takes whatever is inside the parentheses and displays it.

• You can print strings directly, or you can print variables (like age or name).

• You can print multiple items in a single statement by separating them with commas. Python will automatically add a space between them when it prints.

Skill 4: Defining Functions

Explanation of the Skill:

A function is a block of reusable code that performs a specific task. Functions are important because they allow you to write a piece of code once and use it many times throughout your program. They help keep your code organized and efficient.

A function can take input (called parameters) and return an output (called a return value).

How to Write:

You define a function using the def keyword, followed by the function name and parentheses. You can optionally include parameters inside the parentheses, and the function's code goes inside the body (indented).

Example:

def greet(name):

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

Explanation of each line:

• def greet(name):: This line defines a function named greet. The function takes one parameter name.

• print("Hello, " + name + "!"): This is the body of the function. It prints a greeting using the name parameter.

Explanation:

• def is the keyword used to define a function.

• The parameter name inside the parentheses acts like a placeholder for the value you will pass to the function when you call it.

• Inside the function, the code is indented to show it belongs to the function.

• When you call greet("Alice"), the value "Alice" replaces name, and the function prints "Hello, Alice!".

Skill 5: Using parameters

Explanation of the Skill:

When you define a function, you can pass parameters into it. A parameter is like a placeholder, a variable that the function will use when it runs. You can then use this parameter inside the function to perform calculations, make decisions, or even pass it to other functions.

When you call the function, you give it a value for each parameter, and the function uses that value as if it were a regular variable.

How to Write:

You pass a parameter into a function by including it in the function definition. Then, when you call the function, you provide a value to replace the parameter.

Example:

def greet(name):

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

greet("Alice")

Explanation of each line:

• def greet(name):: The function greet is defined with one parameter name.

• print("Hello, " + name + "!"): The function uses the value of name (which will be passed when we call the function).

• greet("Alice"): We call the function and pass the value "Alice" for name. The function prints "Hello, Alice!".

Explanation:

• Passing parameters is how we give a function the information it needs to work.

• The function can have multiple parameters, separated by commas (e.g., def greet(name, age):).

• Inside the function, you can use the parameters just like regular variables. They are only "active" inside that function.

Skill 6: Returning Values from Functions

Explanation of the Skill:

A return value is the result a function gives back after it has finished running. Instead of just printing something, a function can return a result, which can be stored in a variable or used later in your program.

How to Write:

You use the return keyword inside a function to send a value back to the place where the function was called.

Example:

def add(a, b):

return a + b

result = add(5, 3)

print(result)

Explanation of each line:

• def add(a, b):: The function add is defined with two parameters, a and b.

• return a + b : The function returns the sum of a and b (instead of printing it).

• result = add(5, 3): We call the function with 5 and 3 as arguments, and store the return value in the variable result.

• print(result): We print the result, which is 8.

Explanation:

• The return statement gives back a result to wherever the function was called.

• You can return anything: numbers, strings, lists, or even other functions.

• When you call a function that has a return statement, it gives back the value that was returned, and you can use it later in your program.

Skill 7: Calling Functions

Explanation of the Skill:

Once a function is defined, you can use it by calling it. Calling a function means telling the program to execute the code inside that function. You can call a function anywhere in your program and provide arguments if needed.

How to Write:

To call a function, simply use its name followed by parentheses. If the function takes parameters, pass the arguments inside the parentheses.

Example:

def greet(name):

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

greet("Alice")

greet("Bob")

Explanation of each line:

• def greet(name):: The function greet is defined.

• print("Hello, " + name + "!"): Inside the function, we print a greeting with the name passed as a parameter.

• greet("Alice"): This is the first call to the function, and "Alice" is passed as an argument.

• greet("Bob"): This is the second call to the function, and "Bob" is passed as an argument.

Explanation:

• Calling a function runs the code inside it.

• If a function takes parameters, you need to pass the correct values when calling it.

• You can call the same function multiple times with different arguments to perform the same task with different data.

Skill 8: String Methods

Explanation of the Skill:

String methods are built-in functions that allow you to manipulate and interact with strings in Python. These methods help you modify, check, and format strings.

Common string methods include:

• .join(): Combines a list of strings into a single string.

• .isdigit(): Checks if a string is made up of digits.

• .upper(): Converts all characters in a string to uppercase.

• len(): Returns the length (number of characters) of a string.

How to Write:

These methods are used by calling them on a string (or a list of strings) and placing parentheses after them. Here's how you can use each method:

Example:

# Using .join() to combine a list of strings

words = ["Hello", "world"]

sentence = " ".join(words) print(sentence)

# Output: Hello world

# Using .isdigit() to check if a string is a number

is_number = "123".isdigit()

print(is_number)

# Output: True

# Using .upper() to convert a string to uppercase

shouted = "hello".upper()

print(shouted)

# Output: HELLO

# Using len() to find the length of a string

length = len("hello")

print(length)

# Output: 5

Explanation:

• .join() takes a list of strings and joins them together with a specified separator. In this example, we use " ".join(words) to combine the words in the list with spaces between them.

• .isdigit() checks whether all the characters in a string are digits. For example, "123".isdigit() returns True, but "abc".isdigit() returns False.

• .upper() converts the entire string to uppercase. It’s useful when you want to change the case of text.

• len() is used to find out how many characters are in a string. It returns an integer representing the length of the string.

Skill 9: Lists (What a List Is and Syntax for Lists)

Explanation of the Skill:

A list is a collection of items that are ordered and changeable. Lists can store multiple types of data, including numbers, strings, or even other lists. Lists are one of the most useful data structures in Python.

How to Write:

You define a list by placing items inside square brackets [], separated by commas.

Example:

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

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

mixed_list = [1, "apple", True]

Explanation of each line:

• fruits = ["apple", "banana", "cherry"]: This list contains three strings.

• numbers = [1, 2, 3, 4, 5]: This list contains five integers.

• mixed_list = [1, "apple", True]: This list contains an integer, a string, and a boolean value.

Explanation:

• Lists can hold items of any data type and are ordered, meaning the order in which you add items is maintained.

• You can access individual items in a list by using their index, starting from 0 (e.g., fruits[0] would return "apple").

• Lists are mutable, meaning you can change their contents after they're created (e.g., you can add, remove, or modify items).

Skill 10: For Loops

Explanation of the Skill:

A for loop is used to iterate over a sequence (like a list, string, or range) and execute a block of code multiple times. It's useful when you want to perform a repetitive task without writing the same code over and over.

How to Write:

The general syntax of a for loop looks like this:

for variable in sequence:

# code to execute

Example:

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

for fruit in fruits:

print(fruit)

Explanation of each line:

• fruits = ["apple", "banana", "cherry"]: We define a list fruits with three items.

• for fruit in fruits:: This for loop iterates over each item in the fruits list. Each time the loop runs, the current item is assigned to the variable fruit.

• print(fruit): This line prints the value of fruit each time the loop runs, so the output will be each fruit in the list.

Explanation:

• A for loop allows you to run the same block of code for each item in a sequence, whether it's a list, string, or range.

• The variable in the loop (fruit in the example) is temporarily assigned the value of each item in the sequence one by one.

• The code inside the loop runs for every element in the sequence.

Skill 11: Iterating through a list (with a for loop)

Explanation of the Skill:

When you use a for loop to go through a list, the loop temporarily assigns each element in the list to a temporary variable. This temporary variable allows you to work with the current element of the list inside the loop.

How to Write:

Here’s how you can use a for loop to iterate through a list and use a temporary variable to work with each item:

animals = ["dog", "cat", "rabbit"]

for animal in animals:

print("I have a " + animal)

Explanation of each line:

• animals = ["dog", "cat", "rabbit"]: We define a list called animals with three strings.

• for animal in animals:: The for loop starts and each time it runs, animal takes on the value of the next item in the list ("dog", then "cat", then "rabbit").

• print("I have a " + animal): This prints the message "I have a dog", then "I have a cat", then "I have a rabbit", using the animal variable.

Explanation:

• The temporary variable (like animal in this example) holds the value of the current item in the list as the loop runs.

• The loop will run once for each item in the list, allowing you to work with each item individually.

• This is useful when you want to perform operations or tasks on each item in a list without manually addressing each one.

Skill 12: Using Range() within a for loop

Explanation of the Skill:

The range() function is commonly used with a for loop to repeat a block of code a specific number of times. range() generates a sequence of numbers, and the loop will run once for each number.

How to Write:

You can use range() to generate a sequence of numbers and use that with a for loop.

Example:

for i in range(5):

print("This is loop iteration number", i)

Explanation of each line:

• for i in range(5):: The range(5) function generates the numbers 0, 1, 2, 3, 4. The loop will run 5 times (from 0 to 4).

• print("This is loop iteration number", i): This prints the current iteration number each time the loop runs.

Explanation:

• range(5) generates the numbers 0 through 4. This means the loop will run 5 times, with i taking on values from 0 to 4 in each iteration.

• The range() function can take two additional arguments: a starting number and a step. For example, range(1, 10, 2) would generate the numbers 1, 3, 5, 7, 9.

• This method is helpful when you want to repeat a task a set number of times without needing to manually count each iteration.

Skill 13: Conditional Statements

Explanation of the Skill:

Conditional statements allow you to run different blocks of code depending on whether a condition is true or false. The most common conditional statement is the if statement.

How to Write:

The basic syntax for an if statement is:

if condition:

#code to execute if the condition is true

Example:

age = 20

if age >= 18:

print("You are an adult.")

Explanation of each line:

• age = 20: We define a variable age and assign it the value 20.

• if age >= 18:: The if statement checks if the value of age is greater than or equal to 18.

• print("You are an adult."): If the condition is true, this line of code will be executed, printing "You are an adult.".

Explanation:

• A conditional statement lets your program make decisions.

• If the condition evaluates to True, the code inside the if block will run.

• If the condition is False, the code inside the if block will be skipped.

• Conditions can be comparisons, like age >= 18, or any expression that evaluates to True or False.

Skill 14: Logic Operators (e.g., == and != in If Statements)

Explanation of the Skill:

Logic operators are used to compare values and combine multiple conditions in a conditional statement. The two most common logic operators are:

• == (equal to)

• != (not equal to)

These operators allow you to check if two values are the same or different.

How to Write:

age = 20

if age == 18:

print("You just turned 18!")

elif age != 18:

print("You did not just turn 18.")

Explanation of each line:

• age = 20: We define the variable age and assign it the value 20.

• if age == 18:: This checks if age is equal to 18. If true, the first print statement runs.

• elif age != 18:: The elif (else if) checks if age is not equal to 18. If true, the second print statement runs.

Explanation:

• == checks if two values are equal.

• != checks if two values are not equal.

• These operators are helpful when you need to compare values or perform different actions depending on whether two things are the same or different.

• You can also combine multiple conditions with and, or, and not for more complex logic.

Skill 15: If Not Statements

Explanation of the Skill:

The if not statement is used to check if a condition is false. It is the inverse of a regular if statement. Instead of checking if a condition is true, it checks if the condition is false and runs the code block if that's the case.

How to Write:

The syntax of an if not statement is:

if not condition:

# code to execute if the condition is false

Example:

age = 16

if not age >= 18:

print("You are not an adult.")

Explanation of each line:

• age = 16: We define a variable age and set it to 16.

• if not age >= 18:: This checks if age is not greater than or equal to 18. Since 16 is less than 18, the condition is True, and the code inside the if block runs.

• print("You are not an adult."): Since the condition is true (age is not greater than or equal to 18), this line will print the message.

Explanation:

• if not negates the condition. It’s like asking, “Is this condition false?”

• When the condition inside not is false, the code inside the if not block will run. If the condition is true, the code will be skipped.

• This is helpful when you want to execute code when something is not true or doesn’t happen.

Skill 16: Using and, or, not in Conditional Statements

Explanation of the Skill:

and, or, and not are logical operators used to combine or modify conditions in a conditional statement. These allow you to create more complex conditions by combining multiple checks.

• and: Returns True only if both conditions are true.

• or: Returns True if at least one condition is true.

• not: Inverts the truth value of a condition (i.e., it returns True if the condition is false, and False if the condition is true).

How to Write:

Here’s how to use and, or, and not:

age = 20

has_permission = True

if age >= 18 and has_permission:

print("You are allowed to proceed.")

Explanation of each line:

• age = 20: We define a variable age and set it to 20.

• has_permission = True: We define a variable has_permission and set it to True.

• if age >= 18 and has_permission:: This condition checks if both age >= 18 and has_permission are True. Since both are true, the code inside the if block runs.

• print("You are allowed to proceed."): Since the condition is true, this line will print the message.

Example with or:

age = 15

has_permission = True

if age >= 18 or has_permission:

print("You are allowed to proceed.")

Explanation:

• and means both conditions need to be True for the entire condition to be True.

• or means if at least one condition is True, the entire condition becomes True.

• not inverts a condition. For example, not age >= 18 will be True if age is less than 18.

• These operators are powerful for combining checks in a single if statement.

Skill 17: Using +=

Explanation of the Skill:

The += operator is a compound assignment operator that is used to add a value to an existing variable. It combines the addition operation with assignment, making it shorter and easier to write.

How to Write:

The syntax for += is:

variable += value

This is equivalent to:

variable = variable + value

Example:

score = 10

score += 5

print(score)

Explanation of each line:

• score = 10: We define a variable score and set it to 10.

• score += 5: The += operator adds 5 to the current value of score (which is 10), so score becomes 15.

• print(score): This will print 15 because the value of score was updated.

Explanation:

• += adds the value on the right side to the current value of the variable on the left side.

• This is a shorthand for writing variable = variable + value.

• It helps make code cleaner and easier to read, especially when updating variables in a loop or over multiple statements.

Skill 18: Arithmetic Operators

Explanation of the Skill:

Arithmetic operators are used to perform mathematical operations like addition, subtraction, multiplication, and division. The modulus operator (%) is used to find the remainder of a division.

How to Write:

The basic arithmetic operators are:

• + (addition)

• - (subtraction)

• * (multiplication)

• / (division)

• % (modulus)

Example:

x = 10

y = 3

print(x + y) # Addition

print(x - y) # Subtraction

print(x * y) # Multiplication

print(x / y) # Division

print(x % y) # Modulus

Explanation of each line:

• x = 10 and y = 3: We define two variables, x and y.

• x + y: Adds 10 and 3, resulting in 13.

• x - y: Subtracts 3 from 10, resulting in 7.

• x * y: Multiplies 10 and 3, resulting in 30.

• x / y: Divides 10 by 3, resulting in 3.3333 (a float).

• x % y: Finds the remainder when 10 is divided by 3, which is 1.

Explanation:

• +, -, *, and / are the basic arithmetic operators for addition, subtraction, multiplication, and division.

• % gives the remainder of the division (called the modulus). For example, 10 % 3 gives 1 because 3 fits into 10 three times, leaving a remainder of 1.

• These operators are fundamental in performing basic math operations in programming.

Skill 19: Python Methods

Explanation of the Skill:

In Python, methods are functions that are associated with objects. The int() method is used to convert a value into an integer, and the sum() method is used to calculate the sum of a collection of numbers.

How to Write:

int(): Converts a value into an integer.

value = "123"

number = int(value)

print(number)

• sum(): Calculates the sum of all elements in an iterable (like a list).

numbers = [1, 2, 3, 4]

total = sum(numbers)

print(total)

Explanation of each line:

• value = "123": We define a string value with the value "123".

• number = int(value): We use the int() method to convert the string "123" into the integer 123.

• numbers = [1, 2, 3, 4]: We define a list numbers containing four integers.

• total = sum(numbers): The sum() method calculates the sum of the numbers in the list, which is 10.

Explanation:

• int() is used to convert values into integers. For example, it can convert a string representing a number into an actual integer that can be used in mathematical operations.

• sum() takes an iterable (like a list or tuple) and returns the sum of all its elements.

• These methods are useful for converting data types or performing operations like addition on a collection of numbers.

Skill 20: Exception Handling (Value Error)

Explanation of the Skill:

In Python, exception handling allows you to deal with errors or "exceptions" that occur during program execution. ValueError is a built-in exception in Python that is raised when a function receives an argument of the correct type but an inappropriate value. The raise keyword is used to explicitly throw an exception when a certain condition is met.

How to Write:

To raise a ValueError explicitly, use the following syntax:

raise ValueError("Your error message here")

Example:

def check_age(age):

if age < 0:

raise ValueError("Age cannot be negative.")

return age

try:

check_age(-5)

except ValueError as e:

print(f"Error: {e}")

Explanation of each line:

• def check_age(age):: This defines a function check_age that checks if the age is negative.

• if age < 0:: This checks if the age is less than 0.

• raise ValueError("Age cannot be negative."): If the age is negative, this line raises a ValueError with a specific message.

• try:: The try block is where you attempt to run the code that might raise an exception.

• check_age(-5): This calls check_age with an invalid value (-5).

• except ValueError as e:: This except block catches the ValueError and stores the error message in e.

• print(f"Error: {e}"): This prints the error message.

Explanation:

• raise ValueError is used to intentionally trigger an exception when the value provided is inappropriate. In the example, we raise an error if a negative age is provided.

• try and except are used to handle the exception. The try block attempts the code, and if an error occurs, the except block catches it and prevents the program from crashing.

• Raising exceptions is important when you want to ensure that your code behaves in a specific way or prevents invalid values from being used.

Skill 21: Concatenating Strings (+ f Statements)

Explanation of the Skill:

String concatenation is the process of combining two or more strings into one. In Python, this is typically done using the + operator or formatted string literals (also called f-strings). An f-string allows you to embed expressions inside string literals, which is a convenient way to concatenate variables and text.

How to Write:

To concatenate strings, use the following syntax:

• Using + operator:

greeting = "Hello"

name = "Alice"

message = greeting + ", " + name + "!"

print(message)

• Using f-strings (preferred method in Python 3.6 and later):

greeting = "Hello"

name = "Alice"

message = f"{greeting}, {name}!"

print(message)

Explanation of each line:

• greeting = "Hello" and name = "Alice": We define two variables with string values.

• message = greeting + ", " + name + "!": This concatenates the strings using the + operator. We combine the greeting, a comma, name, and an exclamation mark into one string.

• message = f"{greeting}, {name}!": This uses an f-string to embed the values of greeting and name directly inside the string. It produces the same result as the previous line but in a cleaner way.

• print(message): This prints the final concatenated string.

Explanation:

• String concatenation is useful when you want to build a message or combine variables into a single string.

• + operator is the basic way of concatenating, but it can become cumbersome with multiple variables.

• f-strings allow for more readable and concise string formatting. Inside the curly braces {}, you can place variables or expressions, and Python will automatically insert their values into the string.

• Using f-strings is generally preferred because it's more efficient and cleaner than concatenating with +.

Skill 22: New Line Syntax (\n)

Explanation of the Skill:

The new line character (\n) is used to add a line break in a string. When you print a string containing \n, Python moves the output to a new line. This is useful when formatting text or displaying multiple lines of information.

How to Write:

To add a new line in a string, include \n where you want the line break:

message = "Hello,\nWelcome to the Python course!"

print(message)

# Output: Hello,

welcome to the python course!

Explanation of each line:

• message = "Hello,\nWelcome to the Python course!": This string contains \n, which tells Python to print the text before it on one line and the text after it on a new line.

• print(message): This prints the message, and the \n causes the text after it to appear on a new line.

Explanation:

• \n represents a new line character, which tells Python to break the string and continue printing from the next line.

• It’s commonly used when you want to format text that will be displayed in multiple lines or organize output in a more readable way.

• \n is a special character in Python that works within strings. When included, it forces the following text to appear on a new line when printed.

TASK PRIORITY MANAGER

1. Defining a List

Explanation of the Skill

A list in Python is a collection of items or values stored in a specific order. Lists are one of the most commonly used data structures because they allow you to store multiple items in a single variable. A list can contain values of different types (e.g., numbers, strings, booleans), and you can easily access or modify individual items in the list.

How to Write the Code

To define a list in Python, you use square brackets []. You can place your values inside the brackets, separated by commas.

Example Code:

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

Explain

In the above code:

• fruits is a variable that stores the list.

• The list contains three items: "apple", "banana", and "cherry".

• Each item in the list is enclosed in quotation marks because they are strings (text values).

• Lists in Python are ordered, so the order of the items is important and will be preserved.

Key Points:

• A list can hold multiple data types, such as numbers or strings.

• You can access individual items using indexes (explained later).

• Lists are mutable, meaning you can change, add, or remove items.

2. Allowing for User Input (input() method)

Explanation of the Skill

The input() function in Python allows you to get user input through the console. This function waits for the user to type something and press "Enter". The input is then returned as a string. You can ask the user to input data such as text, numbers, or other information.

How to Write the Code

The input() function is used like this:

user_input = input("Please enter something: ")

Example Code:

name = input("What is your name? ")

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

Explain

In this example:

• input("What is your name? ") displays a message to the user and waits for them to type something.

• The user types their name, and the input is stored in the variable name.

• print("Hello, " + name + "!") then prints a greeting that includes the user's input.

Key Point: The input() function always returns the value as a string, even if the user enters numbers.

Key Notes:

• You can prompt users with a message inside the input() function.

• After getting the input, you may need to convert it to another data type (e.g., using int() to convert to a number).

3. Defining a Procedure (Difference Between Procedure and Function)

Explanation of the Skill

A procedure in Python is a block of code that performs a specific task. It is similar to a function, but functions are designed to return a value, while procedures typically perform actions but do not return anything.

In Python, we define both functions and procedures using the def keyword. While a function can return a result using the return keyword, a procedure might not return anything, as its purpose is more to perform an action or modify data.

How to Write the Code

To define a procedure, use def followed by the name of the procedure and parentheses (for parameters). After the colon :, the block of code that performs the task is indented.

Example Code (Procedure):

def greet():

print("Hello!")

Example Code (Function with Return):

def add_numbers(a, b):

return a + b

Explain

• greet() is a procedure because it performs an action (printing "Hello!") but does not return any value.

• add_numbers(a, b) is a function because it performs a calculation and returns the result using return.

Key Point: Procedures and functions are similar in structure, but functions return values while procedures perform actions.

Key Notes:

• Use procedures when you just want to do something (like printing or changing a list) without returning anything.

• Use functions when you need to return a value for further use (like a calculation or string manipulation).

4. Using Parameters in Procedures

Explanation of the Skill

A parameter is a value you can pass into a procedure or function when you call it. It allows you to give specific inputs to the procedure so that it can perform tasks with those values. Parameters can be used within the procedure to perform different actions based on the input provided.

How to Write the Code

You define parameters inside the parentheses when defining the procedure. Then, when you call the procedure, you pass values that will be used as the parameters.

Example Code:

def greet(name):

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

greet("Alice")

Explain

• greet(name) is a procedure that takes one parameter, name.

• When you call greet("Alice"), "Alice" is passed as the argument to the name parameter.

• The procedure then prints a personalized greeting: "Hello, Alice!".

Key Point: Parameters allow you to pass in different values each time you call the procedure, making it flexible and reusable.

Key Notes:

• Parameters can be used within a procedure to perform actions with dynamic data.

• You can have multiple parameters in a procedure, and you can pass values for each when calling it.

5. Calling Procedures

Explanation of the Skill

Calling a procedure means executing the code inside a defined procedure. When you define a procedure, you can call it to perform the task it was designed for. Calling a procedure lets you reuse the code without needing to write it again each time you need it.

How to Write the Code

To call a procedure, simply use its name followed by parentheses. If the procedure requires parameters, pass the appropriate arguments inside the parentheses.

Example Code:

def greet(name):

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

greet("Alice")

Explain

• greet("Alice") is how you call the procedure greet().

• When greet("Alice") is called, it runs the code inside the greet procedure, which prints "Hello, Alice!".

• Procedures are reusable, so you can call greet() multiple times with different arguments, such as greet("Bob"), to personalize the greeting for different users.

Key Point: Calling a procedure runs its code and allows you to reuse the same logic with different inputs.

6. Using if..break

Explanation of the Skill

The if..break statement is used to control the flow of a program. The if statement checks if a condition is true, and if so, the break statement is used to exit a loop. This can be useful when you want to stop a loop under certain conditions, like when a user enters a specific input or when a task is complete.

How to Write the Code

The if..break statement is typically used within loops like while or for loops.

Example Code:

while True:

user_input = input("Enter 'exit' to stop: ")

if user_input == "exit":

break

print("You entered:", user_input)

Explain

• while True: starts an infinite loop, meaning it will continue running unless explicitly stopped.

• user_input = input("Enter 'exit' to stop: ") waits for user input.

• if user_input == "exit": checks if the user typed "exit".

• If the condition is true, break stops the loop and ends the program.

• If the condition is not met, the loop continues to ask for input and print the entered value.

Key Point: The break statement immediately exits the loop, even if the loop was supposed to run indefinitely.

7. Using .append() Method for Lists

Explanation of the Skill

The .append() method allows you to add new items to the end of a list. It’s a very common method used to modify lists, as it makes it easy to add elements dynamically.

How to Write the Code

To use .append(), call the method on a list and pass the item you want to add as an argument.

Example Code:

fruits = ["apple", "banana"]

fruits.append("cherry")

print(fruits)

Explain

• fruits = ["apple", "banana"] initializes a list with two items.

• fruits.append("cherry") adds the item "cherry" to the end of the list.

• print(fruits) prints the updated list: ["apple", "banana", "cherry"].

Key Point: The .append() method modifies the original list, and the new item is added at the end.

8. Using while True

Explanation of the Skill

The while True loop is an infinite loop that keeps executing its code block indefinitely, unless explicitly interrupted (e.g., with break). It’s useful when you want to keep repeating a task until a specific condition is met, such as waiting for user input or performing an action continuously until told to stop.

How to Write the Code

The while True loop is written with the while keyword followed by the condition True. Since True is always true, the loop will continue until you stop it with break.

Example Code:

counter = 0

while True:

counter += 1

print("Counter:", counter)

if counter == 5:

break

Explain

• while True: starts an infinite loop.

• counter += 1 increments the counter each time the loop runs.

• print("Counter:", counter) prints the current value of counter.

• When counter reaches 5, if counter == 5: checks the condition, and break exits the loop.

Key Point: The while True loop will continue running until a specific condition is met and a break statement is used to exit.

9. Using list()

Explanation of the Skill

The list() function in Python is used to convert other data types, such as tuples or strings, into lists. It can also be used to create an empty list. This function is useful when you need to ensure your data is in list form before performing list operations.

How to Write the Code

You can use list() to convert an iterable (like a tuple, string, or set) into a list.

Example Code:

# Convert a string to a list

string = "hello"

list_of_characters = list(string)

print(list_of_characters)

# Convert a tuple to a list

tuple_example = (1, 2, 3)

list_from_tuple = list(tuple_example)

print(list_from_tuple)

Explain

• list(string) converts the string "hello" into a list of characters: ['h', 'e', 'l', 'l', 'o'].

• list(tuple_example) converts the tuple (1, 2, 3) into the list [1, 2, 3].

• The list() function is helpful when you need to perform list-specific operations, such as adding or removing items, on data that isn't initially in list form.

Key Point: list() makes it easy to convert other data types into lists, enabling you to use list methods on them.

10. Using filter()

Explanation of the Skill

The filter() function is used to filter elements from an iterable (like a list) based on a condition. It applies a given function to each item in the iterable and returns only the items for which the function returns True.

How to Write the Code

To use filter(), you need to pass two arguments:

1. A function that defines the condition to be checked.

2. The iterable (such as a list) to filter.

Example Code:

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

even_numbers = filter(lambda x: x % 2 == 0, numbers)

even_numbers_list = list(even_numbers)

print(even_numbers_list)

Explain

• filter(lambda x: x % 2 == 0, numbers) filters the numbers list by applying the lambda function lambda x: x % 2 == 0, which returns True for even numbers and False for odd numbers.

• The filter() function returns an iterator, so we use list() to convert the result into a list.

• The output will be [2, 4, 6] because these are the even numbers in the original list.

Key Point: filter() helps you extract specific items from an iterable that meet a condition, making it useful for cleaning or organizing data.

11. Lambda Functions

Explanation of the Skill

A lambda function is a small anonymous function defined with the lambda keyword. It’s typically used for short-term, simple operations that can be passed as arguments to functions like filter(), map(), or sorted().

How to Write the Code

A lambda function is written using the syntax lambda arguments: expression. It takes one or more arguments and returns the result of an expression.

Example Code:

add = lambda x, y: x + y

result = add(3, 5)

print(result)

Explain

• lambda x, y: x + y defines a lambda function that takes two parameters (x and y) and returns their sum.

• add(3, 5) calls the lambda function with the arguments 3 and 5, returning the result 8.

• Lambda functions are useful when you need a quick, simple function without the need to define a separate function using def.

Key Point: Lambda functions are concise and ideal for short tasks where you don't need to reuse the function elsewhere in your program.

12. Using sorted()

Explanation of the Skill

The sorted() function is used to sort the elements of an iterable (like a list) in ascending or descending order. It returns a new sorted list, leaving the original iterable unchanged.

How to Write the Code

You can use sorted() to sort data. You can also pass additional parameters to control the sorting order or use a custom sorting function.

Example Code:

numbers = [5, 2, 9, 1, 7]

sorted_numbers = sorted(numbers)

print(sorted_numbers)

Explain

• sorted(numbers) sorts the numbers list in ascending order, returning [1, 2, 5, 7, 9].

• The original list numbers remains unchanged, and the sorted result is stored in sorted_numbers.

• sorted() can also take a reverse=True argument to sort in descending order, like sorted(numbers, reverse=True).

Key Point: sorted() is a versatile function that allows sorting lists in different ways without modifying the original data.

13. Using min()

Explanation of the Skill

The min() function returns the smallest item from an iterable or the smallest of two or more arguments. It’s useful when you need to find the minimum value in a collection of data.

How to Write the Code

You can pass a single iterable (like a list) or multiple arguments to min().

Example Code:

numbers = [5, 2, 9, 1, 7]

minimum_value = min(numbers)

print(minimum_value)

Explain

• min(numbers) finds the smallest number in the list numbers, which is 1.

• The min() function can also be used with multiple arguments, like min(5, 2, 9, 1, 7), and it will return 1 as the smallest value.

• This function is helpful when you want to quickly identify the lowest value in a dataset.

Key Point: min() is great for finding the smallest element in a collection or comparing multiple values to determine the smallest.

14. Accessing Items from a List Using Indexes

Explanation of the Skill

Lists in Python are ordered collections, and each item in a list is assigned an index. You can access elements in a list using their index number, which starts at 0 for the first item. This allows you to retrieve or modify specific elements in a list.

How to Write the Code

To access an item from a list, you use square brackets [] and specify the index of the item you want to access.

Example Code:

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

first_fruit = fruits[0]

print(first_fruit)

Explain

• fruits[0] accesses the first item in the list, which is "apple", because list indexing starts at 0.

• If you want to access the second item, you would use fruits[1], which would return "banana".

• You can also access the last item in the list using negative indexing: fruits[-1] returns "cherry".

Key Point: Indexing allows you to retrieve and manipulate specific items in a list based on their position.

15. Recap on Catching Return Values from Functions

Explanation of the Skill

When you define a function, it may perform some action or calculation and return a value using the return statement. Understanding how to capture that return value is crucial in order to use it later in your code.

How to Write the Code

When you call a function that returns a value, you can assign that returned value to a variable so you can use it elsewhere in your program.

Example Code:

def add_numbers(x, y):

return x + y

result = add_numbers(3, 5)

print(result) '#output: 8

Explain

• The function add_numbers(x, y) takes two arguments, x and y, and returns their sum using the return statement.

• When we call add_numbers(3, 5), it returns the value 8.

• The result = add_numbers(3, 5) line assigns the returned value (8) to the variable result.

• Finally, print(result) displays the value 8.

vowel remover program

1. string method .lower and .upper

Explanation of the Skill:

In Python, strings are sequences of characters. The .lower() and .upper() methods are built-in string methods used to change the case of characters in a string.

• .lower() converts all the characters in a string to lowercase (e.g., "Hello" becomes "hello").

• .upper() converts all characters to uppercase (e.g., "hello" becomes "HELLO").

These methods return a new string with the desired case change, but they do not modify the original string.

How to Write:

To use .lower() or .upper(), you simply call them on a string. Here's how to write the code:

# Example string

text = "Hello World!"

# Convert the string to lowercase

lowercase_text = text.lower()

# Convert the string to uppercase

uppercase_text = text.upper()

# Output the results

print(lowercase_text)

print(uppercase_text)

Explanation:

• text = "Hello World!" is a variable that holds a string.

• text.lower() converts the string to lowercase and stores the result in the variable lowercase_text.

• text.upper() converts the string to uppercase and stores the result in the variable uppercase_text.

• print(lowercase_text) and print(uppercase_text) display the results.

When you run this code, the string "Hello World!" will be printed twice, once in lowercase and once in uppercase.

2. recap on string method .join

Explanation of the Skill:

The .join() method is used to join elements of a list or other iterable into a single string, with a separator between them. It’s commonly used to combine strings or characters from a list into one string.

For example, you might have a list of characters and want to combine them into a word.

How to Write:

To use .join(), you need to specify the separator (for example, an empty string '', a space ' ', or a comma ','), and then call it on the separator with the list of strings you want to join.

# Example list of strings

words = ["Hello", "World", "Python"]

# Join the words into a single string with a space in between

sentence = " ".join(words)

# Output the result

print(sentence)

Explanation:

• words = ["Hello", "World", "Python"] is a list containing three strings.

• " ".join(words) joins all the elements of the list words into a single string, separating them with a space (" ").

• print(sentence) displays the joined string, which will be "Hello World Python".

The .join() method is particularly useful when you want to combine a list of words into a sentence or a list of characters into a word.

3. for loop recap

Explanation of the Skill:

A for loop allows you to iterate (or loop) through each element in a sequence (like a list, string, or range). It helps you perform actions on each element one at a time.

For example, you can loop through a list of numbers and print each one.

How to Write:

To use a for loop, specify the sequence you want to iterate over, followed by the loop body. Here's how you write a simple for loop:

# Example list of numbers

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

# Loop through each number in the list and print it

for number in numbers:

print(number)

Explanation:

• numbers = [1, 2, 3, 4, 5] is a list containing five numbers.

• for number in numbers: starts the loop, where number represents each element of the numbers list as the loop iterates over it.

• print(number) outputs each number from the list.

Each time the loop runs, the variable number takes on the value of the next element in the list, and the print() function prints that value.

4. list comprehension

Explanation of the Skill:

List comprehension is a more compact and efficient way to create lists by applying an expression to each item in an existing list or other iterable. It’s often used for tasks like filtering, modifying, or combining elements.

The basic syntax for list comprehension is:

new_list = [expression for item in iterable]

List comprehension can also include conditions to filter elements.

How to Write:

Here’s how you can use list comprehension to create a new list based on an existing one:

# Example list of numbers

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

# Use list comprehension to square each number in the list

squared_numbers = [number ** 2 for number in numbers]

# Output the result

print(squared_numbers)

Explanation:

• numbers = [1, 2, 3, 4, 5] is the original list of numbers.

• [number ** 2 for number in numbers] is a list comprehension that squares each number in the numbers list and creates a new list squared_numbers.

• print(squared_numbers) displays the list [1, 4, 9, 16, 25].

List comprehension allows you to do all of this in a single line, making it a concise and powerful tool for list manipulation.

Square root of pi

1. Arithmetic Operators Recap

Explanation of the skill:

Arithmetic operators in Python are used to perform basic mathematical operations such as addition, subtraction, multiplication, and division. Understanding these operators is essential for performing calculations in any program. Additionally, Python allows you to raise numbers to a power using the ** operator.

How to write:

1. Addition (+): Adds two values.

2. Subtraction (-): Subtracts one value from another.

3. Multiplication (*): Multiplies two values.

4. Division (/): Divides one value by another.

5. Exponentiation (**): Raises a number to a power (e.g., 2**3 means 2 raised to the power of 3).

Here is an example code:

# Basic arithmetic operations

a = 5

b = 3

sum_result = a + b # Adds a and b

difference_result = a - b # Subtracts b from a

product_result = a * b # Multiplies a and b

quotient_result = a / b # Divides a by b

power_result = a ** b # Raises a to the power of b

# Display the results

print("Sum:", sum_result)

print("Difference:", difference_result)

print("Product:", product_result)

print("Quotient:", quotient_result)

print("Power:", power_result)

Example output:

Sum: 8 Difference: 2 Product: 15 Quotient: 1.6666666666666667 Power: 125

Explanation:

• We create two variables, a and b, with values 5 and 3.

• We use each arithmetic operator to perform different operations between a and b and store the results in separate variables.

• Finally, we print the results. The division gives a float result, while the exponentiation gives a raised to the power of b.

2. Using the max() Function

Explanation of the skill:

The max() function is used to find the maximum of two or more values. This function returns the largest of the values provided as arguments. It is helpful when you need to determine the highest value, such as finding the upper bound of a range.

How to write:

# Using max() to find the largest number

a = 10

b = 20

max_value = max(a, b)

print("The larger value is:", max_value)

Example output:

The larger value is: 20

Explanation:

• We use the max() function to compare two numbers, a and b.

• The max() function evaluates the two values and returns the larger one.

• Here, the larger value between 10 and 20 is 20, so that's what is printed.

3. Setting a Variable to None

Explanation of the skill:

In Python, the None keyword represents a null value or no value at all. It is often used to initialize variables that will be assigned a value later, or to indicate that an operation was unsuccessful or does not return a value.

How to write:

# Initializing a variable with None

result = None

# Checking if result is None

if result is None:

print("The result has not been calculated yet.")

else:

print("The result is:", result)

Example output:

The result has not been calculated yet.

Explanation:

• We first initialize a variable result with the value None.

• Later, we use an if statement to check whether result is None. If it is, it indicates that the variable hasn’t been assigned any meaningful value yet.

• If it had a value, we would print it, but in this case, since result is None, it prints a message stating that it hasn't been calculated.

4. Importing Libraries in Python

Explanation of the skill:

In Python, libraries are external files that contain pre-written code that you can use in your programs. The import statement allows you to bring these libraries into your script to access their functions and variables. The math library is built-in and provides mathematical functions, such as the constant pi.

How to write:

# Importing the math library to use its functions

import math

# Using math.pi to get the value of pi

print("The value of pi is:", math.pi)

Example output:

The value of pi is: 3.141592653589793

Explanation:

• First, we use import math to access the functions and constants in the math library.

• We then use math.pi, which provides the value of π (pi), a mathematical constant often used in geometric calculations.

• The print function displays the value of pi to the user.

By importing the math library, we avoid having to manually define the value of pi or create custom functions for advanced mathematical operations.

5. Default Parameters

Explanation of the skill:

In Python, functions can accept parameters (also known as arguments) when they are called. However, you can also set default values for parameters, meaning that if no value is provided when calling the function, the default value will be used. This is particularly useful when you want to provide flexibility while ensuring that the function works without needing to pass in every parameter every time.

How to write:

# Function with a default parameter

def greet(name="Guest"):

print(f"Hello, {name}!")

# Calling the function without providing a name

greet() #Output “Hello Guest”

# Calling the function with a provided name

greet("Alice") #Output “Hello Alice”

Example output:

Hello, Guest! Hello, Alice!

Explanation:

• The greet function has a parameter name with a default value of "Guest".

• When calling greet() without any argument, it uses the default value, printing "Hello, Guest!".

• When calling greet("Alice"), it uses the provided argument, printing "Hello, Alice!".

• Default parameters make it easy to create flexible functions without requiring the caller to specify every argument.

6. Using abs()

Explanation of the skill:

The abs() function in Python returns the absolute value of a number. The absolute value of a number is its distance from zero, regardless of whether the number is positive or negative. This function is often used in cases where you need to work with positive values, such as in calculating the error or tolerance in an algorithm like the bisection method.

How to write:

# Using abs() to find the absolute value

number = -7.5

absolute_value = abs(number)

print(f"The absolute value of {number} is {absolute_value}")

Example output:

The absolute value of -7.5 is 7.5

Explanation:

• In this example, the abs() function is used to convert a negative number -7.5 to its positive equivalent, 7.5.

• This is helpful when you want to remove the negative sign and work with a non-negative value.

• The absolute value is often useful when calculating the difference between two values (e.g., checking how close a calculated value is to the target value in an algorithm).

7. for _ in range

Explanation of the skill:

In Python, the for loop is commonly used to iterate over a sequence of numbers, such as a range. The variable inside the loop (often called i) typically refers to the current number in the sequence. However, if the loop variable is not going to be used in the loop body, it is common to use an underscore (_) instead. This signals to the reader that the variable is intentionally unused.

How to write:

# Using for _ in range when the variable is not needed

for _ in range(3):

print("Hello!")

Example output:

Hello! Hello! Hello!

Explanation:

• In this example, the loop will run three times, but the value of the loop variable is not used.

• By using _ instead of i, we make it clear that the variable is irrelevant to the loop's logic.

• This is often used when performing a certain action a set number of times but not needing to access the loop counter.

8. Recap on if...break in the Context of a Loop

Explanation of the skill:

The if statement is used to test a condition, and if that condition is true, it executes the block of code that follows. The break statement is used to exit the loop prematurely, which is helpful when a certain condition has been met and there is no need to continue iterating. Using if with break is common in situations like searching for a solution or stopping when an error condition is met.

How to write:

# Using if...break to exit a loop early

for i in range(10):

if i == 5:

print("Breaking out of the loop at i =", i)

break

Example output:

Breaking out of the loop at i = 5

Explanation:

• This loop iterates from 0 to 9, but as soon as i equals 5, the condition if i == 5 becomes true.

• The print statement is executed, and then the break statement exits the loop.

• Using if...break helps to stop the loop early when you find the result you're looking for or when you no longer need to continue iterating.

9. Explanation of the Bisection Method

Explanation of the skill:

The bisection method is a numerical technique for finding the roots (or solutions) of a function. It works by repeatedly narrowing the range in which the root lies. In each iteration, the midpoint of the current range is calculated, and the function is evaluated at that point. Based on whether the midpoint value is greater or less than the target, the range is adjusted accordingly.

The bisection method requires the following:

• A function where the root lies between two points (low and high).

• A stopping criterion (e.g., when the difference between the function's value at the midpoint and the target is smaller than a given tolerance).

How to write:

# Bisection method to find the square root of a number

def bisection_method(target, tolerance=1e-7, max_iterations=100):

low = 0

high = max(1, target)

for _ in range(max_iterations):

mid = (low + high) / 2

square_mid = mid ** 2

if abs(square_mid - target) < tolerance:

return mid

if square_mid < target:

low = mid

else:

high = mid

return None

# Running the function to find the square root of 2

result = bisection_method(2)

print("The square root is approximately:", result)

Example output:

The square root is approximately: 1.414213562373095

Explanation:

• The bisection_method function takes the target number, tolerance, and maximum number of iterations as parameters.

• It starts with an initial range from low = 0 to high = max(1, target), and iteratively calculates the midpoint (mid).

• If the square of the midpoint (mid**2) is sufficiently close to the target (within the tolerance), the function returns mid as the result.

• If not, it adjusts the low or high values depending on whether the square of mid is smaller or larger than the target.

• This process continues until the solution is found or the maximum number of iterations is reached.

Generating coupon codes

1. Importing Python libraries - purpose of re, secrets, and string

Explanation:

In Python, libraries are collections of pre-written code that you can use to perform specific tasks. You can "import" libraries into your program to take advantage of these functions without having to write them yourself. The purpose of importing libraries is to extend the functionality of your code and make it easier to solve complex tasks.

• re: This is the regular expression library, used for working with text patterns. It helps you search, match, and manipulate strings based on certain patterns (like checking if a string contains a number, letter, or specific characters).

• secrets: A library used to generate secure random numbers and strings, often used for things like password generation or tokens, where high randomness is important.

• string: A built-in library in Python that contains various useful string constants and functions. For example, it provides predefined sets of characters like uppercase letters (string.ascii_uppercase) or digits (string.digits).

How to Write:

To import these libraries, you simply use the import statement. Here’s how you would import them:

import re

import secrets

import string

Each import statement allows you to use the functions and features of the library in your code.

Example:

import re

import secrets

import string

# Use a function from the string library

letters = string.ascii_uppercase # A string containing all uppercase letters

print(letters)

Explanation of Example:

• import string gives you access to the string library.

• string.ascii_uppercase is a constant in the string library that contains all uppercase letters (A-Z).

• print(letters) outputs ABCDEFGHIJKLMNOPQRSTUVWXYZ because we accessed that constant from the string library.

2. Using Methods from string Libraries (string.ascii_uppercase & string.digits)

Explanation:

The string library is built into Python, and it contains useful constants that can be used for various operations on strings, such as generating random characters.

• string.ascii_uppercase: A constant that contains all uppercase letters from A to Z.

• string.digits: A constant that contains all the digits from 0 to 9.

You can use these constants to select specific groups of characters for tasks like generating random strings or filtering certain types of characters from a string.

How to Write:

To use these methods, you access the constants from the string library directly.

import string

# Get uppercase letters

letters = string.ascii_uppercase

print(letters)

# Get digits

digits = string.digits

print(digits)

Example:

import string

# Generate random uppercase letters and digits

letters = string.ascii_uppercase

digits = string.digits

print("Uppercase Letters:", letters)

print("Digits:", digits)

Explanation of Example:

• string.ascii_uppercase gives you a string of uppercase English letters.

• string.digits gives you a string of all numeric digits.

• You can use these strings to create random selections, generate passwords, or filter characters in a string.

3. Combining Strings

Explanation:

Combining strings, also known as "concatenating," means joining multiple strings together into one string. This is useful when you need to form larger pieces of text from smaller parts.

In Python, you can concatenate strings using the + operator. This combines the strings in the order they are provided.

How to Write:

To combine strings, use the + operator between two or more string variables.

part1 = "Hello"

part2 = "World"

combined = part1 + " " + part2

print(combined)

Example:

import string

# Combine uppercase letters and digits

letters = string.ascii_uppercase

digits = string.digits

combined = letters + digits

print("Combined Letters and Digits:", combined)

Explanation of Example:

• string.ascii_uppercase gives you the uppercase letters.

• string.digits gives you the digits.

• letters + digits combines both into a single string, containing both uppercase letters and digits.

• The result is a string like ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.

4. Using set()

Explanation:

A set is a data structure in Python that stores unique values. Unlike lists, sets cannot contain duplicates. This makes them useful when you need to ensure that all the items in your collection are distinct.

Sets are also unordered, meaning the order in which items are added is not preserved. You can add or remove items from a set, and it will automatically handle duplicates for you.

How to Write:

To create a set, you use curly braces {} or the set() constructor.

# Create a set

my_set = {1, 2, 3}

print(my_set)

# Adding elements

my_set.add(4)

print(my_set)

# Trying to add a duplicate element

my_set.add(2)

print(my_set) # The duplicate "2" will not be added

Example:

# Create a set to store unique coupon codes

generated_codes = set()

# Add new codes

generated_codes.add("ABC123")

generated_codes.add("XYZ456")

# Print the set

print("Generated Codes:", generated_codes)

# Add a duplicate code (it won't be added)

generated_codes.add("ABC123")

print("After Attempting to Add a Duplicate:", generated_codes)

Explanation of Example:

• generated_codes = set() creates an empty set.

• .add("ABC123") adds a new coupon code to the set.

• When you attempt to add "ABC123" again, it is ignored because sets don’t allow duplicates.

• The set will only contain unique coupon codes, ensuring that there are no repeated codes.

5. The .add() Method

Explanation:

The .add() method in Python is used to add a new element to a set. It is important because sets do not allow duplicate elements, so if you attempt to add an element that already exists in the set, it will not be added again. This method is particularly useful for ensuring that you are storing only unique items, such as generating unique coupon codes.

How to Write:

To use the .add() method, you simply call it on a set object and pass the element you want to add. If the element is already in the set, nothing will happen.

# Create an empty set

my_set = set()

# Add an element to the set

my_set.add("element1")

print(my_set)

# Attempt to add the same element again

my_set.add("element1")

print(my_set) # The set remains unchanged, as "element1" was already added

Example:

# Set to store unique coupon codes unique_codes = set() # Add some codes unique_codes.add("ABC123") unique_codes.add("XYZ456") print("Unique Coupon Codes:", unique_codes) # Attempt to add a duplicate code unique_codes.add("ABC123") print("After Attempting to Add Duplicate:", unique_codes)

Explanation of Example:

• unique_codes = set() creates an empty set to store coupon codes.

• .add("ABC123") adds the coupon code to the set.

• When we try to add "ABC123" again, the set does not change, demonstrating that sets store only unique items.

6. Recap on a while True Loop

Explanation:

A while True loop in Python is an infinite loop that keeps running unless explicitly stopped. This loop will continue indefinitely until a condition is met that causes it to break. It is useful when you want the program to repeat actions until a certain requirement is fulfilled.

To exit the loop, you use the break statement when the condition you’re checking for is met.

How to Write:

A basic while True loop looks like this:

while True:

# Code to execute repeatedly

if condition_to_stop:

break

Example:

# Generate a coupon code until it meets specific criteria

while True:

coupon = "ABC123" # Just a placeholder for coupon generation logic

if len(coupon) == 6:

print("Valid Coupon Code:", coupon)

break # Stop the loop when the coupon code is valid

Explanation of Example:

• The while True loop will run indefinitely until the break condition is met.

• Inside the loop, we check if the length of the coupon is 6. Once the coupon meets this condition, we print it and break out of the loop.

7. Using if…in and if…not in

Explanation:

The if…in and if…not in statements are used to check whether an element is present in a collection like a list, set, or string. These statements are useful for checking membership and ensuring that you don't add duplicate elements to data structures, such as when ensuring uniqueness of coupon codes.

• if item in collection: Checks if item exists in the collection.

• if item not in collection: Checks if item does not exist in the collection.

How to Write:

To use these membership operators, write an if statement like this:

if "element" in my_set:

print("Element is in the set")

else:

print("Element is not in the set")

if "element" not in my_set:

print("Element is not in the set")

Example:

# Set to store unique coupon codes

codes = {"ABC123", "XYZ456"}

# Check if a code is already in the set

if "ABC123" in codes:

print("Coupon ABC123 already exists.")

else:

codes.add("ABC123")

# Check if a code is not in the set

if "XYZ789" not in codes:

codes.add("XYZ789")

print("Updated Coupon Codes:", codes)

Explanation of Example:

• if "ABC123" in codes: checks if "ABC123" is already present in the codes set.

• If the coupon is not in the set, we add it. The second check if "XYZ789" not in codes: ensures that "XYZ789" is only added if it's not already in the set.

8. Tuples (What a Tuple Is - Purpose - How to Write)

Explanation:

A tuple is a collection of ordered items, like a list, but unlike lists, tuples are immutable, meaning their values cannot be changed once created. Tuples are often used to store data that should not be modified, like coordinates or fixed collections of items.

Tuples are written using parentheses ().

How to Write:

A tuple is created by enclosing items in parentheses, separated by commas.

# Create a tuple

my_tuple = (1, 2, 3)

print(my_tuple)

# Access tuple items

print(my_tuple[0]) # Prints 1, the first item in the tuple

Example:

# A tuple storing a coupon's code and expiration date

coupon_info = ("ABC123", "2024-12-31")

print("Coupon Code:", coupon_info[0])

print("Expiration Date:", coupon_info[1])

Explanation of Example:

• coupon_info = ("ABC123", "2024-12-31") creates a tuple with two elements: a coupon code and its expiration date.

• We access these elements using indexing, starting from 0. coupon_info[0] gives us the coupon code, and coupon_info[1] gives us the expiration date.

• Tuples are immutable, meaning their values cannot be changed once they are created.

9. Regex Library

Explanation:

The re (regular expression) library is used in Python to search for patterns within strings. Regular expressions are sequences of characters that form search patterns, which can be used for matching, extracting, and replacing text in strings.

• The re library allows you to define patterns that match text and apply operations such as searching, splitting, or replacing text that fits these patterns.

• Common methods include:

  • re.match(): Checks if the beginning of a string matches a pattern.

  • re.search(): Searches the string for the pattern anywhere.

  • re.findall(): Returns all occurrences of the pattern in a string.

How to Write:

Here’s a basic example of how to use the re library:

import re

# Define a pattern

pattern = r'\d'

# Pattern to match digits

# Search for the pattern

result = re.findall(pattern, "The code is 1234")

print(result) # Output: ['1', '2', '3', '4']

Example:

import re

# Define a pattern to match a code format (letters followed by digits)

pattern = r'[A-Z]+\d+'

# Search for the pattern in a string

code = "Your coupon code is ABC123"

found_code = re.search(pattern, code)

if found_code:

print("Coupon Code Found:", found_code.group())

else:

print("No Coupon Code Found")

Explanation of Example:

• pattern = r'[A-Z]+\d+' defines a regular expression pattern that matches one or more uppercase letters followed by one or more digits.

• re.search() looks for this pattern in the string "Your coupon code is ABC123".

• If the pattern is found, found_code.group() returns the matched string "ABC123".

• If the pattern is not found, the message "No Coupon Code Found" is printed.

10. How to Use the all() Function

Explanation:

The all() function in Python is used to check if all items in an iterable (such as a list, tuple, or set) evaluate to True. It returns True if all elements are truthy (i.e., they are not False, None, or empty), and False otherwise.

The all() function is particularly useful when you have multiple conditions to check and you want to confirm that all of them are met. It is commonly used in scenarios where several requirements must be satisfied simultaneously, such as validating input or checking constraints.

How to Write:

The all() function takes an iterable as an argument. Each item inside the iterable is evaluated, and if all items are truthy, the function returns True; otherwise, it returns False.

Here is the syntax:

all(iterable)

To use all(), you can pass a list of boolean expressions (like comparison operators or conditions):

# Using all() with conditions

conditions = [x > 10, x < 20]

if all(conditions):

print("All conditions are met.")

else:

print("Not all conditions are met.")

Example:

# List of conditions to check for coupon code requirements

conditions = [

len("ABC123") == 6, # Check if the length is 6

"ABC123".isupper(), # Check if the coupon code is uppercase

any(char.isdigit() for char in "ABC123") # Check if the coupon contains digits

]

# Use all() to check if all conditions are satisfied

if all(conditions):

print("Coupon code is valid.")

else:

print("Coupon code is invalid.")

Explanation of Example:

• The conditions list contains boolean expressions that evaluate specific conditions:

  • len("ABC123") == 6: Checks if the length of the string is 6 characters.

  • "ABC123".isupper(): Checks if all characters in the string are uppercase.

  • any(char.isdigit() for char in "ABC123"): Checks if at least one character in the string is a digit using a generator expression.

• all(conditions) evaluates whether all conditions in the list are True.

• If all conditions are met, the message "Coupon code is valid." is printed. If not, it prints "Coupon code is invalid.".

pig latin translator

1. Recap on Defining Functions

Explanation:

In Python, a function is a block of reusable code that performs a specific task. Functions help break down complex problems into smaller, manageable tasks. Functions allow you to define a series of steps once and then call (or invoke) them multiple times in your program. This reduces redundancy and increases code efficiency.

How to Write:

To define a function in Python, use the def keyword followed by the function name, parentheses (), and a colon :. Inside the function, you write the logic that the function should execute.

Here’s a basic example:

def greet():

print("Hello, world!")

Explanation:

In this example:

• The def keyword is used to define the function greet.

• Inside the parentheses, you can define parameters (inputs), but in this case, we don't need any.

• The indented code under def greet(): is the body of the function. In this case, it just prints a message when the function is called.

• To use the function, simply write greet(), and it will print "Hello, world!".

2. Recap on Returning Values to Functions

Explanation:

A function in Python can return a value, which means it can give a result back to the caller. This is helpful when you want the function to calculate something and then send that result back for further use.

How to Write:

You use the return keyword to return a value from a function.

Example:

def add_numbers(a, b):

return a + b

Explanation:

In this example:

• The function add_numbers takes two parameters, a and b, which are the numbers you want to add.

• Inside the function, the return statement sends the result of a + b back to the caller.

• When you call add_numbers(3, 4), the function returns 7.

3. Recap on Conditional Statements

Explanation:

Conditional statements allow you to run certain blocks of code depending on whether a condition is true or false. The most common conditional statements are if, elif, and else. These control the flow of your program.

How to Write:

You use the if statement to check a condition, and elif or else to handle other cases.

Example:

def check_age(age):

if age >= 18:

return "You are an adult."

else:

return "You are a minor."

Explanation:

In this example:

• The if statement checks if the age is 18 or greater. If true, it returns "You are an adult."

• If the condition is false, the else part runs, returning "You are a minor."

• You can also use elif for checking additional conditions (e.g., elif age >= 13:).

4. If…in… Statements

Explanation:

The if...in... statement is used to check if a value exists within a sequence (like a list, string, or tuple). It’s particularly useful when you want to check membership or presence of a value.

How to Write:

You use the in keyword to check if an element exists in a sequence.

Example:

def check_item_in_list(item, item_list):

if item in item_list:

return f"{item} is in the list."

else:

return f"{item} is not in the list."

Explanation:

In this example:

• The function check_item_in_list checks if the variable item is found in the list item_list.

• The if item in item_list checks whether the item exists inside the list.

• If the condition is true, the function returns a message confirming that the item is in the list; otherwise, it returns a message saying it’s not found.

5. Using a Simple For Loop

Explanation:

A for loop in Python allows you to iterate over a sequence (such as a list or range) and perform an action for each item in that sequence. It’s a great tool for repeating tasks, like processing items in a list or performing calculations multiple times.

How to Write:

The basic structure of a for loop looks like this:

for item in sequence: # Do something with the item

Example:

for i in range(5):

print(i)

Explanation:

• The range(5) creates a sequence of numbers from 0 to 4.

• The loop then iterates over each number, assigning it to i and printing it.

• So, this will output

  0 1 2 3 4

6. For Loops and Temporary Variables

Explanation:

A temporary variable is a variable that is used within a loop or function to hold a value temporarily during each iteration. These variables are helpful when you need to track or modify information as the loop runs.

How to Write:

You can use temporary variables within a for loop to store intermediate values or results.

Example:

total = 0

for i in range(1, 6):

total += i

print(total)

Explanation:

• The loop goes through each number in the range from 1 to 5.

• The temporary variable total starts at 0 and is updated by adding each value of i to it.

• After the loop finishes, total holds the sum of the numbers from 1 to 5, which is 15.

• So, the output is 15.

7. Enumerate() Function

Explanation:

The enumerate() function adds a counter to an iterable (like a list or string) and returns it in the form of an enumerate object, which can then be used in a for loop. It is particularly useful when you need both the index (position) and the value of each item in a sequence.

How to Write:

The enumerate() function can be used in a for loop as follows:

for index, value in enumerate(sequence): # Do something with the index and value

Example:

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

for index, fruit in enumerate(fruits):

print(f"Index {index}: {fruit}")

Explanation:

• enumerate(fruits) provides each element of the fruits list along with its index.

• The loop assigns the index to index and the value (fruit) to fruit.

• The output will be:

  Index 0: apple Index 1: banana Index 2: cherry

8. Taking Characters from String

Explanation:

Strings are sequences of characters in Python, and you can access individual characters using their index. The index of characters in a string starts at 0. Using square brackets [], you can extract a character at a specific index.

How to Write:

To take a character from a string, use the index inside square brackets:

word = "hello"

first_char = word[0]

Example:

word = "hello"

print(word[0])

Explanation:

• word[0] accesses the first character of the string "hello", which is "h".

• The output will be:

  h

9. String Slicing

Explanation:

String slicing allows you to extract a part of a string by specifying a range of indices. You can slice a string to get a substring, which is very useful for tasks like modifying strings or working with specific sections of a string.

How to Write:

You use the syntax word[start:end] to slice a string from the start index to the end index (but not including the end index). You can also omit the start or end to slice from the beginning or to the end of the string.

Example:

word = "hello"

print(word[1:4]) # Slices from index 1 to 3

Explanation:

• word[1:4] slices the string "hello" starting from index 1 up to (but not including) index 4.

• The output will be:

  ell

• You can also use word[:3] to get the substring from the beginning to index 3 (not including index 3), or word[2:] to slice from index 2 to the end of the string.

10. Combining Strings Recap

Explanation:

Combining strings means joining two or more strings together to form a new string. In Python, this can be done using the + operator or string methods such as .join().

How to Write:

You can combine strings like this:

first_part = "Hello"

second_part = "World"

combined = first_part + " " + second_part

print(combined)

Example:

greeting = "Good"

time_of_day = "Morning"

full_greeting = greeting + " " + time_of_day

print(full_greeting)

Explanation:

• The + operator is used to concatenate the two strings "Good" and "Morning", along with a space in between to form "Good Morning".

• The output will be

  Good Morning

11. Using .split() Method

Explanation:

The .split() method is used to divide a string into a list of substrings based on a delimiter (space by default). This is useful when you want to break up a sentence or string into individual words or parts.

How to Write:

You can split a string by calling .split():

sentence = "Hello World"

words = sentence.split()

print(words)

Example:

sentence = "apple,orange,banana"

fruits = sentence.split(",")

print(fruits)

Explanation:

• The string "apple,orange,banana" is split at each comma (,), and the result is a list of words ['apple', 'orange', 'banana'].

• The output will be:

  ['apple', 'orange', 'banana']

• If no argument is provided to .split(), it splits by whitespace by default.

12. Recap on Calling Functions (Catching Return Values)

Explanation:

When you call a function in Python, it can return a value that can be captured and used elsewhere in your program. This is called "catching" the return value. You store this return value in a variable so you can use it later.

How to Write:

Here’s how you can call a function and catch its return value:

def add_numbers(a, b):

return a + b

result = add_numbers(3, 5)

print(result)

Example:

def greet(name):

return "Hello, " + name

message = greet("Alice")

print(message)

Explanation:

• The function greet takes one argument name and returns a greeting message.

• The function is called with the argument "Alice", and the return value "Hello, Alice" is captured in the variable message.

• The output will be

  Hello, Alice

13. Recap on f-Print Statements

Explanation:

An f-string is a way to embed expressions inside string literals, using curly braces {}. This is a concise and efficient way to format strings, as it evaluates the expressions inside the curly braces and inserts their values into the string.

How to Write:

To use f-strings, you start the string with an f before the quotation mark and place the expressions inside {}:

name = "Alice"

age = 25

greeting = f"Hello, my name is {name} and I am {age} years old."

print(greeting)

Example:

item = "apple"

quantity = 5

sentence = f"I have {quantity} {item}s."

print(sentence)

Explanation:

• The f-string f"I have {quantity} {item}s." evaluates the variables quantity and item and inserts their values into the string.

• The output will be

  I have 5 apples.

Graph representation converter

1. Dictionaries (What a dictionary is - how to define a dictionary - use of dictionaries)

Explanation:

A dictionary is a built-in data type in Python that stores key-value pairs. The keys are unique and map to corresponding values. You can think of a dictionary like a real-life dictionary where you have words (keys) and their definitions (values). The main advantage of a dictionary is that it allows for fast retrieval of values based on the keys.

How to Write:

To define a dictionary, you use curly braces {} and separate the key-value pairs with a colon :. Each pair is separated by a comma. Here's an example of how to define and use a dictionary:

# Defining a dictionary

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

# Accessing a value using the key

print(person["name"]) # Output: Alice

Explain:

• person is the dictionary. The keys are "name", "age", and "city", and the values are "Alice", 25, and "New York", respectively.

• You access a value by using its key in square brackets, e.g., person["name"] returns "Alice".

• Dictionaries are mutable, so you can add or change key-value pairs after they are created.

2. Using .keys() Method

Explanation:

The .keys() method is used to retrieve all the keys in a dictionary. It returns the keys as a view object, which can be iterated over like a list. This is useful when you need to process or inspect all the keys in a dictionary.

How to Write:

To use the .keys() method, you call it on a dictionary. Here's an example:

# Defining a dictionary

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

# Getting the keys of the dictionary

keys = person.keys()

print(keys) # Output: dict_keys(['name', 'age', 'city'])

Explain:

• The .keys() method returns a view object (dict_keys) that contains the dictionary's keys.

• You can iterate through these keys using a for loop or convert it to a list with list() to use like a normal list:

  keys_list = list(person.keys()) print(keys_list) # Output: ['name', 'age', 'city']

3. Using .items() Method

Explanation:

The .items() method is used to retrieve both keys and values from a dictionary at the same time. It returns a view object containing tuples of key-value pairs. This is especially helpful when you want to work with both the keys and their corresponding values in a loop.

How to Write:

To use the .items() method, you call it on a dictionary. Here's an example:

# Defining a dictionary

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

# Getting both keys and values

items = person.items()

print(items) # Output: dict_items([('name', 'Alice'), ('age', 25), ('city', 'New York')])

# Iterating through keys and values

for key, value in person.items():

print(f"{key}: {value}")

Explain:

• The .items() method returns a view object (dict_items) that contains tuples, where each tuple is a key-value pair.

• The for loop iterates through each tuple, and the key and value variables represent the dictionary's key and its associated value, respectively.

• This method is useful when you need to process both keys and values simultaneously.

4. Sorted() Method

Explanation:

The sorted() function is used to return a sorted version of an iterable, such as a list, tuple, or dictionary (by keys). The original iterable remains unchanged. Sorting is helpful when you need to organize data in ascending or descending order.

How to Write:

The sorted() function can be used with various iterables. Here's an example of sorting a list of numbers and a dictionary by its keys:

# Sorting a list of numbers

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

sorted_numbers = sorted(numbers)

print(sorted_numbers) # Output: [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

# Sorting a dictionary by its keys

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

sorted_keys = sorted(person.keys())

print(sorted_keys) # Output: ['age', 'city', 'name']

Explain:

• sorted(numbers) sorts the list numbers in ascending order and returns the sorted list.

• sorted(person.keys()) sorts the dictionary's keys alphabetically (since dictionaries are unordered, you can sort the keys to get an ordered list).

• The sorted() function does not modify the original data; it returns a new sorted iterable.

5. Len() Method

Explanation:

The len() function is a built-in Python function used to determine the length of an object. It works with various types of objects like strings, lists, tuples, and dictionaries. When applied to a dictionary, it returns the number of key-value pairs it contains.

How to Write:

To use the len() method, simply pass the object as an argument. Here’s an example of how to use it:

# Using len() with a list

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

print(len(fruits)) # Output: 3

# Using len() with a dictionary

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

print(len(person)) # Output: 3

Explain:

• len(fruits) returns 3 because there are three items in the list fruits.

• len(person) returns 3 because there are three key-value pairs in the dictionary person.

• The len() function provides a simple way to get the size of various data structures in Python.

6. Enumerate() Method

Explanation:

The enumerate() function is used to iterate over a sequence (such as a list or a string) while keeping track of the index of the current item. It is useful when you need both the index and the value of elements in a loop.

How to Write:

To use enumerate(), you can pass it the iterable (like a list) and it will return each item along with its index. Here's an example:

# Using enumerate() with a list

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

for index, fruit in enumerate(fruits):

print(f"Index {index}: {fruit}") #Ouput: 0: apple 1:banana 2: cherry

Explain:

• The enumerate() function returns an iterator of tuples. Each tuple contains the index (starting from 0) and the value from the iterable.

• The for index, fruit in enumerate(fruits) part of the loop allows you to access both the index and the value (fruit) from the fruits list.

7. Recap on Using Simple For Loops

Explanation:

A for loop is used to iterate over a sequence (list, tuple, string, etc.) and perform an action for each item in that sequence. In Python, the basic syntax for a for loop is for item in sequence:, where item is the current element, and sequence is the iterable you are looping over.

How to Write:

To create a basic for loop that assigns values to variables, you use the following syntax:

# Simple for loop with variable assignment

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

for fruit in fruits: fruit_upper = fruit.upper() # Assigning a modified value to a variable print(fruit_upper)

Explain:

• In this example, for fruit in fruits iterates over the list fruits, and for each item, it assigns the item (a fruit) to the variable fruit.

• Inside the loop, the code fruit.upper() transforms the string into uppercase, and the result is stored in the variable fruit_upper.

• The loop then prints out the uppercase version of each fruit.

8. Nested For Loops

Explanation:

A nested for loop is a loop inside another loop. It is used when you need to perform an action for each item in a sequence for every item in another sequence. This is common in tasks like iterating through 2D arrays or matrices.

How to Write:

Here’s an example of a nested for loop:

# Nested for loop example

rows = [1, 2, 3]

cols = ['A', 'B', 'C']

for row in rows:

for col in cols:

print(f"Row: {row}, Col: {col}")

Explain:

• The outer loop (for row in rows) iterates over the list rows, and for each row, the inner loop (for col in cols) iterates over the list cols.

• This results in all combinations of rows and columns being printed.

• Nested loops are useful when dealing with two-dimensional data structures like grids or matrices.

9. Graph Coding Structure in Computer Science

Explanation:

In computer science, graphs are used to represent relationships between objects. A graph is made up of nodes (also called vertices) and edges (the connections between nodes). A graph can be directed (edges have a direction) or undirected (edges have no direction). Graphs are commonly used in scenarios like social networks, web pages, and transportation systems.

How to Write:

Here's a very basic representation of a graph using an adjacency list:

# Defining a simple graph using an adjacency list

graph = { "A": ["B", "C"], "B": ["A", "D"], "C": ["A", "D"], "D": ["B", "C"] }

Explain:

• The graph is represented as a dictionary (adjacency list), where each key is a node, and the value is a list of nodes it is connected to.

• For example, node "A" is connected to nodes "B" and "C", so "A": ["B", "C"].

• This structure helps visualize relationships and is fundamental in many algorithms, such as those for finding the shortest path or traversing the graph.

10. Explanation on What an Adjacency List Is

Explanation:

An adjacency list is a way of representing a graph. It is a collection of lists or dictionaries, where each key represents a node (or vertex) in the graph, and the value is a list of the nodes that are directly connected to it by edges. The adjacency list is an efficient way to store sparse graphs, where most nodes are not fully connected.

How to Write:

Here’s an example of an adjacency list for a graph:

# Example of an adjacency list

graph = { "A": ["B", "C"], "B": ["A", "D"], "C": ["A", "D"], "D": ["B", "C"] }

Explain:

• The dictionary graph represents a graph with four nodes: "A", "B", "C", and "D".

• The keys "A", "B", "C", and "D" represent the nodes, and the values are lists that contain the nodes each node is connected to.

• For example, node "A" is connected to "B" and "C", which are represented in the list ["B", "C"].

• The adjacency list provides an easy way to view and traverse the graph.

11. Explanation on What an Adjacency Matrix Is

Explanation:

An adjacency matrix is another way to represent a graph. It is a 2D array (matrix) where each element at position (i, j) represents the connection between node i and node j. If there is an edge between the nodes, the matrix contains a 1 at that position; otherwise, it contains a 0. This representation is best for dense graphs with many connections.

How to Write:

Here’s an example of an adjacency matrix for the graph shown in the adjacency list above:

# Example of an adjacency matrix

adj_matrix = [

# A B C D

#A [0, 1, 1, 0], # A is connected to B, C

#B [1, 0, 0, 1], # B is connected to A, D

#C [1, 0, 0, 1], # C is connected to A, D

#D [0, 1, 1, 0] # D is connected to B, C

]

Explain:

• The matrix adj_matrix is a 2D list where each row and column represents a node. In this case, we have 4 nodes: A, B, C, and D.

• The element at position (i, j) is 1 if there is an edge between the nodes i and j; otherwise, it is 0.

• For example, adj_matrix[0][1] = 1 because there is an edge between node A and node B, while adj_matrix[0][3] = 0 because there is no direct edge between A and D.

12. Initializing an Adjacency matrix

Explanation:

When creating an adjacency matrix, you typically initialize it with zeros. This indicates that there are no edges between the nodes initially. You can create an empty matrix of size n x n (where n is the number of nodes) using a loop or list comprehension.

How to Write:

Here’s an example of how to initialize a matrix of size n x n with 0 values:

# Initialize an adjacency matrix of size n x n with 0s

n = 4 # Number of nodes

adj_matrix = [[0 for _ in range(n)] for _ in range(n)]

Explain:

• The outer for _ in range(n) loop creates n rows in the matrix.

• The inner for _ in range(n) loop creates n columns, each initialized to 0.

• This creates an empty adjacency matrix where no nodes are connected to each other yet.

• This approach uses list comprehension for cleaner and more efficient initialization.

13. Adding Items in an Adjacency Matrix Using Indexing

Explanation:

Once the adjacency matrix is initialized, you can add edges between nodes by updating the matrix at the appropriate indices. You use the row and column indices to mark connections between nodes.

How to Write:

Here’s an example of how to add an edge between two nodes:

# Adding edges to the adjacency matrix

adj_matrix[0][1] = 1 # A is connected to B

adj_matrix[0][2] = 1 # A is connected to C adj_matrix[1][3] = 1 # B is connected to D adj_matrix[2][3] = 1 # C is connected to D

Explain:

• The statement adj_matrix[0][1] = 1 adds an edge between node A and node B (index 0 and 1).

• Similarly, adj_matrix[0][2] = 1 adds an edge between node A and node C.

• The indices [i][j] represent the connection between the nodes at positions i and j in the matrix.

• This method of indexing allows you to easily update and manage the adjacency matrix by directly modifying specific cells in the matrix.

14. Iterating Through Tuples Within a List

Explanation:

When iterating through a list of tuples, you can use multiple temporary variables to extract the values from each tuple. This is helpful when you want to process both the key and the value of each tuple.

How to Write:

Here’s an example of iterating through a list of tuples with two temporary variables:

# List of tuples

pairs = [("A", "B"), ("B", "C"), ("C", "D")]

# Iterating through the list of tuples

for first, second in pairs:

print(f"First: {first}, Second: {second}")

Explain:

• The for first, second in pairs loop iterates through each tuple in the list pairs.

• In each iteration, the first variable takes the first element of the tuple, and the second variable takes the second element.

• For the first tuple ("A", "B"), first will be "A", and second will be "B". The loop prints the values of first and second on each iteration.

• This pattern is useful when dealing with tuples, especially when you need to work with each part of the tuple separately.

15. Adding Items to an Adjacency List Using Nested For Loops

Explanation:

Sometimes, you need to add multiple connections between nodes in an adjacency list, especially if you're working with a matrix or other structured data. By using nested for loops, you can iterate over all pairs of nodes and add connections (edges) between them based on certain conditions.

How to Write:

Here’s an example of adding items to an adjacency list using nested loops:

# Example nodes and adjacency list

nodes = ["A", "B", "C", "D"]

adj_list = {node: [] for node in nodes}

# Adding edges using nested for loops

for i in range(len(nodes)):

for j in range(len(nodes)):

if i != j:

# Prevent self-loop

adj_list[nodes[i]].append(nodes[j])

print(adj_list)

Explain:

• We have a list of nodes ["A", "B", "C", "D"] and an adjacency list adj_list initialized as empty lists for each node.

• The nested loops for i in range(len(nodes)) and for j in range(len(nodes)) iterate through each pair of nodes (i and j).

• The condition if i != j: ensures that we don't add a self-loop, meaning we don’t connect a node to itself.

• The statement adj_list[nodes[i]].append(nodes[j]) adds an edge from node i to node j.

• The final adjacency list will have edges from every node to every other node (except self-loops).

16. How to Extract Items from an Adjacency Matrix

Explanation:

Once you have an adjacency matrix, you can extract the value at a specific row and column using indexing. This allows you to check if two nodes are connected (1) or not (0) based on their row and column positions.

How to Write:

Here’s an example of extracting items from an adjacency matrix:

# Example adjacency matrix

adj_matrix = [

[0, 1, 1, 0], # A is connected to B, C

[1, 0, 0, 1], # B is connected to A, D

[1, 0, 0, 1], # C is connected to A, D

[0, 1, 1, 0] # D is connected to B, C

]

# Extracting item from adjacency matrix

print(adj_matrix[0][1]) # A to B (should print 1)

print(adj_matrix[1][2]) # B to C (should print 0)

Explain:

• adj_matrix[0][1] accesses the value at the first row (A) and second column (B), which is 1, meaning there is an edge between A and B.

• adj_matrix[1][2] accesses the value at the second row (B) and third column (C), which is 0, meaning there is no edge between B and C.

• This indexing allows us to easily extract information about whether there’s a direct connection between two nodes.

17. How to Extract Items from an Adjacency List

Explanation:

An adjacency list is usually implemented using a dictionary, and to extract items from the list, you can index the dictionary by the node (key) and retrieve the list of neighboring nodes (value). You can then loop through or access specific neighbors.

How to Write:

Here’s an example of extracting items from an adjacency list:

# Example adjacency list

adj_list = { "A": ["B", "C"], "B": ["A", "D"], "C": ["A", "D"], "D": ["B", "C"] }

# Extracting items from adjacency list

print(adj_list["A"]) # Neighbors of A (should print ['B', 'C'])

print(adj_list["B"]) # Neighbors of B (should print ['A', 'D'])

Explain:

• adj_list["A"] accesses the list of neighbors for node "A", which is ["B", "C"].

• Similarly, adj_list["B"] accesses the list of neighbors for node "B", which is ["A", "D"].

• This direct indexing allows easy access to the neighbors of any node in the adjacency list.

18. Recap on Logic Operators in Conditional Statements

Explanation:

Logic operators (and, or, not) are used to combine multiple conditions in a conditional statement, enabling you to make more complex decisions. These operators are especially useful in decision-making processes, such as checking multiple conditions simultaneously.

How to Write:

Here’s an example using logic operators:

x = 5

y = 10 # Using logical operators in an if statement

if x > 3 and y < 15: # Both conditions must be True

print("Both conditions are True")

if x < 3 or y > 5: # At least one condition must be True

print("At least one condition is True")

if not(x > 3): # Negates the condition

print("x is not greater than 3")

Explain:

• The first if statement checks if both x > 3 and y < 15 are true using the and operator. If both conditions are true, the code inside the block will execute.

• The second if statement checks if either x < 3 or y > 5 is true using the or operator. If at least one condition is true, the code block will execute.

• The third if statement uses not to negate the condition x > 3. If x is not greater than 3, the code block executes.

• Logic operators allow combining multiple conditions for more complex decision-making.

19. Catching Two Return Values from a Function Into Two Variables at Once

Explanation:

In Python, functions can return multiple values. You can catch these return values into multiple variables by unpacking them. This is very useful when a function returns more than one piece of information, like a pair of related values.

How to Write:

Here’s an example of catching two return values from a function:

# Function that returns two values

def get_coordinates():

return 10, 20

# Returning a tuple

# Catching the two return values

x, y = get_coordinates()

print(f"x: {x}, y: {y}")

Explain:

• The function get_coordinates returns two values as a tuple: 10 and 20.

• The line x, y = get_coordinates() unpacks the tuple into two separate variables x and y.

• This allows you to access each value separately, x being 10 and y being 20.

• This technique is useful when a function needs to return multiple related pieces of information, such as coordinates, dimensions, or multiple results.

Maze solver

Recap on Accessing Elements of Lists Through Indexes

Explanation:
A list in Python is a collection of items that are ordered and can be changed. Lists are useful for storing multiple values in a single variable. Each item in a list has an index that starts at 0. This means the first item is at index 0, the second item is at index 1, and so on.

You can access an element in a list by specifying its index. Negative indexes can be used to access elements from the end of the list (-1 is the last element).

How to Write:

To access an element from a list:

1. Write the name of the list.

2. Use square brackets [] to specify the index.

Example:

# Define a list

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

# Access elements by index

first_fruit = fruits[0] #Access the first element

last_fruit = fruits[-1] # Access the last element

Explain:

• fruits[0] retrieves the first item in the list, which is "apple".

• fruits[-1] retrieves the last item in the list, which is "cherry".

• Lists are zero-indexed, so the first element is at index 0, not 1.

What is a 2D Array and How Do We Create Them in Python

Explanation:
A 2D array is essentially a list of lists. It’s like a grid or a table with rows and columns. Each element in the main list is another list, and you can access elements using two indexes — one for the row and one for the column.

How to Write:

To create a 2D array:

1. Define a list.

2. Add lists as elements inside the main list.

Example:

# Create a 2D array (grid)

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

Explain:

• The grid contains three lists, each representing a row.

• grid[0] is [1, 2, 3], the first row.

• grid[1] is [4, 5, 6], the second row.

• grid[2] is [7, 8, 9], the third row.

How to Access Elements from a 2D Array (Tuple Within List) Using Indexing

Explanation:
To access a specific element in a 2D array, use two indexes: the first index for the row and the second index for the column.

How to Write:

To access an element:

1. Specify the row index.

2. Specify the column index.

Example:

# Access elements in a 2D array

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

# Access specific elements

value = grid[1][2] # Access the element in the 2nd row and 3rd column

Explain:

• grid[1] accesses the second row: [4, 5, 6].

• grid[1][2] accesses the third element in that row, which is 6.

Recap on .append Method

Explanation:
The .append() method adds an element to the end of a list. It’s useful for dynamically growing a list as your program runs.

How to Write:

To add an item to a list using .append():

1. Call the .append() method on the list.

2. Pass the item you want to add as an argument.

Example:

# Define a list

numbers = [1, 2, 3]

# Append a new element

numbers.append(4)

Explain:

• numbers starts as [1, 2, 3].

• numbers.append(4) adds 4 to the end of the list, making it [1, 2, 3, 4].

• The .append() method modifies the original list directly.

If statements with boolean values

Explanation:

An if statement is used to control the flow of a program based on a condition. A boolean value is either True or False. Python allows you to directly use a variable containing a boolean in an if condition without explicitly comparing it to True or False. For example:

is_happy = True if is_happy: print("I'm happy!")

How to write:

1. Define a variable with a boolean value (True or False).

2. Use the variable directly in the if condition.

Example:

# Define a boolean variable

light_on = False

# Check the condition

if light_on:

print("The light is on!")

else:

print("The light is off.")

Explain:

• Step 1: The variable light_on is set to False.

• Step 2: The if checks the value of light_on. Since it is False, the else block executes.

• Python simplifies condition checking by allowing you to omit comparisons like if light_on == True.

Recap on using and/or/not in conditionals

Explanation:

Logical operators and, or, and not are used to combine or modify conditions in if statements.

• and: Both conditions must be True.

• or: At least one condition must be True.

• not: Reverses the boolean value.

How to write:

1. Use and to ensure all conditions are met.

2. Use or to allow flexibility in conditions.

3. Use not to invert a condition.

Example:

# Multiple conditions with logical operators

is_raining = True

has_umbrella = False

if is_raining and not has_umbrella:

print("You need an umbrella!")

elif not is_raining or has_umbrella:

print("You're fine without an umbrella.")

Explain:

• is_raining and not has_umbrella: True because it’s raining and you don’t have an umbrella.

• not is_raining or has_umbrella: Evaluates to False, but it doesn’t execute because the first condition was True.

• Logical operators combine or alter the conditions for the if and elif.

Calling functions within if statements

Explanation:

Python allows you to call a function directly inside an if condition. This is useful when you need to check the result of a function’s execution to decide the program’s flow.

How to write:

1. Define a function that returns a value (e.g., True, False, or a number).

2. Use the function call inside the if condition.

Example:

# Define a function

def is_even(number):

return number % 2 == 0

# Call the function in an if statement

num = 4

if is_even(num):

print(f"{num} is even.")

else:

print(f"{num} is odd.")

Explain:

• Step 1: The function is_even checks if a number is divisible by 2.

• Step 2: is_even(4) returns True, so the first if block runs, printing "4 is even."

• Functions allow modular, reusable logic to be checked directly within conditions.

Returning values to functions within if statements

Explanation:

In Python, you can use return inside a function to send a value back to the caller. In an if statement, you can immediately use the returned value to determine the next step.

How to write:

1. Define a function that uses return to send back a value.

2. Call the function inside an if statement to make decisions based on the returned value.

Example:

# Define a function

def check_positive(number):

if number > 0:

return True

else:

return False

# Use the returned value in an if statement

num = -5

if check_positive(num):

print(f"{num} is positive.")

else:

print(f"{num} is not positive.")

Explain:

• Step 1: The check_positive function evaluates if the number is greater than 0.

• Step 2: It returns True if the number is positive, otherwise False.

• Step 3: The if statement receives the returned value and decides which block to execute.

Detailed explanation on recursion (what recursion is - how it works)

Explanation:

Recursion is a technique in programming where a function calls itself to solve smaller instances of the same problem. It continues to call itself until it reaches a condition called the base case, which stops the recursion.

• Key Components of Recursion:

  • Base Case: The condition that stops the recursion.

  • Recursive Case: The part of the function where it calls itself with a smaller or simpler input.

• Recursion is often used for problems like calculating factorials, traversing data structures, or solving puzzles.

How to write:

1. Define a function.

2. Include a base case to stop the recursion.

3. Call the function itself with modified arguments to approach the base case.

Example:

# Recursive function to calculate factorial

def factorial(n): # Base case

if n == 0:

return 1 # Recursive case

return n * factorial(n - 1) # Call the function

result = factorial(5)

print(result)

Explain:

• Step 1: The function is called with n = 5. It checks the base case (n == 0), which is False.

• Step 2: The function calls itself as factorial(4). This process continues until n = 0.

• Step 3: When n = 0, the base case is satisfied, and the recursion stops by returning 1.

• Step 4: The returned values are multiplied step-by-step in reverse order:

  • factorial(1) → 1 * 1 = 1

  • factorial(2) → 2 * 1 = 2

  • factorial(3) → 3 * 2 = 6

  • factorial(4) → 4 * 6 = 24

  • factorial(5) → 5 * 24 = 120