# This is a comment. Comments are ignored by the Python interpreter.
print("Hello, World!")

  if 5 > 2:
      print("Five is greater than two!")

  # This is a single-line comment
  '''
  This is a
  multi-line comment
  '''

$ python
>>> print("Hello, Python!")
Hello, Python!

x = 10          # x is an integer
name = "Alice"  # name is a string
is_student = True  # is_student is a boolean

   age = 25

   height = 5.9

   name = "Alice"
   greeting = 'Hello, World!'

   is_student = True
   is_working = False

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

   coordinates = (10.0, 20.0)

   person = {"name": "Alice", "age": 25}

   unique_numbers = {1, 2, 3, 4}

x = 10       # x is an integer
x = "Hello"  # Now x is a string

x = 10
print(type(x))  # Output: <class 'int'>

y = "Python"
print(type(y))  # Output: <class 'str'>

x = 10
y = float(x)  # Convert integer to float
print(y)      # Output: 10.0

z = str(x)    # Convert integer to string
print(z)      # Output: "10"

# Variables and Data Types
name = "Alice"
age = 25
height = 5.9
is_student = True

# Displaying values and types
print("Name:", name, type(name))
print("Age:", age, type(age))
print("Height:", height, type(height))
print("Is Student:", is_student, type(is_student))

string1 = "Hello, World!"
string2 = 'Python is fun!'

string3 = "It's a beautiful day."
string4 = 'He said, "Python is awesome!"'

multi_line_string = """This is a
multi-line
string."""

   first_name = "Alice"
   last_name = "Smith"
   full_name = first_name + " " + last_name
   print(full_name)  # Output: Alice Smith

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

   text = "Python"
   print(len(text))  # Output: 6

   text = "Python"
   print(text[0])  # Output: P
   print(text[3])  # Output: h

   print(text[-1])  # Output: n
   print(text[-2])  # Output: o

   text = "Python Programming"
   print(text[0:6])   # Output: Python
   print(text[7:18])  # Output: Programming
   print(text[:6])    # Output: Python (from start to index 5)
   print(text[7:])    # Output: Programming (from index 7 to end)
   print(text[::2])   # Output: Pto rgamn (every second character)

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

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

   text = "  Python  "
   print(text.strip())  # Output: Python

   text = "Hello, World!"
   print(text.replace("World", "Python"))  # Output: Hello, Python!

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

   text = "Python is fun"
   print(text.find("is"))  # Output: 7

   text = "Python is fun and Python is easy"
   print(text.count("Python"))  # Output: 2

   text = "Python is fun"
   print(text.startswith("Python"))  # Output: True
   print(text.endswith("fun"))       # Output: True

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

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

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

print("Hello,\nWorld!")  # Output: Hello,
                         #         World!

# Working with Strings
text = "Python is fun!"

# String operations
print("Length:", len(text))
print("First character:", text[0])
print("Last character:", text[-1])
print("Substring:", text[0:6])

# String methods
print("Uppercase:", text.upper())
print("Lowercase:", text.lower())
print("Replace 'fun' with 'awesome':", text.replace("fun", "awesome"))

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

   x = 10
   y = -5

   pi = 3.14
   temperature = -10.5

a = 10
b = 3

