notas_alunos = {'Daniel': 85, 'Victor': 90, 'Julia': 92}
nota_anna = notas_alunos.get('Anna', 70)
print(nota_anna)

# Criamos um dicionário chamado notas_alunos que armazena nomes de alunos como chaves
# e suas respectivas notas como valores.
notas_alunos = {'Daniel': 85, 'Victor': 90, 'Julia': 92}

# Usamos o método get() para tentar obter a nota de um aluno chamado 'Anna'.
# O método get() busca o valor associado à chave fornecida ('Anna' neste caso).
# Se a chave não for encontrada no dicionário, ele retorna um valor padrão que definimos (70 aqui).
# Isso é útil para evitar erros de chave inexistente (KeyError) e fornece um valor padrão.
nota_anna = notas_alunos.get('Anna', 70)

# Mostramos o resultado da busca pela nota de Anna na tela.
# Neste caso, como 'Anna' não está no dicionário, nota_anna será 70, que é o valor padrão fornecido.
print(nota_anna)

c = {'🔴', '🟡', '🟢'}
c.discard('🔵')
print(c)

# Definindo um conjunto chamado 'c' que contém três emojis diferentes 
# Representando cores como círculos vermelhos, amarelos e verdes
c = {'🔴', '🟡', '🟢'}

# Tentativa de remover o emoji '🔵' do conjunto 'c' usando o método 'discard'
# O método 'discard' remove o item especificado do conjunto se ele estiver presente.
# Se o item não estiver no conjunto, nenhum erro será gerado.
c.discard('🔵')

# Imprimindo o conteúdo atual do conjunto 'c'
# Como '🔵' não estava presente no conjunto original, 'c' permanece inalterado
print(c)

from datetime import datetime
dt = datetime(2024, 10, 2, 14, 10, 00)
print(f"{dt:%a, %d %b %Y %H:%M:%S}")

# Importa a classe datetime do módulo datetime
# A classe datetime é usada para trabalhar com datas e horas
from datetime import datetime

# Cria um objeto datetime que representa uma data e hora específicas
# Neste caso, a data é 2 de Outubro de 2024 e a hora é 14:10:00
dt = datetime(2024, 10, 2, 14, 10, 00)

# Imprime a data e hora formatadas
# O uso da string de formato dentro do f-string personaliza a maneira como a data e hora são exibidas
# %a -> Nome abreviado do dia da semana
# %d -> Dia do mês com zero à esquerda
# %b -> Nome abreviado do mês
# %Y -> Ano com quatro dígitos
# %H -> Hora (00 a 23)
# %M -> Minuto (00 a 59)
# %S -> Segundo (00 a 59)
print(f"{dt:%a, %d %b %Y %H:%M:%S}")

x = {10, 20, 30, 40}
y = {30, 40, 50, 60}

sd = x.symmetric_difference(y)
print(sd)

# Definição de dois conjuntos (sets) de números inteiros. 
# Um conjunto em Python é uma coleção de elementos únicos e não ordenados.
x = {10, 20, 30, 40}
y = {30, 40, 50, 60}

# Calcula a diferença simétrica entre os conjuntos x e y.
# A diferença simétrica retorna um novo conjunto contendo elementos 
# que estão em x ou em y, mas não em ambos.
sd = x.symmetric_difference(y)

# Imprime o conjunto resultante da diferença simétrica.
# Neste caso, o output será {10, 20, 50, 60} pois são 
# os elementos exclusivos de cada conjunto.
print(sd)

from functools import reduce

numbers = [2, 3, 4]
p = reduce(lambda x, y: x * y, numbers)
print(p)

# Importamos a função 'reduce' do módulo 'functools'
# 'reduce' é uma função que aplica de forma cumulativa uma função binária (que toma dois argumentos) 
# a uma sequência (por exemplo, uma lista) até reduzir a sequência a um único valor.
from functools import reduce

# Definimos uma lista chamada 'numbers' que contém três números inteiros.
numbers = [2, 3, 4]

# Usamos a função 'reduce' que toma dois argumentos principais:
# 1. Uma função anônima (lambda) que multiplica dois valores 'x' e 'y'.
# 2. A lista 'numbers' sobre a qual queremos aplicar a operação.

# A função lambda aqui é: lambda x, y: x * y. Esta função indica que queremos multiplicar dois valores.

# 'reduce' vai aplicar essa função até que apenas um resultado reste.
# No primeiro passo, ele pega os dois primeiros números: 2 * 3 = 6.
# No segundo passo, ele usa o resultado anterior e o multiplica pelo próximo número: 6 * 4 = 24.
# Assim, 24 será o resultado final da redução.

