matriz = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
result = [num for linha in matriz for num in linha]
print(result)

# Define a 2D list (matrix) named 'matriz'
# This matrix has three rows and three columns
matriz = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# Initiate a list comprehension to flatten the 2D matrix into a 1D list
# A list comprehension is a concise way to create lists.
# In this case, it will iterate over each row (linha) in 'matriz'
# and then iterate over each element (num) in the current row (linha)
result = [num for linha in matriz for num in linha]

# Print the result
# Expected output will be: [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(result)

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

    def speak(self):
        raise NotImplementedError("Subclass must implement abstract method")

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

dog = Dog("Buddy")
print(dog.speak())

# Define a base class named Animal using the class keyword
class Animal:
    # The __init__ method initializes an instance of the class
    # 'self' refers to the instance of the class
    def __init__(self, name):
        # Assign the provided name to the attribute 'name' of the instance
        self.name = name

    # Define a method named 'speak'
    # This is intended to be an abstract method that should be overridden by subclasses
    def speak(self):
        # If a subclass does not override this method, raise a NotImplementedError
        # This ensures that the Animal class itself cannot be used directly to create objects,
        # it forces subclasses to define their own 'speak' method.
        raise NotImplementedError("Subclass must implement abstract method")

# Define a subclass of Animal named Dog
class Dog(Animal):
    # Override the speak method from the Animal class
    def speak(self):
        # Return a string representing the sound a dog makes
        return "Woof!"

# Create an instance of the Dog class with the name "Buddy"
dog = Dog("Buddy")

# Print the result of calling the speak method on the dog instance
# Since 'Dog' overrides 'speak', this will print "Woof!"
print(dog.speak())

from functools import reduce

numbers = [1, 2, 3, 4, 5]
result = reduce(lambda x, y: x + y, numbers)
print(result)

# Import the 'reduce' function from the 'functools' module.
# 'reduce' is a function for performing some computation on a list of elements and returning the final result.
# It is not a built-in function, hence we need to import it from functools.
from functools import reduce

# Create a list named 'numbers' which contains consecutive integers from 1 to 5.
# This list will serve as the input data for the 'reduce' function.
numbers = [1, 2, 3, 4, 5]

# 'reduce' applies a binary (two-input) function cumulatively to the items of the 'numbers' list, starting from the left.
# In this case, we are passing a lambda function as the first argument to 'reduce'.
# The lambda function defines the operation to be performed on the list elements.
# Here, 'x' is the accumulated value and 'y' is the next item in the sequence.
# The lambda adds the current accumulated value 'x' to the next item 'y'.
# 'reduce' ultimately combines (reduces) all the elements of 'numbers' by repeated application of the lambda function.
result = reduce(lambda x, y: x + y, numbers)

# Print out the final result of the reduction.
# The expected output here would be the sum of all the elements in the list 'numbers', which is 1 + 2 + 3 + 4 + 5 = 15.
print(result)

import matplotlib.pyplot as plt
x = [1, 2, 3, 4, 5]
y = [1, 4, 9, 16, 25]
plt.plot(x, y)
plt.show()

# Import the necessary module from the matplotlib library.
# 'pyplot' is a collection of command style functions that make matplotlib work like MATLAB.
import matplotlib.pyplot as plt

# Define the data for the x-axis. This is a list of integers.
x = [1, 2, 3, 4, 5]

# Define the corresponding data for the y-axis. Each y value corresponds to the x value at the same position in its list.
# In this case, y values are the squares of the x values.
y = [1, 4, 9, 16, 25]

# Plot the x and y data. This function creates a 2D line plot.
# The first argument is the x data and the second argument is the y data.
plt.plot(x, y)

# Display the plot on the screen.
plt.show()

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
y = list(filter(lambda x: x % 2 == 0, numbers))
print(y)

# List of the first 10 natural numbers
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# This line uses the filter() function along with a lambda function to filter out even numbers from the 'numbers' list.
# - 'lambda x: x % 2 == 0' is a small anonymous function that returns True if 'x' is even and False otherwise.
# - 'filter()' applies this lambda function to each element in the 'numbers' list.
# - 'list()' is used to convert the filter object (which is an iterator) into a list.
y = list(filter(lambda x: x % 2 == 0, numbers))

# Print the list of even numbers
print(y)

import numpy as np

array = np.arange(6).reshape(2, 3)
print(array[1, 2])

# Import the numpy library, which is a powerful library for numerical computing in Python.
# NumPy provides support for arrays, mathematical functions, and linear algebra operations.
import numpy as np

# Create a 1-Dimensional array containing a range of integers from 0 to 5 (inclusive).
# np.arange(6) creates an array: [0, 1, 2, 3, 4, 5]
array = np.arange(6)

# Reshape the 1-D array into a 2-D array with 2 rows and 3 columns.
# The reshape method allows us to change the shape of the array without changing its data.
# Resulting 2-D array (2 rows, 3 columns):
# [[0, 1, 2],
#  [3, 4, 5]]
array = array.reshape(2, 3)

# Print the element from the 2nd row and 3rd column of the reshaped array.
# Note: NumPy arrays use 0-based indexing, so array[1, 2] refers to the element
# in the second row (index 1) and the third column (index 2) of the array.
# In this case, array[1, 2] would be the value 5.
print(array[1, 2])

import pandas as pd

data = {'name': ['Alice', 'Bob', 'Charlie'],
        'age': [24, 25, 23]}
df = pd.DataFrame(data)
print(df.iloc[1])

# Import the pandas library to work with data structures like DataFrames, which are
# equivalent to tables in a database or Excel spreadsheet.
import pandas as pd