print(a + b)   # Output: 13 (Addition)
print(a - b)   # Output: 7  (Subtraction)
print(a * b)   # Output: 30 (Multiplication)
print(a / b)   # Output: 3.333... (Division)
print(a // b)  # Output: 3  (Floor Division - rounds down to the nearest integer)
print(a % b)   # Output: 1  (Modulus - remainder of division)
print(a ** b)  # Output: 1000 (Exponentiation - a raised to the power of b)

result = 10 + 3 * 2 ** 2  # 2 ** 2 = 4 → 3 * 4 = 12 → 10 + 12 = 22
print(result)  # Output: 22

result = (10 + 3) * 2 ** 2  # 10 + 3 = 13 → 2 ** 2 = 4 → 13 * 4 = 52
print(result)  # Output: 52

x = 10
y = 3.14

# Convert float to integer
print(int(y))  # Output: 3 (truncates the decimal part)

# Convert integer to float
print(float(x))  # Output: 10.0

import math

   print(math.sqrt(16))  # Output: 4.0

   print(math.pow(2, 3))  # Output: 8.0 (2 raised to the power of 3)

   print(math.floor(3.7))  # Output: 3

   print(math.ceil(3.2))  # Output: 4

   print(math.fabs(-10))  # Output: 10.0

   print(math.pi)  # Output: 3.141592653589793
   print(math.e)   # Output: 2.718281828459045

large_number = 123456789012345678901234567890
print(large_number)  # Output: 123456789012345678901234567890

scientific_number = 1.23e6  # 1.23 * 10^6
print(scientific_number)  # Output: 1230000.0

# Working with Numbers
a = 10
b = 3

# Arithmetic operations
print("Addition:", a + b)
print("Subtraction:", a - b)
print("Multiplication:", a * b)
print("Division:", a / b)
print("Floor Division:", a // b)
print("Modulus:", a % b)
print("Exponentiation:", a ** b)

# Order of operations
result = (a + b) * 2 ** 2
print("Result of (a + b) * 2 ** 2:", result)

# Type conversion
x = 3.14
print("Convert float to int:", int(x))
print("Convert int to float:", float(a))

# Math module
import math
print("Square root of 16:", math.sqrt(16))
print("2 raised to the power of 3:", math.pow(2, 3))
print("Floor of 3.7:", math.floor(3.7))
print("Ceiling of 3.2:", math.ceil(3.2))
print("Absolute value of -10:", math.fabs(-10))
print("Value of pi:", math.pi)

input(prompt)

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

   age = input("Enter your age: ")
   print(type(age))  # Output: <class 'str'>

   age = int(input("Enter your age: "))
   print(type(age))  # Output: <class 'int'>

# Simple Calculator
num1 = float(input("Enter the first number: "))
num2 = float(input("Enter the second number: "))

print("Addition:", num1 + num2)
print("Subtraction:", num1 - num2)
print("Multiplication:", num1 * num2)
print("Division:", num1 / num2)

# Taking multiple inputs
values = input("Enter two numbers separated by a space: ").split()
num1 = float(values[0])
num2 = float(values[1])

print("Sum:", num1 + num2)

# User Registration
name = input("Enter your name: ")
age = int(input("Enter your age: "))
email = input("Enter your email: ")

print("\nUser Details:")
print(f"Name: {name}")
print(f"Age: {age}")
print(f"Email: {email}")

try:
    age = int(input("Enter your age: "))
    print("Your age is:", age)
except ValueError:
    print("Invalid input! Please enter a valid number.")

# Getting Input From Users
name = input("Enter your name: ")
age = int(input("Enter your age: "))
height = float(input("Enter your height in meters: "))

print("\nUser Profile:")
print(f"Name: {name}")
print(f"Age: {age}")
print(f"Height: {height} meters")

# Simple calculation
birth_year = 2023 - age
print(f"You were born in {birth_year}.")

my_list = [element1, element2, element3]

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

# List of strings
fruits = ["apple", "banana", "cherry"]

# Mixed data types
mixed_list = [1, "apple", 3.14, True]

# Nested list (list inside a list)
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

my_list[index]

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

print(fruits[0])  # Output: apple
print(fruits[1])  # Output: banana
print(fruits[2])  # Output: cherry

  print(fruits[-1])  # Output: cherry (last element)
  print(fruits[-2])  # Output: banana (second last element)

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

  print(numbers[2:5])   # Output: [3, 4, 5] (elements from index 2 to 4)
  print(numbers[:4])    # Output: [1, 2, 3, 4] (elements from start to index 3)
  print(numbers[5:])    # Output: [6, 7, 8, 9] (elements from index 5 to end)
  print(numbers[::2])   # Output: [1, 3, 5, 7, 9] (every second element)

   fruits = ["apple", "banana", "cherry"]
   fruits[1] = "blueberry"
   print(fruits)  # Output: ["apple", "blueberry", "cherry"]

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

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

     fruits.remove("blueberry")
     print(fruits)  # Output: ["apple", "mango", "cherry", "orange"]

     removed_fruit = fruits.pop(1)
     print(removed_fruit)  # Output: mango
     print(fruits)         # Output: ["apple", "cherry", "orange"]

     del fruits[0]
     print(fruits)  # Output: ["cherry", "orange"]

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

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

   repeated = [1, 2] * 3
   print(repeated)  # Output: [1, 2, 1, 2, 1, 2]

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

   fruits = ["apple", "banana", "cherry"]
   print("banana" in fruits)  # Output: True
   print("mango" in fruits)   # Output: False

   numbers = [3, 1, 4, 1, 5, 9]
   numbers.sort()
   print(numbers)  # Output: [1, 1, 3, 4, 5, 9]

   numbers.reverse()
   print(numbers)  # Output: [9, 5, 4, 3, 1, 1]

   new_numbers = numbers.copy()
   print(new_numbers)  # Output: [9, 5, 4, 3, 1, 1]

   print(numbers.index(4))  # Output: 2

   print(numbers.count(1))  # Output: 2

# Working with Lists
fruits = ["apple", "banana", "cherry"]

# Accessing elements
print("First fruit:", fruits[0])
print("Last fruit:", fruits[-1])

# Modifying lists
fruits.append("orange")
fruits.insert(1, "mango")
fruits.remove("banana")
removed_fruit = fruits.pop(2)

# List operations
print("Fruits:", fruits)
print("Number of fruits:", len(fruits))
print("Is 'apple' in the list?", "apple" in fruits)

# Sorting and reversing
fruits.sort()
print("Sorted fruits:", fruits)
fruits.reverse()
print("Reversed fruits:", fruits)

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

   print(max(numbers))  # Output: 5

   print(min(numbers))  # Output: 1

   print(sum(numbers))  # Output: 15

   unsorted = [3, 1, 4, 1, 5, 9]
   sorted_list = sorted(unsorted)
   print(sorted_list)  # Output: [1, 1, 3, 4, 5, 9]
   print(unsorted)     # Output: [3, 1, 4, 1, 5, 9] (original list unchanged)

   boolean_list = [False, True, False]
   print(any(boolean_list))  # Output: True

   print(all(boolean_list))  # Output: False

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

   fruits.extend(["orange", "mango"])
   print(fruits)  # Output: ["apple", "banana", "cherry", "orange", "mango"]

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

   fruits.remove("banana")
   print(fruits)  # Output: ["apple", "blueberry", "cherry", "orange", "mango"]

   removed_fruit = fruits.pop(2)
   print(removed_fruit)  # Output: cherry
   print(fruits)         # Output: ["apple", "blueberry", "orange", "mango"]

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

   numbers = [10, 20, 30, 20, 40]
   print(numbers.index(20))  # Output: 1

   print(numbers.count(20))  # Output: 2

   numbers.sort()
   print(numbers)  # Output: [10, 20, 20, 30, 40]

     numbers.sort(reverse=True)
     print(numbers)  # Output: [40, 30, 20, 20, 10]

    numbers.reverse()
    print(numbers)  # Output: [10, 20, 20, 30, 40]

    new_numbers = numbers.copy()
    print(new_numbers)  # Output: [10, 20, 20, 30, 40]

[expression for item in iterable if condition]

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

   even_numbers = [x for x in range(10) if x % 2 == 0]
   print(even_numbers)  # Output: [0, 2, 4, 6, 8]

   fruits = ["apple", "banana", "cherry"]
   uppercase_fruits = [fruit.upper() for fruit in fruits]
   print(uppercase_fruits)  # Output: ["APPLE", "BANANA", "CHERRY"]

# List Functions and Methods
numbers = [3, 1, 4, 1, 5, 9]

# Common functions
print("Length:", len(numbers))
print("Max:", max(numbers))
print("Min:", min(numbers))
print("Sum:", sum(numbers))
print("Sorted:", sorted(numbers))

# Common methods
numbers.append(2)
print("After append:", numbers)

numbers.extend([7, 8])
print("After extend:", numbers)

numbers.insert(2, 10)
print("After insert:", numbers)

numbers.remove(1)
print("After remove:", numbers)

popped = numbers.pop(3)
print("Popped element:", popped)
print("After pop:", numbers)

print("Index of 5:", numbers.index(5))
print("Count of 1:", numbers.count(1))

numbers.sort()
print("Sorted list:", numbers)

numbers.reverse()
print("Reversed list:", numbers)

# List comprehension
squares = [x ** 2 for x in numbers]
print("Squares:", squares)

my_tuple = (element1, element2, element3)

# Tuple of integers
numbers = (1, 2, 3, 4, 5)

# Tuple of strings
fruits = ("apple", "banana", "cherry")

# Mixed data types
mixed_tuple = (1, "apple", 3.14, True)

# Single-element tuple
single_element = (42,)  # Note the trailing comma

  not_a_tuple = (42)  # This is an integer, not a tuple

   fruits = ("apple", "banana", "cherry")
   print(fruits[0])  # Output: apple
   print(fruits[2])  # Output: cherry

   print(fruits[-1])  # Output: cherry (last element)
   print(fruits[-2])  # Output: banana (second last element)

   numbers = (1, 2, 3, 4, 5, 6, 7, 8, 9)
   print(numbers[2:5])   # Output: (3, 4, 5) (elements from index 2 to 4)
   print(numbers[:4])    # Output: (1, 2, 3, 4) (elements from start to index 3)
   print(numbers[5:])    # Output: (6, 7, 8, 9) (elements from index 5 to end)
   print(numbers[::2])   # Output: (1, 3, 5, 7, 9) (every second element)

fruits = ("apple", "banana", "cherry")
# fruits[1] = "blueberry"  # This will raise a TypeError

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

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

   fruits = ("apple", "banana", "cherry")
   print("banana" in fruits)  # Output: True
   print("mango" in fruits)   # Output: False

   print(len(fruits))  # Output: 3

   numbers = (1, 2, 3, 1, 2, 1)
   print(numbers.count(1))  # Output: 3

   print(numbers.index(2))  # Output: 1

# Using a tuple as a dictionary key
location = {
    (40.7128, -74.0060): "New York",
    (34.0522, -118.2437): "Los Angeles"
}
print(location[(40.7128, -74.0060)])  # Output: New York

coordinates = (10.0, 20.0)
x, y = coordinates
print("x:", x)  # Output: x: 10.0
print("y:", y)  # Output: y: 20.0

# Working with Tuples
fruits = ("apple", "banana", "cherry")

# Accessing elements
print("First fruit:", fruits[0])
print("Last fruit:", fruits[-1])

# Slicing
print("First two fruits:", fruits[:2])

# Tuple operations
numbers = (1, 2, 3)
repeated = numbers * 2
print("Repeated tuple:", repeated)

# Tuple methods
print("Count of 'banana':", fruits.count("banana"))
print("Index of 'cherry':", fruits.index("cherry"))

# Unpacking
x, y, z = fruits
print("Unpacked values:", x, y, z)

# Using tuples as dictionary keys
location = {
    (40.7128, -74.0060): "New York",
    (34.0522, -118.2437): "Los Angeles"
}
print("Location:", location[(40.7128, -74.0060)])

def function_name(parameters):
    # Code to execute
    return result  # Optional

# Define a function
def greet():
    print("Hello, World!")

# Call the function
greet()  # Output: Hello, World!

# Function with parameters
def greet(name):
    print(f"Hello, {name}!")

# Call the function with an argument
greet("Alice")  # Output: Hello, Alice!
greet("Bob")    # Output: Hello, Bob!

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

# Call the function and store the result
result = add(3, 5)
print(result)  # Output: 8

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

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

def describe_pet(pet_name, animal_type="dog"):
    print(f"I have a {animal_type} named {pet_name}.")

# Using keyword arguments
describe_pet(pet_name="Max", animal_type="cat")  # Output: I have a cat named Max.
describe_pet(animal_type="hamster", pet_name="Bella")  # Output: I have a hamster named Bella.

# Using *args
def add_numbers(*args):
    return sum(args)

print(add_numbers(1, 2, 3))  # Output: 6

# Using **kwargs
def describe_pet(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

describe_pet(name="Max", animal_type="dog", age=3)
# Output:
# name: Max
# animal_type: dog
# age: 3

x = 10  # Global variable

def my_function():
    y = 5  # Local variable
    print(x)  # Access global variable
    print(y)  # Access local variable

my_function()
print(x)  # Output: 10
# print(y)  # This will raise an error (y is local to my_function)

lambda arguments: expression

# Lambda function to add two numbers
add = lambda a, b: a + b
print(add(3, 5))  # Output: 8

# Working with Functions

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

# Call the function
greet()          # Output: Hello, Guest!
greet("Alice")   # Output: Hello, Alice!

# Function with return value
def add(a, b):
    return a + b

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

# Function with *args
def multiply(*args):
    product = 1
    for num in args:
        product *= num
    return product

print("Product:", multiply(2, 3, 4))  # Output: Product: 24

# Lambda function
square = lambda x: x ** 2
print("Square of 5:", square(5))  # Output: Square of 5: 25

def function_name(parameters):
    # Code to execute
    return value  # Value to return

def add(a, b):
    return a + b

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

def calculate(a, b):
    sum = a + b
    difference = a - b
    product = a * b
    return sum, difference, product

result = calculate(10, 5)
print(result)  # Output: (15, 5, 50)

# Unpack the returned tuple
sum, difference, product = calculate(10, 5)
print("Sum:", sum)          # Output: Sum: 15
print("Difference:", difference)  # Output: Difference: 5
print("Product:", product)  # Output: Product: 50

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

result = greet("Alice")
print(result)  # Output: None

def is_positive(number):
    if number > 0:
        return True
    return False

print(is_positive(10))  # Output: True
print(is_positive(-5))  # Output: False

# Returning a list
def get_even_numbers(limit):
    return [x for x in range(limit) if x % 2 == 0]

print(get_even_numbers(10))  # Output: [0, 2, 4, 6, 8]

# Returning a dictionary
def create_person(name, age):
    return {"name": name, "age": age}

print(create_person("Alice", 25))  # Output: {'name': 'Alice', 'age': 25}

def create_multiplier(factor):
    def multiplier(number):
        return number * factor
    return multiplier

double = create_multiplier(2)
print(double(5))  # Output: 10

# Working with the Return Statement

# Function to return a single value
def add(a, b):
    return a + b

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

# Function to return multiple values
def calculate(a, b):
    sum = a + b
    difference = a - b
    product = a * b
    return sum, difference, product

sum, difference, product = calculate(10, 5)
print("Sum:", sum)          # Output: Sum: 15
print("Difference:", difference)  # Output: Difference: 5
print("Product:", product)  # Output: Product: 50

# Function with early return
def is_positive(number):
    if number > 0:
        return True
    return False

print("Is 10 positive?", is_positive(10))  # Output: Is 10 positive? True
print("Is -5 positive?", is_positive(-5))  # Output: Is -5 positive? False

# Function returning a list
def get_even_numbers(limit):
    return [x for x in range(limit) if x % 2 == 0]

print("Even numbers up to 10:", get_even_numbers(10))  # Output: [0, 2, 4, 6, 8]

# Function returning a dictionary
def create_person(name, age):
    return {"name": name, "age": age}

print("Person:", create_person("Alice", 25))  # Output: {'name': 'Alice', 'age': 25}

# Function returning another function
def create_multiplier(factor):
    def multiplier(number):
        return number * factor
    return multiplier

double = create_multiplier(2)
print("Double of 5:", double(5))  # Output: Double of 5: 10

if condition:
    # Code to execute if the condition is true

age = 18

if age >= 18:
    print("You are an adult.")

if condition:
    # Code to execute if the condition is true
else:
    # Code to execute if the condition is false

age = 15

if age >= 18:
    print("You are an adult.")
else:
    print("You are a minor.")

if condition1:
    # Code to execute if condition1 is true
elif condition2:
    # Code to execute if condition2 is true
else:
    # Code to execute if all conditions are false

age = 25

if age < 13:
    print("You are a child.")
elif age < 18:
    print("You are a teenager.")
else:
    print("You are an adult.")

age = 20
has_license = True

if age >= 18:
    if has_license:
        print("You can drive.")
    else:
        print("You are old enough to drive but don't have a license.")
else:
    print("You are too young to drive.")

   age = 20
   has_license = True

   if age >= 18 and has_license:
       print("You can drive.")

   age = 16
   has_parental_consent = True

   if age >= 18 or has_parental_consent:
       print("You can participate.")

   is_raining = False

   if not is_raining:
       print("Let's go outside!")

name = ""

if name:
    print("Hello, " + name)
else:
    print("Name is empty.")

# Working with If Statements

# Simple If Statement
age = 18
if age >= 18:
    print("You are an adult.")

# If-Else Statement
age = 15
if age >= 18:
    print("You are an adult.")
else:
    print("You are a minor.")

# If-Elif-Else Statement
age = 25
if age < 13:
    print("You are a child.")
elif age < 18:
    print("You are a teenager.")
else:
    print("You are an adult.")

# Nested If Statements
age = 20
has_license = True
if age >= 18:
    if has_license:
        print("You can drive.")
    else:
        print("You are old enough to drive but don't have a license.")
else:
    print("You are too young to drive.")

# Logical Operators
age = 20
has_license = True
if age >= 18 and has_license:
    print("You can drive.")

# Truthy and Falsy Values
name = ""
if name:
    print("Hello, " + name)
else:
    print("Name is empty.")

x = 10
y = 5

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

x = 10
y = 5
z = 7

if x > y and y < z:
    print("x is greater than y, and y is less than z")

x = 10
y = 5
z = 7

if x > y and y < z:
    print("x is greater than y, and y is less than z")

name1 = "Alice"
name2 = "Bob"

if name1 < name2:
    print(f"{name1} comes before {name2} in the dictionary.")
else:
    print(f"{name1} comes after {name2} in the dictionary.")

list1 = [1, 2, 3]
list2 = [1, 2, 4]

if list1 < list2:
    print("list1 is less than list2")

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

if "banana" in fruits:
    print("Banana is in the list.")

if "mango" not in fruits:
    print("Mango is not in the list.")

# Working with If Statements & Comparisons

# Comparing numbers
x = 10
y = 5

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

# Chaining comparisons
z = 7
if x > y and y < z:
    print("x is greater than y, and y is less than z")

# Comparing strings
name1 = "Alice"
name2 = "Bob"

if name1 < name2:
    print(f"{name1} comes before {name2} in the dictionary.")
else:
    print(f"{name1} comes after {name2} in the dictionary.")

# Comparing lists
list1 = [1, 2, 3]
list2 = [1, 2, 4]

if list1 < list2:
    print("list1 is less than list2")

# Membership testing
fruits = ["apple", "banana", "cherry"]

if "banana" in fruits:
    print("Banana is in the list.")

if "mango" not in fruits:
    print("Mango is not in the list.")

my_dict = {
    key1: value1,
    key2: value2,
    key3: value3
}

# Dictionary of person details
person = {
    "name": "Alice",
    "age": 25,
    "city": "New York"
}

# Using dict() constructor
person = dict(name="Alice", age=25, city="New York")

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

# Accessing values
print(person["name"])  # Output: Alice
print(person.get("age"))  # Output: 25

  print(person.get("country", "Unknown"))  # Output: Unknown

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

# Adding a new key-value pair
person["country"] = "USA"

# Updating an existing key
person["age"] = 26

print(person)
# Output: {'name': 'Alice', 'age': 26, 'city': 'New York', 'country': 'USA'}

   del person["city"]
   print(person)  # Output: {'name': 'Alice', 'age': 26, 'country': 'USA'}

   age = person.pop("age")
   print(age)  # Output: 26
   print(person)  # Output: {'name': 'Alice', 'country': 'USA'}

   last_item = person.popitem()
   print(last_item)  # Output: ('country', 'USA')
   print(person)  # Output: {'name': 'Alice'}

   person.clear()
   print(person)  # Output: {}

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

   print(person.values())  # Output: dict_values(['Alice', 25, 'New York'])

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

   person.update({"country": "USA", "age": 26})
   print(person)  # Output: {'name': 'Alice', 'age': 26, 'city': 'New York', 'country': 'USA'}

   person_copy = person.copy()
   print(person_copy)

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

# Iterate over keys
for key in person:
    print(key)

# Iterate over values
for value in person.values():
    print(value)

# Iterate over key-value pairs
for key, value in person.items():
    print(f"{key}: {value}")

{key_expression: value_expression for item in iterable}

# Create a dictionary of squares
squares = {x: x ** 2 for x in range(1, 6)}
print(squares)  # Output: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

students = {
    "Alice": {"age": 25, "grade": "A"},
    "Bob": {"age": 22, "grade": "B"},
    "Charlie": {"age": 23, "grade": "C"}
}

# Accessing nested dictionary values
print(students["Alice"]["age"])  # Output: 25

# Working with Dictionaries

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

# Accessing values
print("Name:", person["name"])
print("Age:", person.get("age"))

# Adding/updating entries
person["country"] = "USA"
person["age"] = 26

# Removing entries
del person["city"]
age = person.pop("age")
last_item = person.popitem()

# Dictionary methods
print("Keys:", person.keys())
print("Values:", person.values())
print("Items:", person.items())

# Iterating over a dictionary
for key, value in person.items():
    print(f"{key}: {value}")

# Dictionary comprehension
squares = {x: x ** 2 for x in range(1, 6)}
print("Squares:", squares)

# Nested dictionaries
students = {
    "Alice": {"age": 25, "grade": "A"},
    "Bob": {"age": 22, "grade": "B"},
    "Charlie": {"age": 23, "grade": "C"}
}
print("Alice's age:", students["Alice"]["age"])

while condition:
    # Code to execute

count = 0

while count < 5:
    print("Count:", count)
    count += 1  # Increment count

while True:
    print("This is an infinite loop!")

count = 0

while True:
    print("Count:", count)
    count += 1
    if count >= 5:
        break  # Exit the loop

count = 0

while count < 5:
    count += 1
    if count == 3:
        continue  # Skip the rest of the code for this iteration
    print("Count:", count)

count = 0

while count < 5:
    print("Count:", count)
    count += 1
else:
    print("Loop finished!")

i = 1

while i <= 3:
    j = 1
    while j <= 3:
        print(f"i: {i}, j: {j}")
        j += 1
    i += 1

secret_number = 7
guess = None

while guess != secret_number:
    guess = int(input("Guess the secret number (between 1 and 10): "))
    if guess < secret_number:
        print("Too low!")
    elif guess > secret_number:
        print("Too high!")
    else:
        print("Congratulations! You guessed it!")

# Working with While Loops

# Simple While Loop
count = 0
while count < 5:
    print("Count:", count)
    count += 1

# Infinite While Loop with Break
count = 0
while True:
    print("Count:", count)
    count += 1
    if count >= 5:
        break

# While Loop with Continue
count = 0
while count < 5:
    count += 1
    if count == 3:
        continue
    print("Count:", count)

# While Loop with Else
count = 0
while count < 5:
    print("Count:", count)
    count += 1
else:
    print("Loop finished!")

# Nested While Loops
i = 1
while i <= 3:
    j = 1
    while j <= 3:
        print(f"i: {i}, j: {j}")
        j += 1
    i += 1

# Guessing Game
secret_number = 7
guess = None
while guess != secret_number:
    guess = int(input("Guess the secret number (between 1 and 10): "))
    if guess < secret_number:
        print("Too low!")
    elif guess > secret_number:
        print("Too high!")
    else:
        print("Congratulations! You guessed it!")

for item in sequence:
    # Code to execute

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

for fruit in fruits:
    print(fruit)

message = "Hello"

for char in message:
    print(char)

range(start, stop, step)

   for i in range(5):
       print(i)

   for i in range(2, 6):
       print(i)

   for i in range(1, 10, 2):
       print(i)

for i in range(3):
    for j in range(3):
        print(f"i: {i}, j: {j}")

for i in range(10):
    if i == 5:
        break  # Exit the loop
    print(i)

for i in range(5):
    if i == 2:
        continue  # Skip the rest of the code for this iteration
    print(i)

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

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

for num in numbers:
    total += num

print("Sum:", total)

# Working with For Loops

# Iterating over a list
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

# Iterating over a string
message = "Hello"
for char in message:
    print(char)

# Using range()
for i in range(5):
    print(i)

for i in range(2, 6):
    print(i)

for i in range(1, 10, 2):
    print(i)

# Nested For Loops
for i in range(3):
    for j in range(3):
        print(f"i: {i}, j: {j}")

# Breaking out of a loop
for i in range(10):
    if i == 5:
        break
    print(i)

# Skipping iterations with continue
for i in range(5):
    if i == 2:
        continue
    print(i)

# For Loop with Else
for i in range(3):
    print(i)
else:
    print("Loop finished!")

# Summing numbers in a list
numbers = [1, 2, 3, 4, 5]
total = 0
for num in numbers:
    total += num
print("Sum:", total)

base ** exponent

# Calculate 2 raised to the power of 3
result = 2 ** 3
print(result)  # Output: 8

# Calculate 5 raised to the power of 2
result = 5 ** 2
print(result)  # Output: 25

pow(base, exponent)

# Calculate 2 raised to the power of 3
result = pow(2, 3)
print(result)  # Output: 8

# Calculate 5 raised to the power of 2
result = pow(5, 2)
print(result)  # Output: 25

math.pow(base, exponent)

import math

# Calculate 2 raised to the power of 3
result = math.pow(2, 3)
print(result)  # Output: 8.0

# Calculate 5 raised to the power of 2
result = math.pow(5, 2)
print(result)  # Output: 25.0

# Calculate 2 raised to the power of -3
result = 2 ** -3
print(result)  # Output: 0.125

# Calculate 5 raised to the power of -2
result = pow(5, -2)
print(result)  # Output: 0.04

# Calculate the square root of 16
result = 16 ** 0.5
print(result)  # Output: 4.0

# Calculate the cube root of 27
result = 27 ** (1/3)
print(result)  # Output: 3.0

def exponent(base, power):
    return base ** power

# Calculate 2 raised to the power of 3
result = exponent(2, 3)
print(result)  # Output: 8

# Working with Exponent Functions

# Using the ** operator
result = 2 ** 3
print("2 ** 3 =", result)  # Output: 8

result = 5 ** 2
print("5 ** 2 =", result)  # Output: 25

# Using the pow() function
result = pow(2, 3)
print("pow(2, 3) =", result)  # Output: 8

result = pow(5, 2)
print("pow(5, 2) =", result)  # Output: 25

# Using math.pow()
import math
result = math.pow(2, 3)
print("math.pow(2, 3) =", result)  # Output: 8.0

result = math.pow(5, 2)
print("math.pow(5, 2) =", result)  # Output: 25.0

# Handling negative exponents
result = 2 ** -3
print("2 ** -3 =", result)  # Output: 0.125

result = pow(5, -2)
print("pow(5, -2) =", result)  # Output: 0.04

# Handling fractional exponents
result = 16 ** 0.5
print("16 ** 0.5 =", result)  # Output: 4.0

result = 27 ** (1/3)
print("27 ** (1/3) =", result)  # Output: 3.0

# Custom exponent function
def exponent(base, power):
    return base ** power

result = exponent(2, 3)
print("exponent(2, 3) =", result)  # Output: 8

# A 2D list representing a 3x3 grid
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

matrix[row][column]

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

# Access the element in the second row, third column
print(matrix[1][2])  # Output: 6

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

for row in matrix:
    for element in row:
        print(element, end=" ")  # Print elements in the same row
    print()  # Move to the next line after each row

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

# Change the element in the first row, second column
matrix[0][1] = 10

print(matrix)
# Output: [[1, 10, 3], [4, 5, 6], [7, 8, 9]]

# Create a 3x3 matrix with all elements set to 0
matrix = [[0 for _ in range(3)] for _ in range(3)]
print(matrix)
# Output: [[0, 0, 0], [0, 0, 0], [0, 0, 0]]

# Define two 2x2 matrices
matrix1 = [
    [1, 2],
    [3, 4]
]

matrix2 = [
    [5, 6],
    [7, 8]
]

# Create a result matrix with the same dimensions
result = [[0 for _ in range(2)] for _ in range(2)]

# Perform matrix addition
for i in range(2):  # Iterate over rows
    for j in range(2):  # Iterate over columns
        result[i][j] = matrix1[i][j] + matrix2[i][j]

print(result)
# Output: [[6, 8], [10, 12]]

# Working with 2D Lists & Nested Loops

# Creating a 2D list
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# Accessing elements
print("Element at row 1, column 2:", matrix[1][2])  # Output: 6

# Iterating over a 2D list
print("Matrix elements:")
for row in matrix:
    for element in row:
        print(element, end=" ")
    print()

# Modifying a 2D list
matrix[0][1] = 10
print("Modified matrix:")
for row in matrix:
    for element in row:
        print(element, end=" ")
    print()

# Creating a 2D list using list comprehension
matrix2 = [[0 for _ in range(3)] for _ in range(3)]
print("2D list created using list comprehension:")
for row in matrix2:
    for element in row:
        print(element, end=" ")
    print()

# Matrix addition
matrix1 = [
    [1, 2],
    [3, 4]
]

matrix2 = [
    [5, 6],
    [7, 8]
]

result = [[0 for _ in range(2)] for _ in range(2)]

for i in range(2):
    for j in range(2):
        result[i][j] = matrix1[i][j] + matrix2[i][j]

print("Result of matrix addition:")
for row in result:
    for element in row:
        print(element, end=" ")
    print()

# This is a single-line comment

# Calculate the sum of two numbers
a = 5
b = 10
sum = a + b  # Store the result in the variable 'sum'
print(sum)

"""
This is a multi-line comment.
It can span multiple lines.
"""

"""
This program calculates the area of a rectangle.
It takes the length and width as input and prints the area.
"""
length = 10
width = 5
area = length * width
print("Area:", area)

   # Bad: This adds 5 and 10
   sum = 5 + 10

   # Good: Calculate the total cost including tax
   total_cost = price + (price * tax_rate)

   # TODO: Optimize this function for better performance
   def calculate_sum(numbers):
       return sum(numbers)

x = 10  # Initialize x with a value of 10

def add(a, b):
    """
    This function adds two numbers and returns the result.

    Parameters:
    a (int): The first number.
    b (int): The second number.

    Returns:
    int: The sum of a and b.
    """
    return a + b

# Access the docstring
print(add.__doc__)

# Working with Comments

# Single-line comment
# This program calculates the area of a rectangle

# Multi-line comment
"""
This program takes the length and width of a rectangle as input,
calculates the area, and prints the result.
"""

# Variables
length = 10  # Length of the rectangle
width = 5    # Width of the rectangle

# Calculate area
area = length * width  # Area = length * width

# Print the result
print("Area:", area)

# Function with a docstring
def multiply(a, b):
    """
    This function multiplies two numbers and returns the result.

    Parameters:
    a (int): The first number.
    b (int): The second number.

    Returns:
    int: The product of a and b.
    """
    return a * b

# Access the docstring
print(multiply.__doc__)

try:
    # Code that might raise an exception
except ExceptionType:
    # Code to handle the exception

try:
    num = int(input("Enter a number: "))
    result = 10 / num
    print("Result:", result)
except ZeroDivisionError:
    print("Error: Cannot divide by zero.")
except ValueError:
    print("Error: Invalid input. Please enter a number.")

try:
    num = int(input("Enter a number: "))
    result = 10 / num
    print("Result:", result)
except (ZeroDivisionError, ValueError):
    print("Error: Invalid input or division by zero.")

try:
    num = int(input("Enter a number: "))
    result = 10 / num
    print("Result:", result)
except:
    print("An error occurred.")

try:
    num = int(input("Enter a number: "))
    result = 10 / num
except ZeroDivisionError:
    print("Error: Cannot divide by zero.")
except ValueError:
    print("Error: Invalid input. Please enter a number.")
else:
    print("Result:", result)

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

def divide(a, b):
    if b == 0:
        raise ValueError("Cannot divide by zero.")
    return a / b

try:
    result = divide(10, 0)
except ValueError as e:
    print(e)  # Output: Cannot divide by zero.

class NegativeNumberError(Exception):
    pass

def check_positive(number):
    if number < 0:
        raise NegativeNumberError("Negative numbers are not allowed.")

try:
    check_positive(-5)
except NegativeNumberError as e:
    print(e)  # Output: Negative numbers are not allowed.

# Working with Try/Except

# Handling specific exceptions
try:
    num = int(input("Enter a number: "))
    result = 10 / num
    print("Result:", result)
except ZeroDivisionError:
    print("Error: Cannot divide by zero.")
except ValueError:
    print("Error: Invalid input. Please enter a number.")

# Using else and finally
try:
    file = open("example.txt", "r")
    content = file.read()
    print(content)
except FileNotFoundError:
    print("Error: File not found.")
else:
    print("File read successfully.")
finally:
    file.close()
    print("File closed.")

# Raising exceptions
def divide(a, b):
    if b == 0:
        raise ValueError("Cannot divide by zero.")
    return a / b

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

# Custom exceptions
class NegativeNumberError(Exception):
    pass

def check_positive(number):
    if number < 0:
        raise NegativeNumberError("Negative numbers are not allowed.")

try:
    check_positive(-5)
except NegativeNumberError as e:
    print(e)

file = open("filename", "mode")

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

file = open("example.txt", "r")
content = file.read()
print(content)
file.close()

   file = open("example.txt", "r")
   line = file.readline()
   while line:
       print(line, end="")  # end="" prevents extra newlines
       line = file.readline()
   file.close()

   file = open("example.txt", "r")
   for line in file:
       print(line, end="")
   file.close()

file = open("example.txt", "r")
lines = file.readlines()
for line in lines:
    print(line, end="")
file.close()

with open("filename", "mode") as file:
    # Code to work with the file

with open("example.txt", "r") as file:
    content = file.read()
    print(content)

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

with open("example.txt", "r") as file:
    first_10_chars = file.read(10)
    print(first_10_chars)

# Working with Reading Files

# Reading the entire file
with open("example.txt", "r") as file:
    content = file.read()
    print("Entire file content:")
    print(content)

# Reading line by line
with open("example.txt", "r") as file:
    print("\nFile content line by line:")
    for line in file:
        print(line, end="")

# Reading all lines into a list
with open("example.txt", "r") as file:
    lines = file.readlines()
    print("\nFile content as a list of lines:")
    for line in lines:
        print(line, end="")

# Handling file not found errors
try:
    with open("nonexistent.txt", "r") as file:
        content = file.read()
        print(content)
except FileNotFoundError:
    print("\nError: File not found.")

# Reading specific parts of a file
with open("example.txt", "r") as file:
    first_10_chars = file.read(10)
    print("\nFirst 10 characters of the file:")
    print(first_10_chars)

file = open("filename", "mode")

file = open("example.txt", "w")

file = open("example.txt", "w")
file.write("Hello, World!\n")
file.write("This is a new line.")
file.close()

# Read file content
with open("example.txt", "r") as file:
    content = file.read()
    print(content)

file = open("example.txt", "a")
file.write("\nThis line is appended.")
file.close()

# Read file content
with open("example.txt", "r") as file:
    content = file.read()
    print(content)

with open("filename", "mode") as file:
    # Code to work with the file

with open("example.txt", "w") as file:
    file.write("Hello, World!\n")
    file.write("This is a new line.")

# Read file content
with open("example.txt", "r") as file:
    content = file.read()
    print(content)

lines = ["Line 1\n", "Line 2\n", "Line 3\n"]

with open("example.txt", "w") as file:
    file.writelines(lines)

# Read file content
with open("example.txt", "r") as file:
    content = file.read()
    print(content)

try:
    with open("test.txt", "w") as file:
        file.write("Hello, World!")
except IOError:
    print("Error: Could not write to the file.")

# Working with Writing Files

# Writing to a new file
with open("example.txt", "w") as file:
    file.write("Hello, World!\n")
    file.write("This is a new line.")

# Appending to an existing file
with open("example.txt", "a") as file:
    file.write("\nThis line is appended.")

# Writing multiple lines
lines = ["Line 1\n", "Line 2\n", "Line 3\n"]
with open("example.txt", "w") as file:
    file.writelines(lines)

# Handling file errors
try:
    with open("example.txt", "w") as file:
        file.write("Hello, World!")
except IOError:
    print("Error: Could not write to the file.")

# Reading the file to verify its contents
with open("example.txt", "r") as file:
    content = file.read()
    print("File content:")
    print(content)

# mymodule.py
def greet(name):
    return f"Hello, {name}!"

def add(a, b):
    return a + b

import mymodule

# Using functions from the module
print(mymodule.greet("Alice"))  # Output: Hello, Alice!
print(mymodule.add(3, 5))       # Output: 8

from mymodule import greet, add

# Using the imported functions
print(greet("Bob"))  # Output: Hello, Bob!
print(add(2, 4))     # Output: 6

import mymodule as mm

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

import math

print(math.sqrt(16))  # Output: 4.0

pip install package_name

import requests

response = requests.get("https://www.example.com")
print(response.status_code)  # Output: 200 (if the request is successful)

pip list

# Working with Modules & Pip

# Importing a custom module
import mymodule

print(mymodule.greet("Alice"))  # Output: Hello, Alice!
print(mymodule.add(3, 5))       # Output: 8

# Importing specific functions
from mymodule import greet, add

print(greet("Bob"))  # Output: Hello, Bob!
print(add(2, 4))     # Output: 6

# Renaming imports
import mymodule as mm

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

# Using a standard library module
import math

print(math.sqrt(16))  # Output: 4.0

# Using an installed package (e.g., requests)
import requests

response = requests.get("https://www.example.com")
print(response.status_code)  # Output: 200 (if the request is successful)

class ClassName:
    # Class attributes and methods

class Dog:
    # Class attribute (shared by all instances)
    species = "Canis familiaris"

    # Constructor method (initializes object attributes)
    def __init__(self, name, age):
        self.name = name  # Instance attribute
        self.age = age    # Instance attribute

    # Instance method
    def bark(self):
        return f"{self.name} says woof!"

# Create objects of the Dog class
dog1 = Dog("Buddy", 3)
dog2 = Dog("Max", 5)

# Access attributes
print(dog1.name)  # Output: Buddy
print(dog2.age)   # Output: 5

# Call methods
print(dog1.bark())  # Output: Buddy says woof!

print(dog1.species)  # Output: Canis familiaris (class attribute)
print(dog2.species)  # Output: Canis familiaris (class attribute)

dog1.species = "Golden Retriever"  # Modifying instance attribute
print(dog1.species)  # Output: Golden Retriever
print(dog2.species)  # Output: Canis familiaris (unchanged)

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

    def bark(self):
        return f"{self.name} says woof!"

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

# Create an object
dog = Dog("Buddy", 3)

# Call methods
print(dog.bark())      # Output: Buddy says woof!
print(dog.get_age())   # Output: Buddy is 3 years old.

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

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

# Create an object
dog = Dog("Buddy", 3)

# Print the object
print(dog)  # Output: Buddy is 3 years old.

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

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

# Child class
class Dog(Animal):
    def speak(self):
        return f"{self.name} says woof!"

# Create objects
animal = Animal("Generic Animal")
dog = Dog("Buddy")

# Call methods
print(animal.speak())  # Output: Generic Animal makes a sound.
print(dog.speak())     # Output: Buddy says woof!

# Working with Classes & Objects

# Define a class
class Dog:
    # Class attribute
    species = "Canis familiaris"

    # Constructor
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # Instance method
    def bark(self):
        return f"{self.name} says woof!"

    # Special method for string representation
    def __str__(self):
        return f"{self.name} is {self.age} years old."

# Create objects
dog1 = Dog("Buddy", 3)
dog2 = Dog("Max", 5)

# Access attributes
print(dog1.name)  # Output: Buddy
print(dog2.age)   # Output: 5

# Call methods
print(dog1.bark())  # Output: Buddy says woof!
print(dog2.bark())  # Output: Max says woof!

# Print objects
print(dog1)  # Output: Buddy is 3 years old.
print(dog2)  # Output: Max is 5 years old.

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

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

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

# Create objects
animal = Animal("Generic Animal")
dog = Dog("Buddy")

# Call methods
print(animal.speak())  # Output: Generic Animal makes a sound.
print(dog.speak())     # Output: Buddy says woof!

class ClassName:
    def method_name(self, parameters):
        # Code to execute

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

    # Object function
    def bark(self):
        return f"{self.name} says woof!"

    # Another object function
    def get_age(self):
        return f"{self.name} is {self.age} years old."

# Create an object
dog = Dog("Buddy", 3)

# Call object functions
print(dog.bark())      # Output: Buddy says woof!
print(dog.get_age())   # Output: Buddy is 3 years old.

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

    # Object function to update age
    def birthday(self):
        self.age += 1
        return f"{self.name} is now {self.age} years old."

# Create an object
dog = Dog("Buddy", 3)

# Call the birthday function
print(dog.birthday())  # Output: Buddy is now 4 years old.
print(dog.birthday())  # Output: Buddy is now 5 years old.

class Calculator:
    def __init__(self, initial_value=0):
        self.value = initial_value

    # Object function with parameters
    def add(self, number):
        self.value += number
        return self.value

    def subtract(self, number):
        self.value -= number
        return self.value

# Create an object
calc = Calculator(10)

# Call object functions with parameters
print(calc.add(5))      # Output: 15
print(calc.subtract(3)) # Output: 12

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

    # Special method for string representation
    def __str__(self):
        return f"{self.name} is {self.age} years old."

    # Special method for addition
    def __add__(self, other):
        return Dog(f"{self.name} and {other.name}", self.age + other.age)

# Create objects
dog1 = Dog("Buddy", 3)
dog2 = Dog("Max", 5)

# Use special methods
print(dog1)  # Output: Buddy is 3 years old.

combined_dog = dog1 + dog2
print(combined_dog)  # Output: Buddy and Max is 8 years old.

# Working with Object Functions

# Define a class
class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # Object function
    def bark(self):
        return f"{self.name} says woof!"

    # Object function to update age
    def birthday(self):
        self.age += 1
        return f"{self.name} is now {self.age} years old."

    # Special method for string representation
    def __str__(self):
        return f"{self.name} is {self.age} years old."

# Create an object
dog = Dog("Buddy", 3)

# Call object functions
print(dog.bark())      # Output: Buddy says woof!
print(dog.birthday())  # Output: Buddy is now 4 years old.
print(dog.birthday())  # Output: Buddy is now 5 years old.

# Print the object
print(dog)  # Output: Buddy is 5 years old.

# Using object functions with parameters
class Calculator:
    def __init__(self, initial_value=0):
        self.value = initial_value

    def add(self, number):
        self.value += number
        return self.value

    def subtract(self, number):
        self.value -= number
        return self.value

# Create an object
calc = Calculator(10)

# Call object functions with parameters
print(calc.add(5))      # Output: 15
print(calc.subtract(3)) # Output: 12

# Special object functions
class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age

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

    def __add__(self, other):
        return Dog(f"{self.name} and {other.name}", self.age + other.age)

# Create objects
dog1 = Dog("Buddy", 3)
dog2 = Dog("Max", 5)

# Use special methods
print(dog1)  # Output: Buddy is 3 years old.

combined_dog = dog1 + dog2
print(combined_dog)  # Output: Buddy and Max is 8 years old.

class ParentClass:
    # Parent class attributes and methods

class ChildClass(ParentClass):
    # Child class attributes and methods

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

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

# Child class
class Dog(Animal):
    def speak(self):
        return f"{self.name} says woof!"

# Create objects
animal = Animal("Generic Animal")
dog = Dog("Buddy")

# Call methods
print(animal.speak())  # Output: Generic Animal makes a sound.
print(dog.speak())     # Output: Buddy says woof!

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

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

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)  # Call the parent class's __init__ method
        self.breed = breed

    def speak(self):
        return f"{self.name} says woof!"

# Create an object
dog = Dog("Buddy", "Golden Retriever")

# Access attributes and methods
print(dog.name)   # Output: Buddy
print(dog.breed)  # Output: Golden Retriever
print(dog.speak())  # Output: Buddy says woof!

class Animal:
    def speak(self):
        return "Animal sound"

class Dog(Animal):
    def speak(self):
        return "Woof!"

# Create objects
animal = Animal()
dog = Dog()

print(animal.speak())  # Output: Animal sound
print(dog.speak())     # Output: Woof!

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

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

class Dog(Animal):
    def fetch(self):
        return f"{self.name} fetches the ball."

# Create an object
dog = Dog("Buddy")

# Call methods
print(dog.speak())  # Output: Buddy makes a sound.
print(dog.fetch())  # Output: Buddy fetches the ball.

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

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

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

class Puppy(Dog):
    def play(self):
        return f"{self.name} is playing."

# Create an object
puppy = Puppy("Max")

# Call methods
print(puppy.speak())  # Output: Max says woof!
print(puppy.play())   # Output: Max is playing.

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

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

class Pet:
    def play(self):
        return f"{self.name} is playing."

class Dog(Animal, Pet):
    def speak(self):
        return f"{self.name} says woof!"

# Create an object
dog = Dog("Buddy")

# Call methods
print(dog.speak())  # Output: Buddy says woof!
print(dog.play())   # Output: Buddy is playing.

# Working with Inheritance

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

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

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

    def speak(self):
        return f"{self.name} says woof!"

    def fetch(self):
        return f"{self.name} fetches the ball."

# Create objects
animal = Animal("Generic Animal")
dog = Dog("Buddy", "Golden Retriever")

# Call methods
print(animal.speak())  # Output: Generic Animal makes a sound.
print(dog.speak())     # Output: Buddy says woof!
print(dog.fetch())     # Output: Buddy fetches the ball.

# Multi-level inheritance
class Puppy(Dog):
    def play(self):
        return f"{self.name} is playing."

puppy = Puppy("Max", "Labrador")
print(puppy.speak())  # Output: Max says woof!
print(puppy.play())   # Output: Max is playing.

# Multiple inheritance
class Pet:
    def play(self):
        return f"{self.name} is playing."

class Cat(Animal, Pet):
    def speak(self):
        return f"{self.name} says meow!"

cat = Cat("Whiskers")
print(cat.speak())  # Output: Whiskers says meow!
print(cat.play())   # Output: Whiskers is playing.

# Using a lambda function with map()
numbers = [1, 2, 3, 4, 5]
squared_numbers = list(map(lambda x: x ** 2, numbers))

print(squared_numbers)  # Output: [1, 4, 9, 16, 25]

fruits = ["apple", "banana", "cherry"]
numbers = [1, 2, 3, 4, 5]
mixed = [1, "apple", 3.14, True]

   [expression for item in iterable if condition]

   # Create a list of squares
   squares = [x ** 2 for x in range(1, 6)]
   print(squares)  # Output: [1, 4, 9, 16, 25]

   # Filter even numbers
   evens = [x for x in range(10) if x % 2 == 0]
   print(evens)  # Output: [0, 2, 4, 6, 8]

   # Create a 3x3 matrix
   matrix = [[i + j for j in range(3)] for i in range(3)]
   print(matrix)
   # Output: [[0, 1, 2], [1, 2, 3], [2, 3, 4]]

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

   # Extract every second element
   print(numbers[::2])  # Output: [0, 2, 4, 6, 8]

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

   fruits = ["apple", "banana", "cherry"]
   a, b, c = fruits
   print(a, b, c)  # Output: apple banana cherry

   names = ["Alice", "Bob", "Charlie"]
   ages = [25, 30, 35]

   # Zip lists
   zipped = list(zip(names, ages))
   print(zipped)  # Output: [('Alice', 25), ('Bob', 30), ('Charlie', 35)]

   # Unzip lists
   names_unzipped, ages_unzipped = zip(*zipped)
   print(names_unzipped)  # Output: ('Alice', 'Bob', 'Charlie')
   print(ages_unzipped)   # Output: (25, 30, 35)

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

   numbers.sort()
   print(numbers)  # Output: [1, 1, 3, 4, 5, 9]

   numbers.reverse()
   print(numbers)  # Output: [9, 5, 4, 3, 1, 1]

# Working with Lists

# List comprehensions
squares = [x ** 2 for x in range(1, 6)]
print("Squares:", squares)  # Output: [1, 4, 9, 16, 25]

# Nested list comprehensions
matrix = [[i + j for j in range(3)] for i in range(3)]
print("Matrix:", matrix)  # Output: [[0, 1, 2], [1, 2, 3], [2, 3, 4]]

# Slicing with steps
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print("Every second element:", numbers[::2])  # Output: [0, 2, 4, 6, 8]
print("Reversed list:", numbers[::-1])  # Output: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

# List unpacking
fruits = ["apple", "banana", "cherry"]
a, b, c = fruits
print("Unpacked:", a, b, c)  # Output: apple banana cherry

# Zip and unzip lists
names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]
zipped = list(zip(names, ages))
print("Zipped:", zipped)  # Output: [('Alice', 25), ('Bob', 30), ('Charlie', 35)]
names_unzipped, ages_unzipped = zip(*zipped)
print("Unzipped names:", names_unzipped)  # Output: ('Alice', 'Bob', 'Charlie')
print("Unzipped ages:", ages_unzipped)   # Output: (25, 30, 35)

# List methods
numbers = [3, 1, 4, 1, 5, 9]
numbers.sort()
print("Sorted:", numbers)  # Output: [1, 1, 3, 4, 5, 9]
numbers.reverse()
print("Reversed:", numbers)  # Output: [9, 5, 4, 3, 1, 1]

coordinates = (10.0, 20.0)
fruits = ("apple", "banana", "cherry")
mixed = (1, "apple", 3.14, True)

# Single-element tuple
single = (42,)

# Multiple elements
multiple = (1, 2, 3)

fruits = ("apple", "banana", "cherry")

# Access by index
print(fruits[0])  # Output: apple

# Negative indexing
print(fruits[-1])  # Output: cherry

# Slicing
print(fruits[1:3])  # Output: ('banana', 'cherry')

fruits = ("apple", "banana", "cherry")

# This will raise an error
fruits[0] = "orange"  # TypeError: 'tuple' object does not support item assignment

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

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

   fruits = ("apple", "banana", "cherry")
   print("banana" in fruits)  # Output: True

   print(len(fruits))  # Output: 3

coordinates = (10.0, 20.0)
x, y = coordinates
print(x, y)  # Output: 10.0 20.0

location = {
    (40.7128, -74.0060): "New York",
    (34.0522, -118.2437): "Los Angeles"
}

print(location[(40.7128, -74.0060)])  # Output: New York

   numbers = (1, 2, 3, 1, 2, 1)
   print(numbers.count(1))  # Output: 3

   print(numbers.index(2))  # Output: 1

# Working with Tuples

# Creating tuples
coordinates = (10.0, 20.0)
fruits = ("apple", "banana", "cherry")
single = (42,)

# Accessing elements
print("First fruit:", fruits[0])  # Output: apple
print("Last fruit:", fruits[-1])  # Output: cherry
print("Sliced fruits:", fruits[1:3])  # Output: ('banana', 'cherry')

# Tuple operations
tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
combined = tuple1 + tuple2
print("Combined tuple:", combined)  # Output: (1, 2, 3, 4, 5, 6)

repeated = (1, 2) * 3
print("Repeated tuple:", repeated)  # Output: (1, 2, 1, 2, 1, 2)

# Membership
print("Is 'banana' in fruits?", "banana" in fruits)  # Output: True

# Length
print("Number of fruits:", len(fruits))  # Output: 3

# Tuple unpacking
x, y = coordinates
print("Coordinates:", x, y)  # Output: 10.0 20.0

# Using tuples as dictionary keys
location = {
    (40.7128, -74.0060): "New York",
    (34.0522, -118.2437): "Los Angeles"
}
print("Location:", location[(40.7128, -74.0060)])  # Output: New York

# Tuple methods
numbers = (1, 2, 3, 1, 2, 1)
print("Count of 1:", numbers.count(1))  # Output: 3
print("Index of 2:", numbers.index(2))  # Output: 1

# Using curly braces
person = {
    "name": "Alice",
    "age": 25,
    "city": "New York"
}

# Using dict() constructor
person = dict(name="Alice", age=25, city="New York")

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

# Accessing values
print(person["name"])  # Output: Alice
print(person.get("age"))  # Output: 25

# Handling missing keys
print(person.get("country", "Unknown"))  # Output: Unknown

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

# Adding a new key-value pair
person["country"] = "USA"

# Updating an existing key
person["age"] = 26

print(person)
# Output: {'name': 'Alice', 'age': 26, 'city': 'New York', 'country': 'USA'}

   del person["city"]
   print(person)  # Output: {'name': 'Alice', 'age': 26, 'country': 'USA'}

   age = person.pop("age")
   print(age)  # Output: 26
   print(person)  # Output: {'name': 'Alice', 'country': 'USA'}

   last_item = person.popitem()
   print(last_item)  # Output: ('country', 'USA')
   print(person)  # Output: {'name': 'Alice'}

   person.clear()
   print(person)  # Output: {}

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

   print(person.values())  # Output: dict_values(['Alice', 25, 'New York'])

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

   person.update({"country": "USA", "age": 26})
   print(person)  # Output: {'name': 'Alice', 'age': 26, 'city': 'New York', 'country': 'USA'}

   person_copy = person.copy()
   print(person_copy)

{key_expression: value_expression for item in iterable}

# Create a dictionary of squares
squares = {x: x ** 2 for x in range(1, 6)}
print(squares)  # Output: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

students = {
    "Alice": {"age": 25, "grade": "A"},
    "Bob": {"age": 22, "grade": "B"},
    "Charlie": {"age": 23, "grade": "C"}
}

# Accessing nested dictionary values
print(students["Alice"]["age"])  # Output: 25

# Working with Dictionaries

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

# Accessing values
print("Name:", person["name"])  # Output: Alice
print("Age:", person.get("age"))  # Output: 25

# Adding/updating entries
person["country"] = "USA"
person["age"] = 26

# Removing entries
del person["city"]
age = person.pop("age")
last_item = person.popitem()

# Dictionary methods
print("Keys:", person.keys())  # Output: dict_keys(['name'])
print("Values:", person.values())  # Output: dict_values(['Alice'])
print("Items:", person.items())  # Output: dict_items([('name', 'Alice')])

# Dictionary comprehension
squares = {x: x ** 2 for x in range(1, 6)}
print("Squares:", squares)  # Output: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# Nested dictionaries
students = {
    "Alice": {"age": 25, "grade": "A"},
    "Bob": {"age": 22, "grade": "B"},
    "Charlie": {"age": 23, "grade": "C"}
}
print("Alice's age:", students["Alice"]["age"])  # Output: 25

# Using curly braces
fruits = {"apple", "banana", "cherry"}

# Using set() constructor
numbers = set([1, 2, 3, 4, 5])

# Creating a set with curly braces
fruits = {"apple", "banana", "cherry"}

# Creating a set with set() constructor
numbers = set([1, 2, 3, 4, 5])

# Creating an empty set
empty_set = set()  # Note: {} creates an empty dictionary, not a set

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

   # Add a single element
   fruits.add("orange")

   # Add multiple elements
   fruits.update(["mango", "grape"])

   print(fruits)  # Output: {'apple', 'banana', 'cherry', 'orange', 'mango', 'grape'}

     fruits.remove("banana")
     print(fruits)  # Output: {'apple', 'cherry', 'orange', 'mango', 'grape'}

     fruits.discard("banana")  # No error if "banana" is not in the set

     fruits.clear()
     print(fruits)  # Output: set()

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

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

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

   symmetric_difference_set = set1 ^ set2
   print(symmetric_difference_set)  # Output: {1, 2, 4, 5}

   print(len(fruits))  # Output: 5

   print("apple" in fruits)  # Output: True

   set1 = {1, 2}
   set2 = {1, 2, 3, 4}
   print(set1.issubset(set2))  # Output: True

   print(set2.issuperset(set1))  # Output: True

   set3 = {5, 6}
   print(set1.isdisjoint(set3))  # Output: True

{expression for item in iterable if condition}

# Create a set of squares
squares = {x ** 2 for x in range(1, 6)}
print(squares)  # Output: {1, 4, 9, 16, 25}

# Working with Sets

# Creating sets
fruits = {"apple", "banana", "cherry"}
numbers = set([1, 2, 3, 4, 5])

# Adding elements
fruits.add("orange")
fruits.update(["mango", "grape"])

# Removing elements
fruits.remove("banana")
fruits.discard("banana")  # No error if "banana" is not in the set
removed_fruit = fruits.pop()
fruits.clear()

# Set operations
set1 = {1, 2, 3}
set2 = {3, 4, 5}
union_set = set1 | set2
intersection_set = set1 & set2
difference_set = set1 - set2
symmetric_difference_set = set1 ^ set2

# Set methods
print(len(fruits))  # Output: 0
print("apple" in fruits)  # Output: False
print(set1.issubset(set2))  # Output: False
print(set2.issuperset(set1))  # Output: False
print(set1.isdisjoint(set2))  # Output: False

# Set comprehension
squares = {x ** 2 for x in range(1, 6)}
print("Squares:", squares)  # Output: {1, 4, 9, 16, 25}

# Using single quotes
message1 = 'Hello, World!'

# Using double quotes
message2 = "Python is fun!"

# Using triple quotes for multi-line strings
message3 = """This is a
multi-line string."""

text = "Python"

# Accessing characters
print(text[0])  # Output: P
print(text[3])  # Output: h

# Negative indexing (starts from the end)
print(text[-1])  # Output: n

text = "Python Programming"

# Extract "Python"
print(text[0:6])  # Output: Python

# Extract "Programming"
print(text[7:18])  # Output: Programming

# Extract every second character
print(text[::2])  # Output: Pto rgamn

   print("hello".upper())  # Output: HELLO

   print("HELLO".lower())  # Output: hello

   print("  hello  ".strip())  # Output: hello

   print("hello world".replace("world", "Python"))  # Output: hello Python

   print("apple,banana,cherry".split(","))  # Output: ['apple', 'banana', 'cherry']

   print(", ".join(["apple", "banana", "cherry"]))  # Output: apple, banana, cherry

   print("hello world".find("world"))  # Output: 6

   print("hello world".count("l"))  # Output: 3

   print("hello world".startswith("hello"))  # Output: True

    print("hello world".endswith("world"))  # Output: True

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

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

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

print("Hello\nWorld")  # Output: Hello
                      #         World

print(r"C:\Users\Alice\Documents")  # Output: C:\Users\Alice\Documents

text = "Python is fun"
print("fun" in text)  # Output: True

# Working with Strings

# Creating strings
message1 = 'Hello, World!'
message2 = "Python is fun!"
message3 = """This is a
multi-line string."""

# Accessing characters
text = "Python"
print("First character:", text[0])  # Output: P
print("Last character:", text[-1])  # Output: n

# String slicing
print("Sliced string:", text[0:4])  # Output: Pyth
print("Every second character:", text[::2])  # Output: Pto

# String methods
print("Uppercase:", "hello".upper())  # Output: HELLO
print("Lowercase:", "HELLO".lower())  # Output: hello
print("Stripped:", "  hello  ".strip())  # Output: hello
print("Replaced:", "hello world".replace("world", "Python"))  # Output: hello Python
print("Split:", "apple,banana,cherry".split(","))  # Output: ['apple', 'banana', 'cherry']
print("Joined:", ", ".join(["apple", "banana", "cherry"]))  # Output: apple, banana, cherry
print("Found at index:", "hello world".find("world"))  # Output: 6
print("Count of 'l':", "hello world".count("l"))  # Output: 3
print("Starts with 'hello':", "hello world".startswith("hello"))  # Output: True
print("Ends with 'world':", "hello world".endswith("world"))  # Output: True

# String formatting
name = "Alice"
age = 25
print(f"My name is {name} and I am {age} years old.")  # Output: My name is Alice and I am 25 years old.
print("My name is {} and I am {} years old.".format(name, age))  # Output: My name is Alice and I am 25 years old.
print("My name is %s and I am %d years old." % (name, age))  # Output: My name is Alice and I am 25 years old.

# Escape characters
print("Hello\nWorld")  # Output: Hello
                      #         World

# Raw strings
print(r"C:\Users\Alice\Documents")  # Output: C:\Users\Alice\Documents

# String membership
print("Is 'fun' in the text?", "fun" in "Python is fun")  # Output: True

from collections import namedtuple
NamedTuple = namedtuple("NamedTuple", ["field1", "field2", ...])

from collections import namedtuple

# Define a namedtuple
Point = namedtuple("Point", ["x", "y"])

# Create an instance
p = Point(10, 20)

# Access fields by name
print(p.x, p.y)  # Output: 10 20

from collections import deque
d = deque([iterable])

from collections import deque

# Create a deque
d = deque([1, 2, 3])

# Append to the right
d.append(4)  # deque([1, 2, 3, 4])

# Append to the left
d.appendleft(0)  # deque([0, 1, 2, 3, 4])

# Pop from the right
d.pop()  # Returns 4, deque([0, 1, 2, 3])

# Pop from the left
d.popleft()  # Returns 0, deque([1, 2, 3])

from collections import Counter
c = Counter([iterable])

from collections import Counter

# Count occurrences of elements
c = Counter(["apple", "banana", "apple", "cherry", "banana", "apple"])

print(c)  # Output: Counter({'apple': 3, 'banana': 2, 'cherry': 1})

# Most common elements
print(c.most_common(2))  # Output: [('apple', 3), ('banana', 2)]

from collections import defaultdict
d = defaultdict(default_factory)

from collections import defaultdict

# Default value for missing keys is an empty list
d = defaultdict(list)

# Add elements
d["fruits"].append("apple")
d["fruits"].append("banana")

print(d)  # Output: defaultdict(<class 'list'>, {'fruits': ['apple', 'banana']})

from collections import OrderedDict
od = OrderedDict([items])

from collections import OrderedDict

# Create an OrderedDict
od = OrderedDict()
od["a"] = 1
od["b"] = 2
od["c"] = 3

print(od)  # Output: OrderedDict([('a', 1), ('b', 2), ('c', 3)])

from collections import ChainMap
cm = ChainMap(dict1, dict2, ...)

from collections import ChainMap

# Create dictionaries
dict1 = {"a": 1, "b": 2}
dict2 = {"b": 3, "c": 4}

# Combine dictionaries
cm = ChainMap(dict1, dict2)

# Access values
print(cm["a"])  # Output: 1 (from dict1)
print(cm["b"])  # Output: 2 (from dict1, first match)
print(cm["c"])  # Output: 4 (from dict2)

# Working with Collections

# namedtuple
from collections import namedtuple
Point = namedtuple("Point", ["x", "y"])
p = Point(10, 20)
print("Point:", p.x, p.y)  # Output: 10 20

# deque
from collections import deque
d = deque([1, 2, 3])
d.append(4)
d.appendleft(0)
print("Deque:", d)  # Output: deque([0, 1, 2, 3, 4])

# Counter
from collections import Counter
c = Counter(["apple", "banana", "apple", "cherry", "banana", "apple"])
print("Counter:", c)  # Output: Counter({'apple': 3, 'banana': 2, 'cherry': 1})
print("Most common:", c.most_common(2))  # Output: [('apple', 3), ('banana', 2)]

# defaultdict
from collections import defaultdict
d = defaultdict(list)
d["fruits"].append("apple")
d["fruits"].append("banana")
print("DefaultDict:", d)  # Output: defaultdict(<class 'list'>, {'fruits': ['apple', 'banana']})

# OrderedDict
from collections import OrderedDict
od = OrderedDict()
od["a"] = 1
od["b"] = 2
od["c"] = 3
print("OrderedDict:", od)  # Output: OrderedDict([('a', 1), ('b', 2), ('c', 3)])

# ChainMap
from collections import ChainMap
dict1 = {"a": 1, "b": 2}
dict2 = {"b": 3, "c": 4}
cm = ChainMap(dict1, dict2)
print("ChainMap:", cm["a"], cm["b"], cm["c"])  # Output: 1 2 4

     import itertools

     for i in itertools.count(start=1, step=2):
         if i > 10:
             break
         print(i, end=" ")  # Output: 1 3 5 7 9

     for item in itertools.cycle(["A", "B", "C"]):
         if item == "C":
             break
         print(item, end=" ")  # Output: A B

     for item in itertools.repeat("Python", 3):
         print(item, end=" ")  # Output: Python Python Python

     for item in itertools.product("AB", repeat=2):
         print(item, end=" ")  # Output: ('A', 'A') ('A', 'B') ('B', 'A') ('B', 'B')

     for item in itertools.permutations("ABC", 2):
         print(item, end=" ")  # Output: ('A', 'B') ('A', 'C') ('B', 'A') ('B', 'C') ('C', 'A') ('C', 'B')

     for item in itertools.combinations("ABC", 2):
         print(item, end=" ")  # Output: ('A', 'B') ('A', 'C') ('B', 'C')

     for item in itertools.combinations_with_replacement("ABC", 2):
         print(item, end=" ")  # Output: ('A', 'A') ('A', 'B') ('A', 'C') ('B', 'B') ('B', 'C') ('C', 'C')

     for item in itertools.accumulate([1, 2, 3, 4]):
         print(item, end=" ")  # Output: 1 3 6 10

     for item in itertools.chain("ABC", "DEF"):
         print(item, end=" ")  # Output: A B C D E F

     for item in itertools.compress("ABCDEF", [1, 0, 1, 0, 1, 0]):
         print(item, end=" ")  # Output: A C E

     for item in itertools.dropwhile(lambda x: x < 5, [1, 4, 6, 4, 1]):
         print(item, end=" ")  # Output: 6 4 1

     for item in itertools.takewhile(lambda x: x < 5, [1, 4, 6, 4, 1]):
         print(item, end=" ")  # Output: 1 4

     data = [("A", 1), ("A", 2), ("B", 3), ("B", 4)]
     for key, group in itertools.groupby(data, lambda x: x[0]):
         print(key, list(group))
     # Output:
     # A [('A', 1), ('A', 2)]
     # B [('B', 3), ('B', 4)]

# Working with Itertools

# Infinite iterators
import itertools

print("Count:")
for i in itertools.count(start=1, step=2):
    if i > 10:
        break
    print(i, end=" ")  # Output: 1 3 5 7 9

print("\nCycle:")
for item in itertools.cycle(["A", "B", "C"]):
    if item == "C":
        break
    print(item, end=" ")  # Output: A B

print("\nRepeat:")
for item in itertools.repeat("Python", 3):
    print(item, end=" ")  # Output: Python Python Python

# Combinatoric iterators
print("\nProduct:")
for item in itertools.product("AB", repeat=2):
    print(item, end=" ")  # Output: ('A', 'A') ('A', 'B') ('B', 'A') ('B', 'B')

print("\nPermutations:")
for item in itertools.permutations("ABC", 2):
    print(item, end=" ")  # Output: ('A', 'B') ('A', 'C') ('B', 'A') ('B', 'C') ('C', 'A') ('C', 'B')

print("\nCombinations:")
for item in itertools.combinations("ABC", 2):
    print(item, end=" ")  # Output: ('A', 'B') ('A', 'C') ('B', 'C')

print("\nCombinations with Replacement:")
for item in itertools.combinations_with_replacement("ABC", 2):
    print(item, end=" ")  # Output: ('A', 'A') ('A', 'B') ('A', 'C') ('B', 'B') ('B', 'C') ('C', 'C')

# Terminating iterators
print("\nAccumulate:")
for item in itertools.accumulate([1, 2, 3, 4]):
    print(item, end=" ")  # Output: 1 3 6 10

print("\nChain:")
for item in itertools.chain("ABC", "DEF"):
    print(item, end=" ")  # Output: A B C D E F

print("\nCompress:")
for item in itertools.compress("ABCDEF", [1, 0, 1, 0, 1, 0]):
    print(item, end=" ")  # Output: A C E

print("\nDropwhile:")
for item in itertools.dropwhile(lambda x: x < 5, [1, 4, 6, 4, 1]):
    print(item, end=" ")  # Output: 6 4 1

print("\nTakewhile:")
for item in itertools.takewhile(lambda x: x < 5, [1, 4, 6, 4, 1]):
    print(item, end=" ")  # Output: 1 4

print("\nGroupby:")
data = [("A", 1), ("A", 2), ("B", 3), ("B", 4)]
for key, group in itertools.groupby(data, lambda x: x[0]):
    print(key, list(group))
# Output:
# A [('A', 1), ('A', 2)]
# B [('B', 3), ('B', 4)]

lambda arguments: expression

add = lambda x, y: x + y
print(add(3, 5))  # Output: 8

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

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

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

# Sort by age
sorted_students = sorted(students, key=lambda x: x["age"])
print(sorted_students)
# Output: [{'name': 'Bob', 'age': 22}, {'name': 'Charlie', 'age': 23}, {'name': 'Alice', 'age': 25}]

numbers = [1, 2, 3, 4, 5]
squared = [(lambda x: x ** 2)(x) for x in numbers]
print(squared)  # Output: [1, 4, 9, 16, 25]

# Working with Lambda Functions

# Basic lambda function
add = lambda x, y: x + y
print("Add:", add(3, 5))  # Output: 8

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

# Using lambda with filter()
evens = list(filter(lambda x: x % 2 == 0, numbers))
print("Evens:", evens)  # Output: [2, 4]

# Using lambda with sorted()
students = [
    {"name": "Alice", "age": 25},
    {"name": "Bob", "age": 22},
    {"name": "Charlie", "age": 23}
]
sorted_students = sorted(students, key=lambda x: x["age"])
print("Sorted Students:", sorted_students)
# Output: [{'name': 'Bob', 'age': 22}, {'name': 'Charlie', 'age': 23}, {'name': 'Alice', 'age': 25}]

# Using lambda in list comprehensions
squared = [(lambda x: x ** 2)(x) for x in numbers]
print("Squared (List Comprehension):", squared)  # Output: [1, 4, 9, 16, 25]

   print("Hello, World"  # Missing closing parenthesis

try:
    # Code that might raise an exception
except ExceptionType:
    # Code to handle the exception

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

try:
    num = int(input("Enter a number: "))
    result = 10 / num
except ValueError:
    print("Error: Invalid input. Please enter a number.")
except ZeroDivisionError:
    print("Error: Division by zero.")

try:
    num = int(input("Enter a number: "))
    result = 10 / num
except ValueError:
    print("Error: Invalid input. Please enter a number.")
except ZeroDivisionError:
    print("Error: Division by zero.")
else:
    print("Result:", result)

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

def divide(a, b):
    if b == 0:
        raise ValueError("Cannot divide by zero.")
    return a / b

try:
    result = divide(10, 0)
except ValueError as e:
    print(e)  # Output: Cannot divide by zero.

class NegativeNumberError(Exception):
    pass

def check_positive(number):
    if number < 0:
        raise NegativeNumberError("Negative numbers are not allowed.")

try:
    check_positive(-5)
except NegativeNumberError as e:
    print(e)  # Output: Negative numbers are not allowed.

# Working with Exceptions and Errors

# Handling exceptions
try:
    num = int(input("Enter a number: "))
    result = 10 / num
except ValueError:
    print("Error: Invalid input. Please enter a number.")
except ZeroDivisionError:
    print("Error: Division by zero.")
else:
    print("Result:", result)
finally:
    print("Execution complete.")

# Raising exceptions
def divide(a, b):
    if b == 0:
        raise ValueError("Cannot divide by zero.")
    return a / b

try:
    result = divide(10, 0)
except ValueError as e:
    print(e)  # Output: Cannot divide by zero.

# Custom exceptions
class NegativeNumberError(Exception):
    pass

def check_positive(number):
    if number < 0:
        raise NegativeNumberError("Negative numbers are not allowed.")

try:
    check_positive(-5)
except NegativeNumberError as e:
    print(e)  # Output: Negative numbers are not allowed.

import logging

# Basic logging
logging.warning("This is a warning message.")
logging.error("This is an error message.")
logging.critical("This is a critical message.")

import logging

# Configure logging
logging.basicConfig(
    level=logging.DEBUG,  # Set the logging level
    format="%(asctime)s - %(levelname)s - %(message)s",  # Set the log format
    filename="app.log",  # Log to a file
    filemode="w"  # Overwrite the log file each time
)

# Log messages
logging.debug("This is a debug message.")
logging.info("This is an info message.")
logging.warning("This is a warning message.")
logging.error("This is an error message.")
logging.critical("This is a critical message.")

import logging

# Create a logger
logger = logging.getLogger("my_logger")
logger.setLevel(logging.DEBUG)

# Create a console handler
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.WARNING)

# Create a file handler
file_handler = logging.FileHandler("app.log")
file_handler.setLevel(logging.DEBUG)

# Create a formatter
formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")

# Add the formatter to the handlers
console_handler.setFormatter(formatter)
file_handler.setFormatter(formatter)

# Add the handlers to the logger
logger.addHandler(console_handler)
logger.addHandler(file_handler)

# Log messages
logger.debug("This is a debug message.")
logger.info("This is an info message.")
logger.warning("This is a warning message.")
logger.error("This is an error message.")
logger.critical("This is a critical message.")

with open('app.log', 'r') as file:
    content = file.read()
    print(content)

import logging

# Configure logging
logging.basicConfig(level=logging.DEBUG, format="%(asctime)s - %(levelname)s - %(message)s")

try:
    result = 10 / 0
except ZeroDivisionError:
    logging.exception("An error occurred:")

# Working with Logging

import logging

# Configure logging
logging.basicConfig(
    level=logging.DEBUG,
    format="%(asctime)s - %(levelname)s - %(message)s",
    filename="app.log",
    filemode="w"
)

# Log messages
logging.debug("This is a debug message.")
logging.info("This is an info message.")
logging.warning("This is a warning message.")
logging.error("This is an error message.")
logging.critical("This is a critical message.")

# Logging exceptions
try:
    result = 10 / 0
except ZeroDivisionError:
    logging.exception("An error occurred:")

{
    "name": "Alice",
    "age": 25,
    "is_student": false,
    "courses": ["Math", "Science"],
    "address": {
        "city": "New York",
        "zip": "10001"
    }
}

import json

# Python dictionary
data = {
    "name": "Alice",
    "age": 25,
    "is_student": False,
    "courses": ["Math", "Science"],
    "address": {
        "city": "New York",
        "zip": "10001"
    }
}

# Convert to JSON string
json_string = json.dumps(data, indent=4)  # indent for pretty printing
print(json_string)

import json

# JSON string
json_string = '''
{
    "name": "Alice",
    "age": 25,
    "is_student": false,
    "courses": ["Math", "Science"],
    "address": {
        "city": "New York",
        "zip": "10001"
    }
}
'''

# Convert to Python dictionary
data = json.loads(json_string)
print(data)

   import json

   # Read JSON data from a file
   with open("data.json", "r") as file:
       data = json.load(file)
       print(data)

   import json

   # Python dictionary
   data = {
       "name": "Attila",
       "age": 23,
       "is_student": False,
       "courses": ["Math", "Statics"],
       "address": {
           "city": "Urmia",
           "zip": "50708"
       }
   }

   # Write JSON data to a file
   with open("data.json", "w") as file:
       json.dump(data, file, indent=4)

import json
from datetime import datetime

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

# Custom encoder function
def person_encoder(obj):
    if isinstance(obj, Person):
        return {"name": obj.name, "age": obj.age}
    raise TypeError(f"Object of type {type(obj)} is not JSON serializable")

# Create a Person object
person = Person("Alice", 25)

# Convert to JSON string
json_string = json.dumps(person, default=person_encoder, indent=4)
print(json_string)

# Working with JSON

import json

# Python dictionary
data = {
    "name": "Alice",
    "age": 25,
    "is_student": False,
    "courses": ["Math", "Science"],
    "address": {
        "city": "New York",
        "zip": "10001"
    }
}

# Convert to JSON string
json_string = json.dumps(data, indent=4)
print("JSON String:")
print(json_string)

# Convert JSON string to Python dictionary
data_parsed = json.loads(json_string)
print("\nParsed Data:")
print(data_parsed)

# Write JSON data to a file
with open("data.json", "w") as file:
    json.dump(data, file, indent=4)

# Read JSON data from a file
with open("data.json", "r") as file:
    data_from_file = json.load(file)
    print("\nData from File:")
    print(data_from_file)

# Handling custom objects
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

def person_encoder(obj):
    if isinstance(obj, Person):
        return {"name": obj.name, "age": obj.age}
    raise TypeError(f"Object of type {type(obj)} is not JSON serializable")

person = Person("Alice", 25)
json_string_custom = json.dumps(person, default=person_encoder, indent=4)
print("\nCustom Object JSON String:")
print(json_string_custom)

import random

   print(random.random())  # Output: e.g., 0.3745401188473625

   print(random.uniform(1.5, 4.5))  # Output: e.g., 2.345678901234567

   print(random.randint(1, 10))  # Output: e.g., 7

   print(random.randrange(0, 100, 5))  # Output: e.g., 45

   fruits = ["apple", "banana", "cherry"]
   print(random.choice(fruits))  # Output: e.g., "banana"

   print(random.choices(fruits, k=2))  # Output: e.g., ["cherry", "apple"]

   print(random.sample(fruits, 2))  # Output: e.g., ["banana", "cherry"]

   numbers = [1, 2, 3, 4, 5]
   random.shuffle(numbers)
   print(numbers)  # Output: e.g., [3, 1, 5, 2, 4]

   shuffled = random.sample(numbers, k=len(numbers))
   print(shuffled)  # Output: e.g., [4, 2, 5, 1, 3]

random.seed(42)  # Set the seed
print(random.random())  # Output: 0.6394267984578837
print(random.random())  # Output: 0.025010755222666936

random.seed(42)  # Reset the seed
print(random.random())  # Output: 0.6394267984578837 (same as before)

# Working with Random Numbers

import random

# Generating random numbers
print("Random float between 0.0 and 1.0:", random.random())
print("Random float between 1.5 and 4.5:", random.uniform(1.5, 4.5))
print("Random integer between 1 and 10:", random.randint(1, 10))
print("Random integer from range 0 to 100 (step 5):", random.randrange(0, 100, 5))

# Selecting random elements
fruits = ["apple", "banana", "cherry"]
print("Random choice from fruits:", random.choice(fruits))
print("Random choices (with replacement):", random.choices(fruits, k=2))
print("Random sample (without replacement):", random.sample(fruits, 2))

# Shuffling sequences
numbers = [1, 2, 3, 4, 5]
random.shuffle(numbers)
print("Shuffled numbers:", numbers)

# Seeding random numbers
random.seed(42)
print("Random number with seed 42:", random.random())
random.seed(42)
print("Random number with seed 42 (again):", random.random())

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

@my_decorator
def say_hello():
    print("Hello!")

say_hello()

def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("Something is happening before the function is called.")
        result = func(*args, **kwargs)
        print("Something is happening after the function is called.")
        return result
    return wrapper

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

greet("Alice")

def decorator1(func):
    def wrapper():
        print("Decorator 1")
        func()
    return wrapper

def decorator2(func):
    def wrapper():
        print("Decorator 2")
        func()
    return wrapper

@decorator1
@decorator2
def say_hello():
    print("Hello!")

say_hello()

def repeat(num_times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(num_times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

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

greet("Alice")

class MyClass:
    @staticmethod
    def static_method():
        print("This is a static method.")

    @classmethod
    def class_method(cls):
        print(f"This is a class method of {cls.__name__}.")

    @property
    def my_property(self):
        return "This is a property."

# Usage
MyClass.static_method()  # Output: This is a static method.
MyClass.class_method()   # Output: This is a class method of MyClass.

obj = MyClass()
print(obj.my_property)   # Output: This is a property.

# Working with Decorators

# Basic decorator
def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")
    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

say_hello()

# Decorator with arguments
def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("Something is happening before the function is called.")
        result = func(*args, **kwargs)
        print("Something is happening after the function is called.")
        return result
    return wrapper

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

greet("Alice")

# Chaining decorators
def decorator1(func):
    def wrapper():
        print("Decorator 1")
        func()
    return wrapper

def decorator2(func):
    def wrapper():
        print("Decorator 2")
        func()
    return wrapper

@decorator1
@decorator2
def say_hello():
    print("Hello!")

say_hello()

# Decorator with arguments
def repeat(num_times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(num_times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

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

greet("Alice")

# Built-in decorators
class MyClass:
    @staticmethod
    def static_method():
        print("This is a static method.")

    @classmethod
    def class_method(cls):
        print(f"This is a class method of {cls.__name__}.")

    @property
    def my_property(self):
        return "This is a property."

# Usage
MyClass.static_method()  # Output: This is a static method.
MyClass.class_method()   # Output: This is a class method of MyClass.

obj = MyClass()
print(obj.my_property)   # Output: This is a property.

def simple_generator():
    yield 1
    yield 2
    yield 3

# Create a generator object
gen = simple_generator()

# Iterate over the generator
for value in gen:
    print(value)

   def count_up_to(n):
       count = 1
       while count <= n:
           yield count
           count += 1

   # Create a generator object
   gen = count_up_to(5)

   # Iterate over the generator
   for value in gen:
       print(value)

   gen = (x ** 2 for x in range(5))

   # Iterate over the generator
   for value in gen:
       print(value)

def infinite_sequence():
    num = 0
    while True:
        yield num
        num += 1

# Create a generator object
gen = infinite_sequence()

# Print the first 5 values
for _ in range(5):
    print(next(gen))

def generator_with_send():
    value = yield
    yield f"Received: {value}"

# Create a generator object
gen = generator_with_send()

# Start the generator
next(gen)

# Send a value to the generator
result = gen.send("Hello")
print(result)

# Working with Generators

# Simple generator
def simple_generator():
    yield 1
    yield 2
    yield 3

gen = simple_generator()
print("Simple Generator:")
for value in gen:
    print(value)

# Generator with yield
def count_up_to(n):
    count = 1
    while count <= n:
        yield count
        count += 1

gen = count_up_to(5)
print("\nCount Up To 5:")
for value in gen:
    print(value)

# Generator expression
gen = (x ** 2 for x in range(5))
print("\nGenerator Expression:")
for value in gen:
    print(value)

# Infinite generator
def infinite_sequence():
    num = 0
    while True:
        yield num
        num += 1

gen = infinite_sequence()
print("\nInfinite Generator (First 5 Values):")
for _ in range(5):
    print(next(gen))

# Sending values to a generator
def generator_with_send():
    value = yield
    yield f"Received: {value}"

gen = generator_with_send()
next(gen)
result = gen.send("Hello")
print("\nGenerator with Send:")
print(result)

import threading
import time

def print_numbers():
    for i in range(5):
        print(f"Thread 1: {i}")
        time.sleep(1)

def print_letters():
    for letter in "ABCDE":
        print(f"Thread 2: {letter}")
        time.sleep(1)

# Create threads
thread1 = threading.Thread(target=print_numbers)
thread2 = threading.Thread(target=print_letters)

# Start threads
thread1.start()
thread2.start()

# Wait for threads to finish
thread1.join()
thread2.join()

print("Done!")

import multiprocessing
import time

def print_numbers():
    for i in range(5):
        print(f"Process 1: {i}")
        time.sleep(1)

def print_letters():
    for letter in "ABCDE":
        print(f"Process 2: {letter}")
        time.sleep(1)

# Create processes
process1 = multiprocessing.Process(target=print_numbers)
process2 = multiprocessing.Process(target=print_letters)

# Start processes
process1.start()
process2.start()

# Wait for processes to finish
process1.join()
process2.join()

print("Done!")

# Working with Threading and Multiprocessing

import threading
import multiprocessing
import time

# Threading example
def print_numbers():
    for i in range(5):
        print(f"Thread 1: {i}")
        time.sleep(1)

def print_letters():
    for letter in "ABCDE":
        print(f"Thread 2: {letter}")
        time.sleep(1)

print("Threading Example:")
thread1 = threading.Thread(target=print_numbers)
thread2 = threading.Thread(target=print_letters)

thread1.start()
thread2.start()

thread1.join()
thread2.join()
print("Threading Done!\n")

# Multiprocessing example
def print_numbers():
    for i in range(5):
        print(f"Process 1: {i}")
        time.sleep(1)

def print_letters():
    for letter in "ABCDE":
        print(f"Process 2: {letter}")
        time.sleep(1)

print("Multiprocessing Example:")
process1 = multiprocessing.Process(target=print_numbers)
process2 = multiprocessing.Process(target=print_letters)

process1.start()
process2.start()

process1.join()
process2.join()
print("Multiprocessing Done!")

import threading
import time

def print_numbers():
    for i in range(5):
        print(f"Thread 1: {i}")
        time.sleep(1)

def print_letters():
    for letter in "ABCDE":
        print(f"Thread 2: {letter}")
        time.sleep(1)

# Create threads
thread1 = threading.Thread(target=print_numbers)
thread2 = threading.Thread(target=print_letters)

# Start threads
thread1.start()
thread2.start()

# Wait for threads to finish
thread1.join()
thread2.join()

print("Done!")

import threading

# Shared resource
counter = 0
lock = threading.Lock()

def increment():
    global counter
    for _ in range(100000):
        with lock:
            counter += 1

# Create threads
thread1 = threading.Thread(target=increment)
thread2 = threading.Thread(target=increment)

# Start threads
thread1.start()
thread2.start()

# Wait for threads to finish
thread1.join()
thread2.join()

print("Counter:", counter)  # Output: Counter: 200000

import threading
import time

def daemon_task():
    while True:
        print("Daemon thread is running...")
        time.sleep(1)

# Create a daemon thread
daemon_thread = threading.Thread(target=daemon_task, daemon=True)

# Start the daemon thread
daemon_thread.start()

# Main program
print("Main program is running...")
time.sleep(3)
print("Main program is done.")

from concurrent.futures import ThreadPoolExecutor
import time

def task(name):
    print(f"Task {name} started")
    time.sleep(2)
    print(f"Task {name} finished")

# Create a thread pool with 3 threads
with ThreadPoolExecutor(max_workers=3) as executor:
    # Submit tasks to the thread pool
    futures = [executor.submit(task, i) for i in range(5)]

print("All tasks completed.")

# Working with Multithreading

import threading
import time
from concurrent.futures import ThreadPoolExecutor

# Basic threading example
def print_numbers():
    for i in range(5):
        print(f"Thread 1: {i}")
        time.sleep(1)

def print_letters():
    for letter in "ABCDE":
        print(f"Thread 2: {letter}")
        time.sleep(1)

print("Basic Threading Example:")
thread1 = threading.Thread(target=print_numbers)
thread2 = threading.Thread(target=print_letters)

thread1.start()
thread2.start()

thread1.join()
thread2.join()
print("Basic Threading Done!\n")

# Thread synchronization example
counter = 0
lock = threading.Lock()

def increment():
    global counter
    for _ in range(100000):
        with lock:
            counter += 1

print("Thread Synchronization Example:")
thread1 = threading.Thread(target=increment)
thread2 = threading.Thread(target=increment)

thread1.start()
thread2.start()

thread1.join()
thread2.join()
print("Counter:", counter)
print("Thread Synchronization Done!\n")

# Daemon thread example
def daemon_task():
    while True:
        print("Daemon thread is running...")
        time.sleep(1)

print("Daemon Thread Example:")
daemon_thread = threading.Thread(target=daemon_task, daemon=True)
daemon_thread.start()

print("Main program is running...")
time.sleep(3)
print("Main program is done.\n")

# Thread pool example
def task(name):
    print(f"Task {name} started")
    time.sleep(2)
    print(f"Task {name} finished")

print("Thread Pool Example:")
with ThreadPoolExecutor(max_workers=3) as executor:
    futures = [executor.submit(task, i) for i in range(5)]

print("All tasks completed.")

import multiprocessing
import time

def worker_function(name):
    print(f"Process {name} started")
    time.sleep(2)  # Simulate some work
    print(f"Process {name} finished")

if __name__ == "__main__":
    # Create two processes
    process1 = multiprocessing.Process(target=worker_function, args=("Process 1",))
    process2 = multiprocessing.Process(target=worker_function, args=("Process 2",))

    # Start the processes
    process1.start()
    process2.start()

    # Wait for the processes to finish
    process1.join()
    process2.join()

    print("All processes finished")

     import multiprocessing

     def worker(q):
         q.put("Hello from the worker process!")

     if __name__ == "__main__":
         q = multiprocessing.Queue()
         p = multiprocessing.Process(target=worker, args=(q,))
         p.start()
         print(q.get())  # Output: Hello from the worker process!
         p.join()

     import multiprocessing

     def square(x):
         return x * x

     if __name__ == "__main__":
         with multiprocessing.Pool(processes=4) as pool:
             results = pool.map(square, range(10))
         print(results)  # Output: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

     import multiprocessing

     def worker(conn):
         conn.send("Message from worker")
         conn.close()

     if __name__ == "__main__":
         parent_conn, child_conn = multiprocessing.Pipe()
         p = multiprocessing.Process(target=worker, args=(child_conn,))
         p.start()
         print(parent_conn.recv())  # Output: Message from worker
         p.join()

     import multiprocessing

     def worker(val):
         val.value += 1

     if __name__ == "__main__":
         shared_value = multiprocessing.Value("i", 0)  # 'i' for integer
         p = multiprocessing.Process(target=worker, args=(shared_value,))
         p.start()
         p.join()
         print(shared_value.value)  # Output: 1

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

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

greet(message="Hi", name="Bob")  # Output: Hi, Bob!

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

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

def add(*args):
    return sum(args)

print(add(1, 2, 3))  # Output: 6
print(add(4, 5, 6, 7))  # Output: 22

def display_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

display_info(name="Alice", age=30, city="New York")
# Output:
# name: Alice
# age: 30
# city: New York

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

greet(name="Alice", message="Hi")  # Output: Hi, Alice!
# greet("Alice", "Hi")  # This would raise a TypeError

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

greet("Alice", message="Hi")  # Output: Hi, Alice!
# greet(name="Alice", message="Hi")  # This would raise a TypeError

def example(a, b, /, c, d=4, *args, e, f=6, **kwargs):
    print(f"a: {a}, b: {b}, c: {c}, d: {d}, args: {args}, e: {e}, f: {f}, kwargs: {kwargs}")

example(1, 2, 3, e=5, extra="hello")
# Output:
# a: 1, b: 2, c: 3, d: 4, args: (), e: 5, f: 6, kwargs: {'extra': 'hello'}

# Multiplication
result = 5 * 3
print(result)  # Output: 15

# Exponentiation
result = 2 ** 3
print(result)  # Output: 8

numbers = [1, 2, 3]
print(*numbers)  # Output: 1 2 3

print(1, 2, 3)

first, *middle, last = [1, 2, 3, 4, 5]
print(first)   # Output: 1
print(middle)  # Output: [2, 3, 4]
print(last)    # Output: 5

def sum_numbers(*args):
    return sum(args)

print(sum_numbers(1, 2, 3))  # Output: 6
print(sum_numbers(4, 5, 6, 7))  # Output: 22

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

data = ["Alice", "Hello"]
greet(*data)  # Output: Hello, Alice!

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

data = {"name": "Bob", "message": "Hi"}
greet(**data)  # Output: Hi, Bob!

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

greet(name="Alice", message="Hi")  # Output: Hi, Alice!
# greet("Alice", "Hi")  # This would raise a TypeError

def func(a, b, c):
    print(f"a: {a}, b: {b}, c: {c}")

args = [1, 2]
kwargs = {"c": 3}
func(*args, **kwargs)  # Output: a: 1, b: 2, c: 3

import copy

original = [[1, 2, 3], [4, 5, 6]]
shallow_copy = copy.copy(original)

# Modify the nested list in the shallow copy
shallow_copy[0][0] = 99

print(original)     # Output: [[99, 2, 3], [4, 5, 6]]
print(shallow_copy) # Output: [[99, 2, 3], [4, 5, 6]]

import copy

original = [[1, 2, 3], [4, 5, 6]]
deep_copy = copy.deepcopy(original)

# Modify the nested list in the deep copy
deep_copy[0][0] = 99

print(original)  # Output: [[1, 2, 3], [4, 5, 6]]
print(deep_copy) # Output: [[99, 2, 3], [4, 5, 6]]

import copy

original = [[1, 2], [3, 4]]
shallow_copy = copy.copy(original)

shallow_copy[0][0] = 99
print(original)     # Output: [[99, 2], [3, 4]]
print(shallow_copy) # Output: [[99, 2], [3, 4]]

import copy

original = [[1, 2], [3, 4]]
deep_copy = copy.deepcopy(original)

deep_copy[0][0] = 99
print(original)  # Output: [[1, 2], [3, 4]]
print(deep_copy) # Output: [[99, 2], [3, 4]]

import copy

original = {"a": [1, 2], "b": [3, 4]}
shallow_copy = copy.copy(original)

shallow_copy["a"][0] = 99
print(original)     # Output: {'a': [99, 2], 'b': [3, 4]}
print(shallow_copy) # Output: {'a': [99, 2], 'b': [3, 4]}

import copy

original = {"a": [1, 2], "b": [3, 4]}
deep_copy = copy.deepcopy(original)

deep_copy["a"][0] = 99
print(original)  # Output: {'a': [1, 2], 'b': [3, 4]}
print(deep_copy) # Output: {'a': [99, 2], 'b': [3, 4]}

# Without context manager
file = open("example.txt", "w")
file.write("Hello, World!")
file.close()  # Must remember to close the file

# With context manager
with open("example.txt", "w") as file:
    file.write("Hello, World!")
# File is automatically closed when the block is exited

class MyContextManager:
    def __enter__(self):
        print("Entering the context")
        return self  # Optional: Return an object to use in the `with` block

    def __exit__(self, exc_type, exc_value, traceback):
        print("Exiting the context")
        if exc_type is not None:
            print(f"An exception occurred: {exc_value}")
        # Return True to suppress the exception, False to propagate it
        return False

# Using the custom context manager
with MyContextManager() as cm:
    print("Inside the context")
    # raise ValueError("Something went wrong")  # Uncomment to test exception handling

from contextlib import contextmanager

@contextmanager
def my_context_manager():
    print("Entering the context")
    try:
        yield  # The block inside the `with` statement runs here
    except Exception as e:
        print(f"An exception occurred: {e}")
    finally:
        print("Exiting the context")

# Using the context manager
with my_context_manager():
    print("Inside the context")
    # raise ValueError("Something went wrong")  # Uncomment to test exception handling

   with open("example.txt", "r") as file:
       content = file.read()

   with db_connection() as conn:
       cursor = conn.cursor()
       cursor.execute("SELECT * FROM table")

   with threading.Lock():
       # Critical section
       pass

   from contextlib import redirect_stdout
   import io

   f = io.StringIO()
   with redirect_stdout(f):
       print("This goes to the buffer")
   print(f.getvalue())  # Output: This goes to the buffer

Name	Link
Visual Studio Code	https://code.visualstudio.com/
Sublime Text	https://www.sublimetext.com/
PyCharm	https://www.jetbrains.com/pycharm/
Jupyter	https://jupyter.org/

Operator	Description	Example	Result
`==`	Equal to	`5 == 5`	`True`
`!=`	Not equal to	`5 != 3`	`True`
`>`	Greater than	`10 > 5`	`True`
`<`	Less than	`10 < 5`	`False`
`>=`	Greater than or equal to	`10 >= 10`	`True`
`<=`	Less than or equal to	`10 <= 5`	`False`

Feature	Threading	Multiprocessing
Memory	Threads share the same memory space.	Processes have separate memory spaces.
GIL	Affected by the GIL (limits CPU-bound tasks).	Not affected by the GIL.
Use Case	Best for I/O-bound tasks.	Best for CPU-bound tasks.
Overhead	Low overhead.	Higher overhead due to separate memory spaces.
Scalability	Limited by the GIL.	Scales well with multiple CPU cores.

Use Case	Example
Multiplication	`5 * 3` → `15`
Exponentiation	`2 ** 3` → `8`
Unpacking iterables	`print(*[1, 2, 3])` → `1 2 3`
Extended unpacking	`first, *middle, last = [1, 2, 3, 4, 5]`
Variable-length arguments (`*args`)	`def func(*args): ...`
Unpacking in function calls	`func(*[1, 2, 3])`
Keyword argument unpacking (`**`)	`func(**{"a": 1, "b": 2})`
Keyword-only arguments	`def func(*, a, b): ...`

Use Case	Shallow Copy	Deep Copy
Object contains only immutable elements	Use shallow copy (no difference in behavior).	Use deep copy (no difference in behavior).
Object contains mutable nested objects	Use shallow copy if you want changes to nested objects to affect the original.	Use deep copy if you want changes to nested objects to not affect the original.
Performance	Faster (less memory and computation).	Slower (more memory and computation due to recursive copying).

Aspect	Shallow Copy	Deep Copy
Copies nested objects?	No (references are shared).	Yes (recursively copies nested objects).
Performance	Faster.	Slower.
Use Case	When nested objects are immutable or shared references are acceptable.	When nested objects are mutable and independent copies are needed.

Aspect	Details
Purpose	Manage resources (e.g., files, locks) safely and efficiently.
Syntax	`with context_manager as variable: ...`
Built-in Context Managers	`open()`, `threading.Lock()`, `contextlib.redirect_stdout()`, etc.
Custom Context Managers	Implement `__enter__` and `__exit__` methods or use `contextlib.contextmanager`.
Exception Handling	The `__exit__` method can handle exceptions raised in the `with` block.

Python Handbook: A Comprehensive Guide¶

By Attila Asghari¶

Purpose of This Handbook¶

Who Is This Handbook For?¶

How to Use This Handbook¶

Acknowledgments¶

About the Author¶

Prerequisites¶

Tools and Setup¶

Table of Contents¶

Beginner Python¶

Intermediate Python¶

1. Introduction to Python¶

Why Learn Python?¶

Installing Python¶

Writing Your First Python Program¶

Running a Python Program¶

Python Syntax Basics¶

Python Modes¶

2. Variables & Data Types¶

What Are Variables?¶

Rules for Naming Variables¶

Assigning Values to Variables¶

Data Types in Python¶

Dynamic Typing¶

Checking Data Types¶

Type Conversion¶

Variable Naming Conventions¶

Example Program¶

3. Working With Strings¶

Creating Strings¶

String Operations¶

String Methods¶

String Formatting¶

Escape Characters¶

Example Program¶

4. Working With Numbers¶

Types of Numbers¶

Basic Arithmetic Operations¶

Order of Operations (PEMDAS/BODMAS)¶

Type Conversion Between Numbers¶

Common Math Functions¶

Handling Large Numbers¶

Example Program¶

5. Getting Input From Users¶

The input() Function¶

Important Notes About input()¶

Example: Simple Calculator¶

Handling Multiple Inputs¶

Example: User Registration¶

Error Handling for User Input¶

Example Program¶

6. Lists¶

Creating Lists¶

Accessing List Elements¶

Modifying Lists¶

List Operations¶

List Methods¶

Example Program¶

7. List Functions¶

Common List Functions¶

Common List Methods¶

List Comprehensions¶

Example Program¶

8. Tuples¶

Creating Tuples¶

Accessing Tuple Elements¶

Tuples Are Immutable¶

Tuple Operations¶

Tuple Methods¶

When to Use Tuples¶

Unpacking Tuples¶

Example Program¶

9. Functions¶

Defining a Function¶

Calling a Function¶

Function Parameters and Arguments¶

Returning Values¶

Default Parameters¶

Keyword Arguments¶

The `input()` Function¶

Important Notes About `input()`¶

Using `in` and `not in` for Membership¶

Using the `range()` Function¶

Using the `pow()` Function¶

Using the `math.pow()` Function¶