def mystery_function(x):
    result = 1
    while x > 0:
        result *= x
        x -= 1
    return result

mystery_function(4)

def mystery_function(x):
    # Inicializa a variável 'result' com o valor 1
    # 'result' será usado para calcular o produto dos números
    result = 1

    # Enquanto 'x' for maior que 0, continue executando o bloco de código abaixo
    while x > 0:
        # Multiplica o valor atual de 'result' por 'x' e armazena de volta em 'result'
        # Isso efetivamente acumula o produto de 'x' com todos os inteiros abaixo dele
        result *= x

        # Decrementa 'x' em 1 a cada iteração
        # Isso é importante para eventualmente parar o loop quando 'x' chegar a 0
        x -= 1

    # Retorna o valor calculado de 'result', que no final será o fatorial de 'x' inicial
    return result

# Chama a função 'mystery_function' com o argumento 4
# Espera-se que o resultado seja 4 * 3 * 2 * 1 = 24
mystery_function(4)

def apresente_se(nome, idade, cidade="São Paulo"):
    print(f"Sou a {nome}, tenho {idade} anos e vivo em {cidade}.")

apresente_se(nome="Alice", idade=30)

# Definimos uma função chamada 'apresente_se' que aceita três argumentos
# 'nome' e 'idade' são argumentos obrigatórios
# 'cidade' é um argumento opcional com um valor padrão "São Paulo"
def apresente_se(nome, idade, cidade="São Paulo"):
    # Utilizamos uma string formatada (f-string) para imprimir uma mensagem
    # Essa mensagem inclui o nome, a idade, e a cidade da pessoa
    print(f"Sou a {nome}, tenho {idade} anos e vivo em {cidade}.")

# Chamamos a função 'apresente_se' com argumentos nomeados
# Passamos o valor "Alice" para o parâmetro 'nome'
# Passamos o valor 30 para o parâmetro 'idade'
# Não passamos nada para 'cidade', então ele usa o valor padrão "São Paulo"
apresente_se(nome="Alice", idade=30)

# O resultado desta chamada será:
# "Sou a Alice, tenho 30 anos e vivo em São Paulo."

def decorator(func):
    def wrapper():
        print("(Início)", end = ' ')
        func()
        print("(Fim)", end = ' ')
    return wrapper

@decorator
def cumprimento():
    print("Olá", end = ' ')

cumprimento()

# Definimos uma função chamada `decorator` que recebe outra função como argumento.
def decorator(func):
    # Dentro do `decorator`, criamos uma função `wrapper` que irá envolver (ou "embrulhar") a função original.
    def wrapper():
        # Imprime "(Início)" antes de chamar a função original. 
        # O parâmetro `end=' '` impede a mudança de linha após a impressão.
        print("(Início)", end=' ')
        # Chama-se a função original passada como argumento para o decorator.
        # Neste exemplo, seria a função `cumprimento`.
        func()
        # Imprime "(Fim)" após a execução da função original.
        # O `end=' '` novamente impede a mudança de linha, para que continue na mesma linha.
        print("(Fim)", end=' ')
    # Retorna a função `wrapper`, agora "decorada", em vez da função original.
    return wrapper

# Utilizamos o decorator `@decorator` logo acima da definição da função `cumprimento`.
# Isso significa que `cumprimento` será passado automaticamente como argumento para a função `decorator`.
@decorator
def cumprimento():
    # Essa é a função original que desejamos decorar.
    # Imprime "Olá" no terminal.
    print("Olá", end=' ')

# Ao chamar `cumprimento()`, na realidade estamos chamando a função `wrapper` retornada pelo `decorator`.
# Portanto, a saída será "(Início) Olá (Fim)" tudo na mesma linha.
cumprimento()

class CaixaDeBrinquedosMágica(type):
    def __init__(cls, nome, bases, attrs):
        cls._contador_brinquedos = 0
        super().__init__(nome, bases, attrs)

    def __call__(cls, *args, **kwargs):
        cls._contador_brinquedos += 1
        return super().__call__(*args, **kwargs)

