from functools import reduce

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

# Importe a função 'reduce' do módulo 'functools'.
# 'reduce' é uma função para executar alguma computação em uma lista de elementos e retornar o resultado final.
# Não é uma função interna, portanto, precisamos importá-la de functools.
from functools import reduce

# Crie uma lista chamada 'numbers' que contém inteiros consecutivos de 1 a 5.
# Esta lista servirá como dados de entrada para a função 'reduce'.
numbers = [1, 2, 3, 4, 5]

# 'reduce' aplica uma função binária (duas entradas) cumulativamente aos itens da lista 'numbers', começando da esquerda.
# Neste caso, estamos passando uma função lambda como o primeiro argumento para 'reduce'.
# A função lambda define a operação a ser executada nos elementos da lista.
# Aqui, 'x' é o valor acumulado e 'y' é o próximo item na sequência.
# O lambda adiciona o valor acumulado atual 'x' ao próximo item 'y'.
# 'reduce' finalmente combina (reduz) todos os elementos de 'numbers' pela aplicação repetida da função lambda.
result = reduce(lambda x, y: x + y, numbers)

# Imprime o resultado final da redução.
# A saída esperada aqui seria a soma de todos os elementos na lista 'numbers', que é 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()

# Importa o módulo necessário da biblioteca matplotlib.
# 'pyplot' é uma coleção de funções de estilo de comando que fazem matplotlib funcionar como MATLAB.
import matplotlib.pyplot as plt

# Define os dados para o eixo x. Esta é uma lista de inteiros.
x = [1, 2, 3, 4, 5]

# Define os dados correspondentes para o eixo y. Cada valor y corresponde ao valor x na mesma posição em sua lista.
# Neste caso, os valores y são os quadrados dos valores x.
y = [1, 4, 9, 16, 25]

# Plota os dados x e y. Esta função cria um gráfico de linha 2D.
# O primeiro argumento são os dados x e o segundo argumento são os dados y.
plt.plot(x, y)

# Exiba o gráfico na tela.
plt.show()

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

# Lista dos primeiros 10 números naturais
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Esta linha usa a função filter() junto com uma função lambda para filtrar números pares da lista 'numbers'.
# - 'lambda x: x % 2 == 0' é uma pequena função anônima que retorna True se 'x' for par e False caso contrário.
# - 'filter()' aplica esta função lambda a cada elemento na lista 'numbers'.
# - 'list()' é usada para converter o objeto de filtro (que é um iterador) em uma lista.
y = list(filter(lambda x: x % 2 == 0, numbers))

# Imprime a lista de números pares
print(y)

import numpy as np

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

# Importe a biblioteca numpy, que é uma biblioteca poderosa para computação numérica em Python.
# NumPy fornece suporte para matrizes, funções matemáticas e operações de álgebra linear.
import numpy as np

# Crie uma matriz unidimensional contendo um intervalo de inteiros de 0 a 5 (inclusive).
# np.arange(6) cria uma matriz: [0, 1, 2, 3, 4, 5]
array = np.arange(6)

# Remodele a matriz 1-D em uma matriz 2-D com 2 linhas e 3 colunas.
# O método reshape nos permite alterar a forma da matriz sem alterar seus dados.
# Matriz 2-D resultante (2 linhas, 3 colunas):
# [[0, 1, 2],
# [3, 4, 5]]
array = array.reshape(2, 3)

# Imprime o elemento da 2ª linha e 3ª coluna da matriz remodelada.
# Observação: matrizes NumPy usam indexação baseada em 0, então array[1, 2] se refere ao elemento
# na segunda linha (índice 1) e na terceira coluna (índice 2) da matriz.
# Nesse caso, array[1, 2] seria o valor 5.
print(array[1, 2])

import pandas as pd

dados = {'nome': ['Ana', 'Bruno', 'Carlos'],
        'idade': [24, 25, 23]}

df = pd.DataFrame(dados)
print(df.iloc[1])