p = reduce(lambda x, y: x * y, numbers)

# Finalmente, imprimimos o resultado da operação de redução
print(p)  # Isso vai imprimir '24' como resultado final

s = "InfinitePy, newsletter semanal sobre Python"
result = s[3:25:3]
result = result.upper()
print(result)

# Definindo uma string
s = "InfinitePy, newsletter semanal sobre Python"

# Extraindo uma substring da string original. 
# Aqui '[3:25:3]' significa:
# 3: Começar da quarta posição na string (lembre-se que a contagem começa em 0)
# 25: Ir até a 25ª posição da string (não inclusivo)
# 3: Pular de três em três caracteres (isto é, pegar o caractere a cada 3 posições)
result = s[3:25:3]

# Transformando a substring extraída para letras maiúsculas.
result = result.upper()

# Imprimindo o resultado final que é a substring modificada em maiúsculas.
print(result)

num = [26, 9, 2024, 52, 18, 4048]
print( all(n > 0 for n in num) )

# Lista de números inteiros
num = [26, 9, 2024, 52, 18, 4048]

# all() é uma função embutida em Python que retorna True se todos os elementos do iterável forem verdadeiros ou 
# se o iterável estiver vazio. Caso contrário, retorna False.
# No caso do iterável ser uma lista de números, como 'num', consideramos um número como "verdadeiro" se ele
# for diferente de zero (para booleanos, qualquer número diferente de zero é equivalente a True).
# Então, aqui estamos usando a função all() em um objeto gerador (generator expression), que avalia se
# todos os números na lista 'num' são maiores que zero.

# Para cada elemento 'n' na lista 'num', estamos verificando se 'n > 0'. 
# Este será o caso para todos os elementos na lista, pois todos são números positivos.
# Assim, a expressão 'all(n > 0 for n in num)' retorna True.
print(all(n > 0 for n in num))

lst = [0, 1]
[lst.append(lst[k - 1] + lst[k - 2]) for k in range(2, 5)]
print(lst)

# Inicializa uma lista 'lst' com os dois primeiros elementos da sequência de Fibonacci
lst = [0, 1]

# Esta é uma compreensão de lista que está sendo usada para iterar em um intervalo.
# Mas aqui, seu principal propósito é executar a operação de acréscimo na lista 'lst' para cada valor de 'k'.
# Normalmente, as compreensões de lista são usadas para gerar listas, mas aqui são usadas deliberadamente para modificar 'lst'.
# Iteramos em 'range(2, 5)', que gera uma sequência de números [2, 3, 4].
[lst.append(lst[k - 1] + lst[k - 2]) for k in range(2, 5)]

# Aqui está o detalhamento dentro da compreensão de lista para cada 'k':
# - Quando k = 2: lst.append(lst[1] + lst[0]) adiciona (1 + 0 = 1) a lst. Agora lst = [0, 1, 1].
# - Quando k = 3: lst.append(lst[2] + lst[1]) adiciona (1 + 1 = 2) a lst. Agora lst = [0, 1, 1, 2].
# - Quando k = 4: lst.append(lst[3] + lst[2]) adiciona (2 + 1 = 3) a lst. Agora lst = [0, 1, 1, 2, 3].

# Após a compreensão ser concluída, ela não cria nenhuma nova lista como normalmente faz.
# Em vez disso, ela executa efeitos colaterais (modificando a lista existente).

# Imprime a lista final, que agora contém os primeiros cinco números de Fibonacci: [0, 1, 1, 2, 3]
print(lst)

lst = [10]
lst_iter = iter(lst)
print(next(lst_iter))

# Defina uma lista chamada `lst` com três elementos numéricos. Observe o erro aqui no seu código original.
# A lista deve ser definida com vírgulas entre os elementos:
lst = [10, 20, 30] # Uma lista de inteiros

# Crie um objeto iterador da lista `lst` usando a função `iter()`.
# Um iterador é um objeto que permite que você percorra todos os elementos de uma coleção (como uma lista), um de cada vez.
lst_iter = iter(lst) # Criando um iterador para a lista

# Use a função `next()` para recuperar o próximo item do iterador `lst_iter`.
# Neste contexto, `next()` retornará o primeiro elemento da lista porque o iterador está atualmente posicionado no início.
# Chamadas subsequentes para `next(lst_iter)` retornariam o segundo, terceiro elementos e assim por diante, até esgotar a lista.
# Se você chamar `next(lst_iter)` mais vezes do que há elementos na lista, isso gerará uma exceção 'StopIteration'.
print(next(lst_iter)) # Imprima o primeiro item do iterador, que é `10`