class Brinquedo(metaclass=CaixaDeBrinquedosMágica):
    def __init__(self, forma_divertida):
        self.forma_divertida = forma_divertida

brinquedo1 = Brinquedo("🚗")
brinquedo2 = Brinquedo("🐻")
brinquedo3 = Brinquedo("🦕")

print(f"Quantos brinquedos na caixa? {Brinquedo._contador_brinquedos}")

# Definindo uma classe metaclass chamada CaixaDeBrinquedosMágica
# Metaclasses são como classes de classes, ou seja, elas definem o comportamento de outras classes.
class CaixaDeBrinquedosMágica(type):
    # Método especial __init__, que é chamado quando a classe (não a instância) é criada
    def __init__(cls, nome, bases, attrs):
        # Inicializa um contador de brinquedos na classe que usa esta metaclasse
        cls._contador_brinquedos = 0
        # Chama o método __init__ da superclasse 'type'
        super().__init__(nome, bases, attrs)

    # Método especial __call__, que é chamado quando uma instância da classe (que usa esta metaclasse) é criada
    def __call__(cls, *args, **kwargs):
        # Incrementa o contador de brinquedos a cada vez que uma instância é criada
        cls._contador_brinquedos += 1
        # Chama o __call__ da superclasse para efetivamente criar a instância
        return super().__call__(*args, **kwargs)

# Criando a classe Brinquedo que usa a metaclasse CaixaDeBrinquedosMágica
class Brinquedo(metaclass=CaixaDeBrinquedosMágica):
    # Método especial __init__ de uma instância, que é chamado ao criar cada brinquedo
    def __init__(self, forma_divertida):
        # Armazena a forma divertida do brinquedo passado no momento da criação da instância
        self.forma_divertida = forma_divertida

# Cria várias instâncias da classe Brinquedo, cada uma com uma forma divertida específica
brinquedo1 = Brinquedo("🚗")
brinquedo2 = Brinquedo("🐻")
brinquedo3 = Brinquedo("🦕")

# Imprime o número total de brinquedos na 'caixa', que é na verdade o número de instâncias criadas
print(f"Quantos brinquedos na caixa? {Brinquedo._contador_brinquedos}")

dict1 = {"a": 1, "b": 2}
dict2 = {"a": 1, "b": 3}
print(dict1 != dict2)

# Criamos dois dicionários, dict1 e dict2, que contêm pares chave-valor. 
# Um dicionário em Python é uma coleção de pares chave-valor, 
# onde cada chave é única. 
dict1 = {"a": 1, "b": 2}
dict2 = {"a": 1, "b": 3}

# Aqui, estamos comparando os dois dicionários usando o operador != 
# O operador != significa "diferente de", então ele verifica se os dois
# dicionários não são iguais.
# Python considera dois dicionários iguais se eles têm o mesmo conjunto de 
# chaves e os valores correspondentes a essas chaves também são iguais.
print(dict1 != dict2) 

# O print irá exibir True, porque os dicionários dict1 e dict2 são diferentes.
# Apesar de ambos terem as mesmas chaves ("a" e "b"), os valores associados 
# à chave "b" são diferentes (2 em dict1 e 3 em dict2).

x = ['🥦', '🥕', '🌽']
y = x[:]
y.append('🍅')
print(x)

# Inicializamos uma lista chamada 'x' que contém alguns emojis de vegetais.
x = ['🥦', '🥕', '🌽']

# Criamos uma cópia da lista 'x' usando a notação de 'slicing'.
# O '[:]' cria uma nova lista que começa no início e vai até o final da lista 'x'.
# Isso significa que 'y' é uma nova lista, e não apenas uma referência à lista 'x'.
y = x[:]

# Adicionamos um novo elemento (emoji de tomate) à lista 'y' usando o método 'append'.
# Isso modifica apenas a lista 'y' porque 'y' e 'x' são listas diferentes.
y.append('🍅')

# Imprimimos a lista 'x' para verificar seu conteúdo após a operação acima.
# Esperamos que ela ainda contenha apenas os emojis iniciais, sem o emoji de tomate.
print(x)  # Saída esperada: ['🥦', '🥕', '🌽']

from collections import deque

