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

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

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

# Define uma função chamada 'func' que recebe três parâmetros: a, b e c.
# Esta função simplesmente retorna a soma desses três parâmetros.
def func(a, b, c):
    # Retorna a soma de a, b e c
    return a + b + c

# Cria um dicionário chamado 'my_dict' com as chaves 'a', 'b' e 'c' e seus valores correspondentes 1, 2 e 3.
# Este dicionário será usado para fornecer argumentos para a função 'func'.
my_dict = {'a': 1, 'b': 2, 'c': 3}

# Chama a função 'func' usando o desempacotamento de dicionário (**my_dict).
# O desempacotamento de dicionário (**my_dict) é uma maneira conveniente de passar os valores do dicionário como argumentos de palavra-chave para a função.
# Aqui, será interpretado como chamar func(a=1, b=2, c=3)
result = func(**my_dict)

# Imprime o resultado da chamada da função. A saída esperada é a soma dos valores no dicionário, que é 1 + 2 + 3 = 6.
print(result)

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

# Define uma lista com inteiros variando de 10 a 70 com um incremento de 10
lst = [10, 20, 30, 40, 50, 60, 70]

# Usa o fatiamento de lista para selecionar uma parte específica da lista.
# O fatiamento de lista é feito usando a sintaxe lst[start:stop:step].
# Aqui, lst[2:5] fatia a lista do elemento no índice 2 para o elemento logo antes do índice 5.
# O índice 2 é o terceiro elemento (30) e o índice 5 é o sexto elemento, mas não incluído (60).
# Portanto, esse fatiamento retornará elementos nos índices 2, 3 e 4.
print(lst[2:5]) # Isso produzirá [30, 40, 50]

minha_lista = [1, 2]
nova_lista = minha_lista * 2
print(nova_lista)

# Defina uma lista chamada 'minha_lista' contendo dois elementos: os inteiros 1 e 2.
minha_lista = [1, 2]

# Crie uma nova lista chamada 'nova_lista' repetindo os elementos de 'minha_lista' duas vezes.
# O operador de multiplicação (*) quando usado com uma lista e um número repetirá
# os elementos da lista tantas vezes. Então, minha_lista * 2 resultará em [1, 2, 1, 2].
nova_lista = minha_lista * 2

# Imprima o conteúdo de 'nova_lista' no console.
# A saída esperada é: [1, 2, 1, 2]
print(nova_lista)

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

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

# Defina uma função geradora chamada 'gen' que recebe um parâmetro 'n'
def gen(n):
    # A função usa um loop 'for' para iterar em um intervalo de números de 0 a n-1
    for i in range(n):
        # 'yield' é usado para produzir uma sequência de valores. Aqui, ele produz o quadrado do número atual 'i'
        # Yielding em vez de return permite que a função produza uma série de valores preguiçosamente, o que significa que ela gera valores em tempo real, conforme necessário
        yield i**2

# Crie um objeto gerador 'g' chamando a função 'gen' com um argumento de 3
g = gen(3) # Isso inicializa o gerador, mas ainda não executa o corpo da função

# ConvertE o gerador 'g' em uma lista. Cada valor do gerador será coletado na lista
# Isso força o gerador a produzir todos os seus valores de uma vez, permitindo-nos ver a sequência completa que ele produz
print(list(g)) # A saída será [0, 1, 4]

# Explicação do comportamento:
# Quando o gerador 'g' é criado, ele está pronto para gerar valores, mas ainda não o fez.
# 'list(g)' iterará sobre o gerador, fazendo com que o loop 'for' dentro de 'gen' seja executado.
# A primeira iteração produz 0 (0 ao quadrado), a segunda produz 1 (1 ao quadrado) e a terceira produz 4 (2 ao quadrado).
# Esses valores produzidos são coletados em uma lista por 'list(g)' e então impressos.

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())

# Importa os componentes necessários da biblioteca SQLAlchemy
# SQLAlchemy é um kit de ferramentas SQL e uma biblioteca de mapeamento objeto-relacional (ORM) para Python.
from sqlalchemy import create_engine, text

