def countdown(n):
    while n > 0:
        yield n
        n -= 1

gen = countdown(10)
print(next(gen), end = " ")
print(next(gen), end = " ")
print(next(gen), end = " ")

# Definindo uma função chamada 'countdown' que recebe um argumento 'n'
def countdown(n):
    # Enquanto 'n' for maior que zero, execute o bloco de código abaixo
    while n > 0:
        # 'yield' é usado para fazer uma pausa no estado atual da função e retornar 'n' ao chamador
        yield n
        # Subtrai 1 de 'n' em cada iteração do loop while
        n -= 1

# Aqui estamos criando um gerador 'gen' chamando a função 'countdown' com o argumento 10
gen = countdown(10)

# O gerador 'gen' não executa o código imediatamente. Ele é um objeto iterável que
# produz valores conforme necessário. Usamos a função 'next' para obter o próximo valor.

# Imprimindo o próximo valor gerado por 'gen' com 'end = " "' para manter a mesma linha
print(next(gen), end=" ")  # Esperado imprimir 10
# Imprimindo o próximo valor gerado por 'gen'
print(next(gen), end=" ")  # Esperado imprimir 9
# Imprimindo o próximo valor gerado por 'gen'
print(next(gen), end=" ")  # Esperado imprimir 8

# Se chamássemos 'next(gen)' novamente, obteríamos o próximo valor: 7, 
# e assim por diante até que o gerador fique sem valores e levante uma exceção 'StopIteration'.

print(min(max(False,-3,-4), 2,7))

# min() é uma função que retorna o menor valor entre os argumentos fornecidos.
# max() é uma função que retorna o maior valor entre os argumentos fornecidos.

# max(False, -3, -4)
# False em Python é considerado como 0 quando comparado com números inteiros.
# Portanto, max(False, -3, -4) é equivalente a max(0, -3, -4), porque o valor de False é interpretado como 0.
# max(0, -3, -4) retornará o maior valor dentre 0, -3 e -4, que é 0.

# Agora substituímos max(False, -3, -4) por 0 na expressão original:
# min(0, 2, 7)

# min(0, 2, 7)
# A função min() retorna o menor valor entre 0, 2 e 7, que é 0.

# Portanto, a expressão print(min(max(False, -3, -4), 2, 7)) vai mostrar o valor False no console.
print(min(max(False, -3, -4), 2, 7))

dict_a = {"a": 1, "b": 2}
dict_b = {"a": 1, "b": 2}

print(dict_a is dict_b)
print(dict_a == dict_b)

# Criamos dois dicionários, dict_a e dict_b.
# Um dicionário é uma coleção não ordenada de pares chave-valor.
dict_a = {"a": 1, "b": 2}
dict_b = {"a": 1, "b": 2}

# Aqui estamos usando o operador 'is' para comparar se dict_a e dict_b são o mesmo objeto na memória.
# Como dict_a e dict_b são dois objetos diferentes, mesmo que contenham os mesmos pares chave-valor,
# o resultado será False.
print(dict_a is dict_b)

# Aqui estamos usando o operador '==' para comparar se dict_a e dict_b são iguais.
# Como dict_a e dict_b têm os mesmos pares chave-valor, o resultado será True.
print(dict_a == dict_b)

num = [10, 20, 30, 40, 50]
num[1:4] = [15, 25, 35]
print(num)

# Define uma lista chamada 'num' que contém cinco elementos inteiros
num = [10, 20, 30, 40, 50]

# Aqui, estamos realizando uma atribuição de fatiamento (slice assignment)
# Os índices 1 até 3 (4 não é incluído) estão sendo substituídos por uma nova lista [15, 25, 35]
# Ou seja, a sublista [20, 30, 40] será substituída por [15, 25, 35]
# Após a operação, a lista 'num' será [10, 15, 25, 35, 50]
num[1:4] = [15, 25, 35]

# Imprime a lista 'num' atualizada no console:
print(num)

from itertools import pairwise

def gerador(lista):
    return list(pairwise(lista))

lista_numeros = [1, 2, 3, 4, 5]
print(gerador(lista_numeros))

# Importa a função pairwise do módulo itertools
from itertools import pairwise

def gerador(lista):
    # A função gerador recebe uma lista como parâmetro
    # pairwise é uma função que gera pares consecutivos dos elementos na lista
    # Convertemos o resultado de pairwise, que é um iterador, para uma lista
    resultado = list(pairwise(lista))
    # Retornamos a lista de pares consecutivos
    return resultado

# Exemplo de uso da função gerador
# Definimos uma lista de números de exemplo
lista_numeros = [1, 2, 3, 4, 5]

# Chamamos a função gerador passando lista_numeros como argumento
# e imprimimos o resultado
print(gerador(lista_numeros))

l1 = [1, 2, 3]
l2 = l1
l2.append(4)
print(l1)

# Definimos uma lista 'l1' com os elementos 1, 2 e 3
l1 = [1, 2, 3]

