x = {'a' : 10, 'b' : 20}
y = {'b' : 30, 'c' : 40}

z = {**x, **

frutas = ['lemon', 'apple', 'banana', 'orange']
((x, *y), *z) = frutas
print(y)

# List of fruits
# Here we declare a list containing several types of fruits as strings.
fruits = ['lemon', 'apple', 'banana', 'orange']

# Unpacking the 'fruits' list
# We are using a technique called unpacking, which allows us to decompose parts of an iterable, like a list, into distinct variables.

# (x, *y): This pattern is used to unpack values. 'x' will receive the first letter from the first item of the list.
# '*y' reads as "whatever is left". It packs the remaining characters of the first element into a list.
#
# *z: This syntax is used to capture any remaining items in the list after extracting (x, *y).
# 'z' will effectively store the rest of the 'fruits' list starting from 'apple'.

# Important to note here is that:
# (x, *y) works on the first element of 'fruits', which is the string 'lemon'.
# This results in x getting 'l' and y getting ['e', 'm', 'o', 'n'].
((x, *y), *z) = fruits

# Printing the values stored in y.
# We expect ['e', 'm', 'o', 'n'] because of how 'lemon' was unpacked into x and y.
print(y)

# Additional Explanation:
# Since 'x' assigned the first character 'l' from "lemon" and 'y' gathered the rest ['e', 'm', 'o', 'n'], we print the list 'y'.
# The remaining elements of the 'fruits' list ('apple', 'banana', 'orange') are packed into the list 'z'.

lst = [1, 3, 5, 7, 9, 11, 13, 15]
print(lst[::-2])

# Initialize a list `lst` with a series of odd integers from 1 to 15.
lst = [1, 3, 5, 7, 9, 11, 13, 15]

# Print a sliced version of the list `lst` but in reverse order.
# The slice `[::-2]` can be broken down as follows:
# - `:` before the first colon means to include all elements from the start.
# - `:` after the second colon means to include all elements until the end.
# - `-2` is the step value, which means to take every second element, moving backward.
# Therefore, `[::-2]` means: start from the end of the list, move left by 2 steps
# each time, and collect the elements in this way until the beginning of the list is reached.
print(lst[::-2])

def func(a, b, c):
    return a + b + c

my_dict = {'a': 1, 'b': 2, 'c': 3}

result = func(**my_dict)
print(result)

# Define a function named 'func' that takes three parameters: a, b, and c.
# This function simply returns the sum of these three parameters.
def func(a, b, c):
    # Return the sum of a, b, and c
    return a + b + c

# Create a dictionary named 'my_dict' with keys 'a', 'b', and 'c' and their corresponding values 1, 2, and 3.
# This dictionary will be used to provide arguments to the 'func' function.
my_dict = {'a': 1, 'b': 2, 'c': 3}

# Call the 'func' function using dictionary unpacking (**my_dict).
# Dictionary unpacking (**my_dict) is a convenient way to pass the values of the dictionary as keyword arguments to the function.
# Here, it will be interpreted as calling func(a=1, b=2, c=3)
result = func(**my_dict)

# Print the result of the function call. The expected output is the sum of the values in the dictionary, which is 1 + 2 + 3 = 6.
print(result)

lst = [10, 20, 30, 40, 50, 60, 70]
print(lst[2:5])

# Define a list with integers ranging from 10 to 70 with an increment of 10
lst = [10, 20, 30, 40, 50, 60, 70]

# Use list slicing to select a specific portion of the list.
# List slicing is done using the syntax lst[start:stop:step].
# Here, lst[2:5] slices the list from the element at index 2 to the element right before index 5.
# Index 2 is the third element (30) and index 5 is the sixth element but not included (60).
# Hence, this slice will return elements at indices 2, 3, and 4.
print(lst[2:5])  # This will output [30, 40, 50]

my_list = [1, 2]
new_lista = my_list * 2
print(new_lista)

# Define a list called 'my_list' containing two elements: the integers 1 and 2.
my_list = [1, 2]

# Create a new list called 'new_list' by repeating the elements of 'my_list' twice.
# The multiplication operator (*) when used with a list and a number will repeat
# the elements of the list that many times. So, my_list * 2 will result in [1, 2, 1, 2].
new_list = my_list * 2 

# Print the contents of 'new_list' to the console.
# The expected output is: [1, 2, 1, 2]
print(new_list)

def gen(n):
    for i in range(n):
        yield i**2

g = gen(3)
print(list(g))

# Define a generator function named 'gen' that takes one parameter 'n'
def gen(n):
    # The function uses a 'for' loop to iterate over a range of numbers from 0 to n-1
    for i in range(n):
        # 'yield' is used to produce a sequence of values. Here it yields the square of the current number 'i'
        # Yielding instead of returning allows the function to produce a series of values lazily, meaning it generates values on the fly as needed
        yield i**2

# Create a generator object 'g' by calling the 'gen' function with an argument of 3
g = gen(3)  # This initializes the generator but does not execute the function body yet

# Convert the generator 'g' to a list. Each value from the generator will be collected into the list
# This forces the generator to yield all its values at once, allowing us to see the full sequence it produces
print(list(g))  # Output will be [0, 1, 4]

# Explanation of the behavior:
# When the generator 'g' is created, it is ready to generate values but hasn't done so yet.
# 'list(g)' will iterate over the generator, occurring the 'for' loop inside 'gen' to run.
# The first iteration yields 0 (0 squared), the second yields 1 (1 squared), and the third yields 4 (2 squared).
# These yielded values are collected into a list by 'list(g)' and then printed.

from sqlalchemy import create_engine, text

engine = create_engine('sqlite:///:memory:')

with engine.connect() as connection:
    result = connection.execute(text("SELECT 1"))
    print(result.fetchone())

# Import the required components from the SQLAlchemy library
# SQLAlchemy is a SQL toolkit and Object-Relational Mapping (ORM) library for Python.
from sqlalchemy import create_engine, text

# Create an in-memory SQLite database engine
# The connection string 'sqlite:///:memory:' specifies that we want to use an SQLite database
# that will be stored in RAM (thus, it will be temporary and not persist after the program ends).
engine = create_engine('sqlite:///:memory:')

# Use a context manager (with statement) to manage the database connection
# This ensures that the connection is properly closed after the block of code is executed, 
# even if an error occurs within the block.
with engine.connect() as connection:
    # Execute a simple SQL query 'SELECT 1' using the connection
    # The `text` function is used to wrap the raw SQL string, making it safe to pass it to SQLAlchemy.
    result = connection.execute(text("SELECT 1"))

    # Fetch and print the first row of the query result
    # 'fetchone()' retrieves the first row from the result set.
    # Since 'SELECT 1' returns a single row with a single column containing the value 1, 
    # it should print (1,)
    print(result.fetchone())

stack = [3, 4, 5]
stack.append(6)
stack.append(7)
print(stack.pop())

# Initial list representing the stack with initial elements
stack = [3, 4, 5]

# Adding an element '6' to the top of the stack using the append() method
stack.append(6)  # stack now is [3, 4, 5, 6]

# Adding another element '7' to the top of the stack using the append() method
stack.append(7)  # stack now is [3, 4, 5, 6, 7]

# Removing and returning the top element of the stack using the pop() method
# In this case, it will remove '7' since it is the last element added (Last In, First Out - LIFO)
print(stack.pop())  # This will print '7' and the stack now will be [3, 4, 5, 6]

# - The pop() method removes and returns the last element from the list.
# - Since '7' was the last appended element, it is removed and returned by pop().
# - After pop(), the result is: stack = [3, 4, 5, 6]
# - The line print(stack.pop()) not only removes '7' but also prints it.

x = "python"
y = x[::-1]
print(x, y)

# Assign the string "python" to the variable x
x = "python"

# Reverse the string x by using slicing.
# The slicing syntax x[start:stop:step] can be used to manipulate strings.
# Here, we are using x[::-1] which means:
# - start is omitted, so it defaults to the start of the string
# - stop is omitted, so it defaults to the end of the string
# - step is -1, meaning we take steps of -1 and thus reverse the string
y = x[::-1]

# Print the original string x and the reversed string y
# The print function prints its arguments separated by a space by default
# This will output: python nohtyp
print(x, y)

list1 = [1, 2, 3]
list2 = list1
list2.append(4)

print(list1, ' ', list2)

# Initialize the first list with three integer elements: 1, 2, and 3
list1 = [1, 2, 3]  # list1 is now [1, 2, 3]

# Make the variable list2 refer to the same list object that list1 refers to
# This does not create a new list but just another reference to the same list
list2 = list1  # Now list2 is also [1, 2, 3] and points to the same underlying list as list1

# Append the integer 4 to the list through the reference list2
# Since list2 and list1 reference the same list, this change affects both variables
list2.append(4)  # The list both list1 and list2 reference is now [1, 2, 3, 4]

# Print the contents of list1 and list2
# Since list1 and list2 are references to the same underlying list,
# the change is reflected in both, showing they are identical
print(list1, ' ', list2)  # This will output: [1, 2, 3, 4]   [1, 2, 3, 4]

x = (1, 2, 3)
y = x
y += (4,)

print(x, ' ', y)

# This line creates a tuple named 'x' with the values 1, 2, and 3.
x = (1, 2, 3)

# This line assigns the tuple 'x' to the variable 'y'.
# Both 'x' and 'y' now reference the same tuple object.
y = x

# Here, we are using augmented assignment (+=) to add a new element (4,) to the tuple 'y'.
# Note: Because tuples are immutable in Python, this actually creates a new tuple rather than modifying the existing one.
# The expression 'y += (4,)' is similar to 'y = y + (4,)', which concatenates the two tuples.
y += (4,)

# Now, 'x' still references the original tuple (1, 2, 3),
# but 'y' references a new tuple (1, 2, 3, 4) because tuples are immutable.
# This means that when we "modified" 'y', we actually created a new tuple and updated 'y' to point to this new tuple.
# The original tuple that 'x' references remains unchanged.
print(x, ' ', y)  # This will print: (1, 2, 3)   (1, 2, 3, 4)

for i in range(5):
    if i == 3:
        break
    print(i , end = " ")
else:
    print("All iterations complete")

# The 'range(5)' function generates a sequence of numbers: 0, 1, 2, 3, 4.
for i in range(5):

    # Check if the current value of 'i' is equal to 3.
    if i == 3:
        # If 'i' is 3, break out of the loop. 
        # This stops the loop prematurely and prevents any code within the loop 
        # from running further once 'i' equals 3.
        break

    # Print the current value of 'i' followed by a space
    # instead of a newline. 'end = " "' ensures that subsequent
    # numbers will be printed on the same line separated by a space.
    print(i, end=" ")

# The 'else' block associated with the 'for' loop only executes 
# if the loop completes all iterations (i.e., it doesn't encounter a 'break' statement).
else:
    # Print a message indicating that all iterations were completed.
    # This line will be executed only if the 'for' loop wasn't terminated
    # prematurely by a 'break' statement.
    print("All iterations complete")

from functools import reduce

nums = [32 ,2 ,2 ,2 ,2 ,2]
result = reduce(lambda x, y: x / y, nums)
print(result)

# The 'functools' module provides higher-order functions that act on or return other functions.
# Here, we import the 'reduce' function from the 'functools' module.
from functools import reduce

# Initializing a list of numbers. In this case, the list is called 'nums' and contains six integer elements.
nums = [32, 2, 2, 2, 2, 2]

# The 'reduce' function is used to apply a binary function (in this case, a lambda function for division) 
# cumulatively to the items of the iterable (here 'nums'), from left to right, so as to reduce the iterable 
# to a single value.

# A lambda function is an anonymous function in Python represented as 'lambda x, y: x / y' here. 
# It takes two arguments, 'x' and 'y', and returns the result of dividing 'x' by 'y'.
result = reduce(lambda x, y: x / y, nums)

# The 'reduce' function will process the 'nums' list as follows:
# Step 1: 32 / 2 = 16
# Step 2: 16 / 2 = 8
# Step 3: 8 / 2 = 4
# Step 4: 4 / 2 = 2
# Step 5: 2 / 2 = 1

# So, the final result of the reduce operation will be 1.
print(result)