# Cria um mecanismo de banco de dados SQLite na memória
# A string de conexão 'sqlite:///:memory:' especifica que queremos usar um banco de dados SQLite
# que será armazenado na RAM (portanto, será temporário e não persistirá após o término do programa).
engine = create_engine('sqlite:///:memory:')

# Use um gerenciador de contexto (com instrução) para gerenciar a conexão do banco de dados
# Isso garante que a conexão seja fechada corretamente após o bloco de código ser executado,
# mesmo se ocorrer um erro dentro do bloco.
with engine.connect() as connection:
    # Execute uma consulta SQL simples 'SELECT 1' usando a conexão
    # A função `text` é usada para encapsular a string SQL bruta, tornando seguro passá-la para SQLAlchemy.
    result = connection.execute(text("SELECT 1"))

    # Busca e imprime a primeira linha do resultado da consulta
    # 'fetchone()' recupera a primeira linha do conjunto de resultados.
    # Como 'SELECT 1' retorna uma única linha com uma única coluna contendo o valor 1,
    # ele deve imprimir (1,)
    print(result.fetchone())

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

# Lista inicial representando a pilha com elementos iniciais
stack = [3, 4, 5]

# Adicionando um elemento '6' ao topo da pilha usando o método append()
stack.append(6) # a pilha agora é [3, 4, 5, 6]

# Adicionando outro elemento '7' ao topo da pilha usando o método append()
stack.append(7) # a pilha agora é [3, 4, 5, 6, 7]

# Removendo e retornando o elemento do topo da pilha usando o método pop()
# Neste caso, ele removerá '7', pois é o último elemento adicionado (Último a Entrar, Primeiro a Sair - LIFO)
print(stack.pop()) # Isso imprimirá '7' e a pilha agora será [3, 4, 5, 6]

# - O método pop() remove e retorna o último elemento da lista.
# - Como '7' foi o último elemento anexado, ele é removido e retornado por pop().
# - Após pop(), o resultado é: stack = [3, 4, 5, 6]
# - A linha print(stack.pop()) não apenas remove '7' como também o imprime.

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

# Atribui a string "python" à variável x
x = "python"

# Inverta a string x usando fatiamento.
# A sintaxe de fatiamento x[inicio:fim:incremento] pode ser usada para manipular strings.
# Aqui, estamos usando x[::-1] que significa:
# - o início é omitido, então o padrão é o início da string
# - o fim é omitido, então o padrão é o fim da string
# - o incremento é -1, significando que tomamos passos de -1 e, assim, invertemos a string
y = x[::-1]

# Imprime a string original x e a string invertida y
# Isso produzirá: python nohtyp
print(x, y)

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

print(list1, ' ', list2)

# Criando uma lista chamada list1 com elementos inteiros: 1, 2, 3.
list1 = [1, 2, 3]

# Atribuindo list1 para list2. Aqui não estamos criando uma nova lista,
# apenas referenciando list2 para a mesma lista que list1.
list2 = list1

# Adicionando o número 4 ao final de list2.
# Como list2 e list1 referenciam a mesma lista na memória,
# essa operação afetará ambas.
list2.append(4)

# Imprimindo o conteúdo de list1 e list2.
# Como ambos referenciam a mesma lista, a saída será: [1, 2, 3, 4]  [1, 2, 3, 4]
print(list1, ' ', list2)

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

print(x, ' ', y)

# Define uma tupla x contendo três elementos: 1, 2 e 3
x = (1, 2, 3)

# Atribui y para referenciar o mesmo objeto de tupla que x referencia
y = x

# O operador '+=' para uma tupla cria uma nova tupla concatenando
# o conteúdo da tupla original e o iterável dado (4,)
# Aqui, a tupla (4,) é concatenada à tupla y, criando uma nova tupla (1, 2, 3, 4)
# Isso é atribuído a y, então y agora referencia a nova tupla (1, 2, 3, 4)
# Nota: y não modifica x; aponta para uma tupla recém-criada
y += (4,)