my_deque = deque(['a', 'b', 'c'])

my_deque.append('d')
my_deque.appendleft('z')
my_deque.pop()

print(list(my_deque))

# Importando a classe deque a partir do módulo collections.
# Deque é uma abreviação de "double-ended queue" (fila de duas pontas).
# Ela permite adicionar e remover elementos de ambas as extremidades da fila com eficiência O(1).
from collections import deque

# Criando um deque com elementos iniciais 'a', 'b', e 'c'.
my_deque = deque(['a', 'b', 'c'])

# Adicionando o elemento 'd' ao final do deque.
# O método append adiciona um item ao final da lista, similar ao método de lista padrão.
my_deque.append('d')

# Adicionando o elemento 'z' ao início do deque.
# O método appendleft é específico do deque e insere um item na posição inicial.
my_deque.appendleft('z')

# Removendo e retornando o último elemento do deque.
# O método pop remove o item localizado na extremidade direita do deque.
my_deque.pop()

# Convertendo o deque em uma lista e imprimindo os elementos.
# A função list() é usada para transformar o deque em uma lista Python padrão,
# o que é útil para visualização e operações adicionais.
print(list(my_deque))

def verificar_numeros(numeros):
    for numero in numeros:
        if numero < 0:
            print("Encontrado um número negativo:", numero)
            break
    else:
        print("Todos os números são não-negativos.")

numeros = [1, 2, 3, 4]
verificar_numeros(numeros)

# Defina uma função chamada "verificar_numeros" que recebe uma lista de números como parâmetro.
def verificar_numeros(numeros):
    # Percorre cada número na lista fornecida.
    for numero in numeros:
        # Se o número atual for menor que zero, indica que é negativo.
        if numero < 0:
            # Imprime a mensagem informando que foi encontrado um número negativo, seguido do número.
            print("Encontrado um número negativo:", numero)
            # Interrompe o loop, pois apenas precisávamos encontrar um número negativo para parar.
            break
    # O 'else' aqui é um bloco que só será executado se o loop não foi interrompido pelo 'break'.
    else:
        # Se percorrer toda a lista sem encontrar números negativos, imprime que todos são não-negativos.
        print("Todos os números são não-negativos.")

# Cria uma lista de números para testar a função.
numeros = [1, 2, 3, 4]

# Chama a função "verificar_numeros" passando a lista de números como argumento.
verificar_numeros(numeros)

def x(n):
    return n ** 2

n = [1, 2, 3, 4]
result = list(map(x, n))

print(result)

# Definindo uma função chamada 'x' que recebe um argumento 'n'
def x(n):
    # A função retorna o quadrado de 'n', ou seja, n elevado à segunda potência
    return n ** 2

# Criando uma lista chamada 'n' com alguns números inteiros
n = [1, 2, 3, 4]

# Usando a função 'map' para aplicar a função 'x' a cada elemento da lista 'n'
# 'map(x, n)' retorna um iterador que aplica a função 'x' a cada elemento de 'n'
# Convertendo o iterador em uma lista para obter os resultados
result = list(map(x, n))

# Imprimindo a lista 'result', que contém os quadrados de cada número na lista original 'n'
print(result)

list1 = ['a', 'b', 'c']
list2 = [1, 2, 3]
zipped = list(zip(list1, list2))

print(zipped)

# Definição de duas listas diferentes. 
# 'list1' é uma lista de caracteres/strings
list1 = ['a', 'b', 'c']

# 'list2' é uma lista de números inteiros
list2 = [1, 2, 3]

# A função zip() é usada para combinar elementos de duas ou mais listas.
# Ela cria pares a partir dos elementos nas mesmas posições das listas passadas.
# Aqui, estamos convertendo o objeto zip em uma lista usando list(),
# então 'zipped' conterá pares (tuplas) de elementos, um de cada lista original.
# Por exemplo, o primeiro elemento do resultado será ('a', 1).
zipped = list(zip(list1, list2))

# Imprime a lista de tuplas criada pela operação zip.
# Neste caso, o output será: [('a', 1), ('b', 2), ('c', 3)]
print(zipped)