# Importe a biblioteca pandas para trabalhar com estruturas de dados como DataFrames, que são
# equivalentes a tabelas em um banco de dados ou planilha do Excel.
import pandas as pd

# Crie um dicionário chamado 'dados' contendo dois pares de chave-valor.
# As chaves são 'nome' e 'idade'. O valor associado a cada chave é uma lista.
# 'nome' contém uma lista de strings (nomes de indivíduos).
# 'idade' contém uma lista de inteiros (idades correspondentes a cada indivíduo).
dados = {'nome': ['Ana', 'Bruno', 'Carlos'],
        'idade': [24, 25, 23]}

# Converte o dicionário 'dados' em um DataFrame do pandas.
# Um DataFrame é uma estrutura de dados rotulada bidimensional com colunas de tipos potencialmente diferentes.
# É semelhante a uma tabela em SQL ou uma planilha do Excel.
# O DataFrame terá duas colunas (nome e idade) e três linhas (uma para cada indivíduo).
df = pd.DataFrame(dados)

# Uso do método iloc do DataFrame para acessar uma linha pelo seu índice inteiro.
# iloc significa "integer location".
# Neste caso, df.iloc[1] acessará a segunda linha (índice 1, já que a indexação começa em 0).
# A segunda linha corresponde aos dados de 'Bruno'.
print(df.iloc[1])

# Contexto adicional:
# df.iloc[1] retorna um objeto Series. Uma Series é um objeto unidimensional do tipo array.
# O índice (ou rótulos) da Series são derivados das colunas do DataFrame.
# Portanto, a saída mostrará os valores de 'nome' e 'idade' para a segunda linha.

import pandas as pd

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

# Importa a biblioteca pandas e a renomeia como 'pd' para facilitar o uso.
# pandas é uma biblioteca poderosa para análise e manipulação de dados.
import pandas as pd

# Cria uma Série (Series) em pandas. Uma Série é uma estrutura de dados unidimensional, 
# semelhante a uma lista ou um array, mas com capacidade de rotular cada elemento (indexação).
# Aqui, estamos criando uma Série com os valores [1, 2, 3] e atribuindo a ela rótulos de índice ['a', 'b', 'c'].
s = pd.Series([1, 2, 3], index=['a', 'b', 'c'])

# Imprime o valor associado ao índice 'b' na Série.
# Neste caso, o valor é 2, pois 'b' está associado ao segundo elemento da lista [1, 2, 3].
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)

# A função 'reduce' é útil para executar alguma computação em uma lista e retornar o resultado.
# Por exemplo, 'reduce' pode ser usada para somar ou multiplicar todos os números em uma lista.
from functools import reduce

# Criação de uma lista chamada 'items' com os números 1, 2, 3 e 4
items = [1, 2, 3, 4]

# Use a função 'reduce' para aplicar uma função lambda a 'items'.
# A função lambda pega dois argumentos 'x' e 'y' e os multiplica.
# A função 'reduce' aplica a função lambda cumulativamente aos itens da lista, da esquerda para a direita,
# para reduzir a lista a um único valor realizando a multiplicação.
# Veja como funciona passo a passo:
# Etapa 1: x = 1 (primeiro item da lista), y = 2 (segundo item da lista), resultado = 1 * 2 = 2
# Etapa 2: x = 2 (resultado da etapa 1), y = 3 (terceiro item da lista), resultado = 2 * 3 = 6
# Etapa 3: x = 6 (resultado da etapa 2), y = 4 (quarto item da lista), resultado = 6 * 4 = 24
# Após a etapa final, a função 'reduce' retorna o resultado, que é 24.
result = reduce(lambda x, y: x * y, items)

# Imprime o resultado final, que será o produto de todos os números na lista 'items'
print(result)

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

# Em Python, um conjunto (set) é uma coleção de itens únicos e não ordenados.
# Aqui, estamos criando um conjunto `x` com os valores 1, 2 e 3.
x = {1, 2, 3}

# Similarmente, criamos outro conjunto `y` com os valores 4, 3 e 6.
y = {4, 3, 6}