# Imprime a tupla original x e a tupla modificada y
# x permanece inalterado como (1, 2, 3)
# y faz referência à nova tupla (1, 2, 3, 4)
print(x, ' ', y) # Saída esperada: (1, 2, 3) (1, 2, 3, 4)

for i in range(5):
    if i == 3:
        break
    print(i , end = " ")
else:
    print("Todas as iterações concluídas")

# A função 'range(5)' gera uma sequência de números: 0, 1, 2, 3, 4.
for i in range(5):

    # Verifique se o valor atual de 'i' é igual a 3.
    if i == 3:
        # Se 'i' for 3, saia do loop.
        # Isso interrompe o loop prematuramente e evita que qualquer código dentro do loop
        # seja executado mais uma vez quando 'i' for igual a 3.
        break

    # Imprima o valor atual de 'i' seguido por um espaço
    # em vez de uma nova linha. 'end = " "' garante que os números
    # subsequentes serão impressos na mesma linha separados por um espaço.
    print(i, end=" ")

# O bloco 'else' associado ao loop 'for' só é executado
# se o loop concluir todas as iterações (ou seja, não encontrar uma instrução 'break').
else:
    # Imprima uma mensagem indicando que todas as iterações foram concluídas.
    # Esta linha será executada somente se o loop 'for' não foi encerrado
    # prematuramente por uma declaração 'break'.
    print("Todas as iterações concluídas")

from functools import reduce

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

# Importa a função reduce do módulo functools.
# O módulo functools fornece funções de ordem superior para programação funcional.
from functools import reduce

# Definindo uma lista de números inteiros.
nums = [32, 2, 2, 2, 2, 2]

# A função reduce aplica uma função binária cumulativamente aos itens de uma sequência,
# da esquerda para a direita, de modo a reduzir a sequência a um único valor.
# Neste caso, a função binária é uma função lambda que divide dois números (x, y).
# A aplicação da função lambda será feita da seguinte forma:
# Etapa 1: 32 / 2 = 16 
# Etapa 2: 16 / 2 = 8 
# Etapa 3: 8 / 2 = 4 
# Etapa 4: 4 / 2 = 2 
# Etapa 5: 2 / 2 = 1
result = reduce(lambda x, y: x / y, nums)

# Portanto, o resultado final da operação de redução será 1.
print(result)

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

# Definindo uma matriz (lista de listas) 3x3 com elementos inteiros
matriz = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# A expressão "for linha in matriz" itera por cada linha da matriz.
# A expressão "for num in linha" itera por cada número em cada linha.
# O resultado é uma nova lista contendo todos os números da matriz original sequencialmente.

# Descrição passo a passo:
# 1. Primeiro, para a linha [1, 2, 3]:
#    - num será 1, depois 2, e então 3.
# 2. Em seguida, para a linha [4, 5, 6]:
#    - num será 4, depois 5, e então 6.
# 3. Por último, para a linha [7, 8, 9]:
#    - num será 7, depois 8, e então 9.

result = [num for linha in matriz for num in linha]

# O esperado é que a lista resultante seja [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(result)

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

    def falar(self):
        raise NotImplementedError("A subclasse deve implementar um método abstrato")

class Cachorro(Animal):
    def falar(self):
        return "Auau!"

caramelo = Cachorro("Caramelo")
print(caramelo.falar())

# Definição da classe base Animal
class Animal:
    # Método construtor da classe Animal
    def __init__(self, nome):
        # Atributo de instância nome, que armazena o nome do animal
        self.nome = nome

    # Método abstrato falar, que deve ser implementado pelas subclasses
    def falar(self):
        # Levanta um erro caso a subclasse não implemente este método
        raise NotImplementedError("A subclasse deve implementar um método abstrato")

# Definição da classe Cachorro, que herda de Animal
class Cachorro(Animal):
    # Implementação do método falar para a classe Cachorro
    def falar(self):
        # Retorna o som que o cachorro faz
        return "Auau!"

# Criação de uma instância da classe Cachorro chamada Caramelo
caramelo = Cachorro("Caramelo")
# Impressão do resultado do método falar da instância Caramelo
print(caramelo.falar())