x = {10, 20, 30, 40}
y = {30, 40, 50, 60}

r1 = x.intersection(y)
print(r1)

# Defina um conjunto 'x' com quatro elementos: 10, 20, 30 e 40
x = {10, 20, 30, 40}

# Defina outro conjunto 'y' com quatro elementos: 30, 40, 50 e 60
y = {30, 40, 50, 60}

# Usa o método 'intersection' do conjunto 'x' para encontrar elementos comuns aos dois conjuntos 'x' e 'y'
# O método intersection retorna um novo conjunto contendo elementos que aparecem em x e y
r1 = x.intersection(y) 

# Imprime o conjunto resultante 'r1' que deve conter os elementos que são comuns em ambos os conjuntos 
print(r1) # Saída esperada: {30, 40}

# Análise adicional do processo de interseção: 
# 1. Observe cada elemento em 'x': 10, 20, 30, 40 
# 2. Verifique se esses elementos também estão em 'y': 30, 40, 50, 60 
# 3. Os elementos que aparecem em ambos os conjuntos são 30 e 40 
# 4. O método de intersecção captura esses elementos comuns e 'r1' armazena o resultado: {30 , 40}

x = {'a' : 10, 'b' : 20}
y = {'b' : 30, 'c' : 40}

z = {**x, **y}
print(z)

# Aqui temos dois dicionários, x e y, cada um com pares chave-valor.
x = {'a': 10, 'b': 20}  # Dicionário x: contém as chaves 'a' e 'b' com os valores 10 e 20, respectivamente.
y = {'b': 30, 'c': 40}  # Dicionário y: contém as chaves 'b' e 'c' com os valores 30 e 40, respectivamente.

# A sintaxe {**x, **y} é uma maneira de realizar o "merge" (união) de dois dicionários.
# Vamos explicar o que isso faz:
# - **x descompacta o dicionário x e inclui todos seus pares chave-valor no novo dicionário.
# - **y descompacta o dicionário y e inclui seus pares chave-valor no novo dicionário resultante.
# - Se houver chaves repetidas entre x e y, o valor da chave no dicionário y substituirá o valor da chave do dicionário x.

z = {**x, **y}  # Aqui, criamos um novo dicionário chamado z que resulta da união dos dicionários x e y.

# Após a união:
# z = {'a': 10, 'b': 30, 'c': 40}
# A chave 'b' existente em x teve seu valor (20) substituído pelo valor correspondente em y (30),
# pois em casos de conflito, o último dicionário passado ganha, neste caso, y.

print(z)  # Exibe o dicionário resultante para o usuário
# Saída: {'a': 10, 'b': 30, 'c': 40}

frutas = ['limão', 'maçã', 'banana', 'laranja']
((x, *y), *z) = frutas
print(y)

# Lista de frutas
frutas = ['limão', 'maçã', 'banana', 'laranja']

# Descompactando a lista 'frutas'
# Especificamente, está alocando elementos da lista para variáveis ​​(x, *y):
# Esta parte da expressão receberá o primeiro valor da lista 'frutas'.
# Então, a primeira letra do elemento será atribuída a x, e as letras subsequentes serão compactadas em uma lista e atribuídas a y.
# *z: Isso está fora da tupla e receberá quaisquer elementos restantes da lista 'fruits'.
((x, *y), *z) = frutas

# Imprima os valores armazenados em y. A saída esperada é ['i', 'm', 'ã', 'o']
print(y)

lst = [1, 3, 5, 7, 9, 11, 13, 15]
print(lst[::-2])

# Inicialize uma lista `lst` com uma série de inteiros ímpares de 1 a 15.
lst = [1, 3, 5, 7, 9, 11, 13, 15]

# Imprima uma versão fatiada da lista `lst`, mas na ordem inversa.
# A fatia `[::-2]` pode ser dividida da seguinte forma:
# - `:` antes dos primeiros dois pontos significa incluir todos os elementos do início.
# - `:` depois dos segundos dois pontos significa incluir todos os elementos até o fim.
# - `-2` é o valor do passo, o que significa pegar cada segundo elemento, movendo para trás.
# Portanto, `[::-2]` significa: começar do fim da lista, mover para a esquerda em 2 passos
# a cada vez e coletar os elementos dessa forma até que o início da lista seja alcançado.
print(lst[::-2])