# O operador & (AND) aplicado aos conjuntos retorna a interseção entre eles.
# A interseção de dois conjuntos é um novo conjunto contendo apenas os elementos
# que existem em ambos os conjuntos, `x` e `y`.
z = x & y

# Neste caso, `z` conterá apenas o valor {3}, pois 3 é o único elemento
# que está presente em ambos os conjuntos `x` e `y`.
print(z)

import re

text = "Vamos aprender Python 3.11 e muito mais!"
pattern = re.compile(r'\d+\.?\d*')
match = pattern.findall(text)
print(match)

# Importação do módulo 're', que fornece ferramentas para manipulação de expressões regulares
import re

# Define uma string de exemplo chamada 'text'
text = "Vamos aprender Python 3.11 e muito mais!"

# Usa 're.compile' para compilar um padrão de expressão regular
# Padrão r'\d+\.?\d*' explica a seguir:
# r'' - Indica que é uma string "raw" (crua), onde caracteres especiais nas expressões regulares são tratados literalmente
# \d+ - Correspondência de um ou mais dígitos (por exemplo, 3 ou 11 em '3.11')
# \.? - Opcionalmente, corresponder a um ponto ('.'), usado em números decimais
# \d* - Correspondência de zero ou mais dígitos após o ponto (por exemplo, .11 em '3.11')
pattern = re.compile(r'\d+\.?\d*')

# Usa o método 'findall' para encontrar todas as correspondências do padrão na string 'text'
# 'findall' retorna uma lista de todas as substrings na string que correspondem ao padrão
match = pattern.findall(text)

# Imprime a lista de correspondências encontradas
# No caso da string 'text', deverá imprimir ['3.11']
print(match)

valor = 7 and 8
resultado = "Par" if valor % 2 == 0 else "Ímpar"
print(resultado)

# A expressão "7 and 8" usa o operador lógico 'and', que retorna o último valor quando ambos são verdadeiros.
# Portanto, 'valor' será 8 porque 7 e 8 são valores "verdadeiros" (não zero).
valor = 7 and 8

# Aqui, estamos usando uma expressão condicional (também conhecida como operador ternário) para definir a variável 'resultado'.
# O operador % é o módulo, que retorna o resto da divisão. Se o resto da divisão de 'valor' por 2 for zero, significa que 'valor' é par.
# A expressão 'valor % 2 == 0' será True se 'valor' for par e False se for ímpar.
# Se a expressão for True (par), 'resultado' recebe a string "Par", caso contrário (False, ímpar), recebe a string "Ímpar".
resultado = "Par" if valor % 2 == 0 else "Ímpar"

# Finalmente, o comando 'print' exibe o valor da variável 'resultado' na tela.
print(resultado)

def bold_decorator(func):
    def wrapper():
        return "<b>" + func() + "</b>"
    return wrapper

@bold_decorator
def diz_ola():
    return "Olá, mundo!"

result = diz_ola()
print(result)

# Definindo um decorador chamado 'bold_decorator'
# Um decorador é uma função que modifica o comportamento de outra função
def bold_decorator(func):
    # A função 'wrapper' será a função intermediária que realiza a modificação
    def wrapper():
        # Aqui, modificamos a saída da função 'func' adicionando tags HTML <b> para deixar o texto em negrito
        return "<b>" + func() + "</b>"
    # Retornamos a função 'wrapper' que agora contém o comportamento melhorado/modificado
    return wrapper

# Utilizando o decorador 'bold_decorator' na função 'diz_ola'
# O '@bold_decorator' é uma sintaxe especial que aplica o decorador à função 'diz_ola'
@bold_decorator
def diz_ola():
    # Esta função simplesmente retorna a string "Olá, mundo!"
    return "Olá, mundo!"

# Aqui, chamamos a função 'diz_ola' que agora está decorada
# O retorno será a string "Olá, mundo!" dentro de tags <b>
result = diz_ola()

# Imprimimos o resultado na tela, que será: <b>Olá, mundo!</b>
print(result)