# Create a dictionary named 'data' containing two key-value pairs.
# The keys are 'name' and 'age'. The value associated with each key is a list.
# 'name' contains a list of strings (names of individuals).
# 'age' contains a list of integers (ages corresponding to each individual).
data = {'name': ['Alice', 'Bob', 'Charlie'],
        'age': [24, 25, 23]}

# Convert the dictionary 'data' into a pandas DataFrame.
# A DataFrame is a 2-dimensional labeled data structure with columns of potentially different types.
# It's similar to a table in SQL or an Excel spreadsheet.
# The DataFrame will have two columns (name and age) and three rows (one for each individual).
df = pd.DataFrame(data)

# Use the iloc method of the DataFrame to access a row by its integer index.
# iloc stands for "integer location".
# In this case, df.iloc[1] will access the second row (index 1, since indexing starts at 0).
# The second row corresponds to the data for 'Bob'.
print(df.iloc[1])

# Additional context:
# df.iloc[1] returns a Series object. A Series is a one-dimensional array-like object.
# The index (or labels) of the Series are derived from the DataFrame's columns.
# Therefore, the output will show the values of 'name' and 'age' for the second row.

import pandas as pd

s = pd.Series([1, 2, 3], index=['a', 'b', 'c'])
print(s['b'])

# Import the pandas library and give it an alias 'pd'
# Pandas is a powerful data manipulation library used for data analysis in Python.
import pandas as pd

# Create a pandas Series.
# A Series is a one-dimensional array-like object that can hold various data types (ints, floats, strings, etc.).
# Here, we are creating a Series with three integer values: 1, 2, and 3.
# The 'index' parameter specifies custom labels for the data elements.
s = pd.Series([1, 2, 3], index=['a', 'b', 'c'])

# Print the value associated with the index 'b'.
# Series in pandas can be accessed similarly to dictionaries where keys are the index labels.
# In this case, 'b' is the index label for the second element in the Series (which is 2).
print(s['b'])

class MyClass:
    pass

obj = MyClass()
obj.new_attr = 10
print(obj.new_attr)

# Define a class named MyClass
# In Python, "class" is a keyword used to define a new class, followed by the class name.
class MyClass:
    pass # The pass statement is a placeholder that indicates an empty block of code.

# Create an instance of MyClass and assign it to the variable 'obj'
# Creating an instance means creating an object based on the class definition.
obj = MyClass()

# Add a new attribute 'new_attr' to the 'obj' instance and set its value to 10
# In Python, you can dynamically add attributes to an instance of a class.
# Here, we are assigning the value 10 to 'new_attr' on 'obj'.
obj.new_attr = 10

# Print the value of 'new_attr' attribute of 'obj'
print(obj.new_attr)

from functools import reduce

items = [1, 2, 3, 4]
result = reduce(lambda x, y: x * y, items)
print(result)

# The 'reduce' function is useful for performing some computation on a list and returning the result.
# For example, 'reduce' can be used to sum or multiply all the numbers in a list.
from functools import reduce

# Create a list named 'items' that contains the integer elements 1, 2, 3, and 4.
items = [1, 2, 3, 4]

# Use the 'reduce' function to apply a lambda function to 'items'.
# The lambda function takes two arguments 'x' and 'y' and multiplies them together.
# The 'reduce' function applies the lambda function cumulatively to the items of the list, from left to right,
# so as to reduce the list to a single value by performing the multiplication.
# Here's how it works step-by-step:
# Step 1: x = 1 (first item of the list), y = 2 (second item of the list), result = 1 * 2 = 2
# Step 2: x = 2 (result from step 1), y = 3 (third item of the list), result = 2 * 3 = 6
# Step 3: x = 6 (result from step 2), y = 4 (fourth item of the list), result = 6 * 4 = 24
# After the final step, the 'reduce' function returns the result, which is 24.
result = reduce(lambda x, y: x * y, items)

# Print the final result of the 'reduce' function, which is 24.
print(result) 

x = {1, 2, 3}
y = {4, 3, 6}
z = x & y
print(z)

# Define a set 'x' with the elements 1, 2, and 3.
x = {1, 2, 3}

# Define another set 'y' with the elements 4, 3, and 6.
y = {4, 3, 6}

# The '&' operator is used to find the intersection of sets 'x' and 'y'.
# The intersection of two sets is a new set containing all elements that are 
# common to both 'x' and 'y'. In this case, both sets 'x' and 'y' contain the element '3'.
z = x & y

# Print the intersection set 'z'.
# In this case, it will output {3} because 3 is the only common element in both sets.
print(z)

import re

text = "Let's learn Python 3.11 and more!"
pattern = re.compile(r'\d+\.?\d*')
match = pattern.findall(text)
print(match)

# Import the regular expression module. This module provides support for regular expressions in Python.
import re

# This is the text we're going to search for patterns in.
text = "Let's learn Python 3.11 and more!"

# We're using a regular expression to find patterns in the text.
# In this case, the pattern is a sequence of one or more digits (represented by \d+)
# followed by an optional decimal point (represented by \.) and any number of digits (represented by \d*).
# The r before the pattern string indicates that it's a raw string, which means backslashes in the string are interpreted literally.
pattern = re.compile(r'\d+\.?\d*')

# The findall function returns all non-overlapping matches of pattern in string, as a list of strings.
# The string is scanned left-to-right, and matches are returned in the order found.
match = pattern.findall(text)

# Print the matches. In this case, it should print ['3.11'], because that's the only sequence of digits followed by a decimal point and more digits in the text.
print(match)