# Aqui, atribuimos 'l1' a 'l2'.
# Isso faz com que 'l2' e 'l1' apontem para a mesma lista na memória.
l2 = l1

# Adicionamos o número 4 à lista 'l2'.
# Como 'l2' e 'l1' apontam para o mesmo objeto na memória,
# isso significa que estamos realmente adicionando o número 4 a ambas as listas.
# Portanto, tanto 'l1' quanto 'l2' agora contêm [1, 2, 3, 4].
l2.append(4)

# Finalmente, imprimimos 'l1'.
# O resultado será [1, 2, 3, 4] porque a operação 'append' em 'l2'
# modificou a lista que 'l1' também referencia.
print(l1)

def foo(x=[]):
    x.append(1)
    return x

print(foo())
print(foo())

# Definimos uma função chamada foo que recebe um parâmetro opcional x, que por padrão é uma lista vazia.
def foo(x=[]):
    # Adicionamos o número 1 ao final da lista x.
    x.append(1)
    # Retornamos a lista x depois de adicionar o número 1.
    return x

# Chamamos a função foo sem passar nenhum argumento, então ela usa o valor padrão da lista x, que é uma lista vazia. 
# A função adiciona 1 a essa lista e a retorna, então a lista retornada e impressa é [1].
print(foo())

# Chamamos a função foo novamente sem passar nenhum argumento. 
# Agora, como a lista x foi definida no escopo da função e não é recriada a cada chamada (por causa do comportamento do parâmetro padrão mutável),
# a lista que está sendo usada ainda contém o valor anterior (ou seja, [1]).
# A função adiciona outro 1 a essa lista e a retorna, então a lista retornada e impressa é [1, 1].
print(foo())

import pandas as pd

data = {'Equipe': ['China 🇨🇳', 'França 🇫🇷', 'Austrália 🇦🇺', 'Estados Unidos 🇺🇸', 'Grã-Bretanha 🇬🇧'],
        '🥇': [16, 11, 12, 11, 10],
        '🥈': [11, 14,  7, 20, 10],
        '🥉': [ 9,  7,  5, 20, 12]}

df = pd.DataFrame(data)
df['Total'] = df['🥇'] + df['🥈'] + df['🥉']

import pandas as pd  # Importa a biblioteca pandas como pd

# Define um dicionário com os dados das equipes e suas respectivas medalhas
data = {'Equipe': ['China 🇨🇳', 'França 🇫🇷', 'Austrália 🇦🇺', 'Estados Unidos 🇺🇸', 'Grã-Bretanha 🇬🇧'],
        '🥇': [16, 11, 12, 11, 10],  # Medalhas de ouro para cada país
        '🥈': [11, 14,  7, 20, 10],  # Medalhas de prata para cada país
        '🥉': [ 9,  7,  5, 20, 12]}  # Medalhas de bronze para cada país

# Cria um DataFrame com os dados fornecidos
df = pd.DataFrame(data)

# Criamos uma nova coluna 'Total' que soma todas as colunas de medalhas para cada país.
df['Total'] = df['🥇'] + df['🥈'] + df['🥉']

# Imprime o nome da equipe que tem o maior número total de medalhas usando idxmax() para encontrar o índice
# idxmax() retorna o índice do maior valor na série df['Total']
print(df.loc[df['Total'].idxmax(), 'Equipe'])

# Alternativamente, imprime o nome da equipe que tem o maior número total de medalhas usando argmax() para encontrar o índice (identico a idxmax)
# argmax() também pode ser usado em substituição a idxmax(), ele retorna a posição do maior valor na série df['Total']
print(df.loc[df['Total'].argmax(), 'Equipe'])

# Outra forma de acessar o nome da equipe com mais medalhas, usando indexação direta através do índice fornecido por idxmax()
print(df['Equipe'][df['Total'].idxmax()])

# Imprime o total de medalhas da equipe que mais ganhou medalhas, encontrada com idxmax()
print(df.loc[df['Total'].idxmax(), 'Total'])

lista = [10, 20, 30, 40, 50, 60]
lista_fatiada = lista[1:5:2]
print(lista_fatiada)

# Define uma lista com elementos inteiros
lista = [10, 20, 30, 40, 50, 60]

# Realiza uma fatiamento/slice na lista
# lista[1:5:2] significa:
# - começando no índice 1 (20)
# - até o índice 5 (não incluindo o índice 5, ou seja, até 50)
# - pegando a cada 2 elementos
# O resultado será [20, 40]
lista_fatiada = lista[1:5:2]

# Imprime a lista fatiada
print(lista_fatiada)

result = 0
for i in range(1, 10):
    if i % 2 == 0:
        result += i

print(result)

# Inicializa a variável "result" com valor 0
result = 0

# Inicia um loop que vai de 1 até 9 (o 10 não é incluído)
for i in range(1, 10):
    # Verifica se o valor de "i" é par (ou seja, se o resto da divisão de "i" por 2 é igual a 0)
    if i % 2 == 0:
        # Se "i" for par, adiciona o valor de "i" à variável "result"
        result += i

# Imprime o valor final de "result"
print(result)