l = ['a', 'b', 'c', 'd']
d = {k: [] for k in l}
d['b'].append(2)

print(d)

# Iniciamos uma lista chamada 'l' que contém quatro elementos de caracteres.
l = ['a', 'b', 'c', 'd']

# Usamos uma compreensão de dicionário para criar um dicionário chamado 'd'.
# A compreensão de dicionário percorre cada elemento em 'l' e
# cria pares chave-valor para o dicionário 'd'.
# Cada chave é um elemento da lista 'l', e o valor associado a cada chave é uma lista vazia.
d = {k: [] for k in l}

# A linha acima é equivalente a:
# d = {
#     'a': [],
#     'b': [],
#     'c': [],
#     'd': []
# }

# Aqui, fazemos uma operação específica no dicionário 'd'.
# Acessamos a chave 'b' e usamos o método 'append' para adicionar o número 2
# à lista associada à chave 'b'. Agora, a chave 'b' tem o valor de uma lista
# contendo um único elemento: 2.
d['b'].append(2)

# Finalmente, imprimimos o dicionário 'd'. Nesse ponto, 'd' parece com isto:
# {
#     'a': [],
#     'b': [2],
#     'c': [],
#     'd': []
# }
print(d)

import itertools

list1 = [1, 2]
list2 = ['a', 'b']
result = list(itertools.product(list1, list2))
print(result)

# Importamos o módulo itertools, que fornece várias funções que trabalham com iteradores para produzir iteráveis complexos
import itertools

# Definimos a primeira lista de elementos numéricos
list1 = [1, 2]

# Definimos a segunda lista de elementos de caracteres
list2 = ['a', 'b']

# Utilizamos a função product do módulo itertools para criar o produto cartesiano das duas listas
# O produto cartesiano é uma combinação de todos os elementos de list1 com todos os elementos de list2
# Por exemplo, se list1 = [1, 2] e list2 = ['a', 'b'], o produto cartesiano será:
# [(1, 'a'), (1, 'b'), (2, 'a'), (2, 'b')]
#
# Convertemos o objeto retornado pelo itertools.product (que é um iterador) em uma lista para
# facilitar a visualização e manipulação dos dados
result = list(itertools.product(list1, list2))

# Finalmente, imprimimos o resultado do produto cartesiano
print(result)

def foo():
    try:
        return 1
    finally:
        return 2

k = foo()
print(k)

# Definimos a função chamada 'foo'. Esta função não recebe parâmetros.
def foo():
    # Iniciamos um bloco 'try'. 'Try' é usado para testar um bloco de código quanto a erros.
    try:
        # Este é o valor que gostaríamos de retornar inicialmente da função.
        return 1
    # 'finally' é um bloco que sempre será executado, independente se ocorreu uma exceção ou não no 'try'.
    finally:
        # O valor no bloco 'finally' está substituindo o valor do 'try'. O Python sempre executa
        # o bloco 'finally', então o 'return 2' aqui substitui o 'return 1' do 'try'.
        return 2

# Aqui, chamamos a função 'foo' e armazenamos o valor retornado na variável 'k'.
k = foo()

# Imprimimos o valor de 'k', que será 2, porque o 'finally' sobrepõe o valor de retorno inicial do 'try'.
print(k)

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

print(x, y)

# Definimos uma tupla `x` contendo dois elementos, 1 e 2.
# Lembre-se de que as tuplas são imutáveis, ou seja, seus valores não podem ser alterados após a criação.
x = (1, 2)

# Aqui, criamos uma nova referência `y` que aponta para a mesma tupla que `x`.
# Isto significa que, inicialmente, `x` e `y` são essencialmente iguais, apontando para o mesmo objeto na memória.
y = x

# Agora, usamos o operador de adição aumentada `+=` para adicionar outra tupla `(3, 4)` a `y`.
# Isso NÃO altera a tupla original apontada por `y`, mas cria uma NOVA tupla `(1, 2, 3, 4)`.
# Por ser imutável, uma nova tupla deve ser criada sempre que algum tipo de modificação é feito.
y += (3, 4)

# Exibimos os valores de `x` e `y`.
# `x` ainda manterá a tupla original `(1, 2)`, pois `x` e `y` não compartilham mais a mesma tupla (após o `+=`).
# `y`, por outro lado, será `(1, 2, 3, 4)`, pois a operação `+=` fez `y` apontar para o novo objeto.
print(x, y)  # Saída será: (1, 2) (1, 2, 3, 4)

x = {'a': 10, 'b': 20}
y = {'b': 30, 'c': 40}
x.update(y)
print(x)

# Inicializando um dicionário chamado 'x' com duas chaves: 'a' e 'b'.
# 'a' está associada ao valor 10, e 'b' ao valor 20.
x = {'a': 10, 'b': 20}

# Inicializando outro dicionário chamado 'y' com duas chaves: 'b' e 'c'.
# 'b' está associada ao valor 30, e 'c' ao valor 40.
y = {'b': 30, 'c': 40}

# Utilizando o método 'update' do dicionário 'x'.
# O método update() atualiza 'x' com os pares chave-valor de 'y'.
# Se uma chave em 'y' já existe em 'x', como a chave 'b' neste exemplo, 
# o valor dessa chave em 'x' será atualizado com o valor de 'y'.
# Isso significa que o valor de 'b' em 'x' será alterado de 20 para 30.
# As chaves que existem em 'y' mas não em 'x', como 'c',
# serão adicionadas ao dicionário 'x' junto com seus valores.
x.update(y)

# Imprimindo o dicionário 'x' após a atualização.
# O output esperado será {'a': 10, 'b': 30, 'c': 40}.
# Isso porque 'b' foi atualizado e 'c' foi adicionado.
print(x)

from functools import reduce

num = [5, 10, 20]
r = reduce(lambda x, y: x * y, num)
print(r)

# `reduce` é uma função do módulo `functools` que importamos aqui
# `reduce` aplica uma função binária aos itens de uma sequência (como uma lista)
# da esquerda para a direita para reduzir a sequência a um único valor acumulado.
from functools import reduce

# `num` é uma lista contendo três elementos inteiros: 5, 10 e 20.
num = [5, 10, 20]

# A função `reduce` é usada aqui para executar uma operação cumulativa na lista `num`.
# Ela recebe uma função lambda e um iterável (nossa lista `num`) como argumentos.
# A função lambda `lambda x, y: x * y` define uma função anônima que multiplica dois números.
# Veja como funciona: `reduce` pegará os dois primeiros elementos, 5 e 10, multiplicará para obter 50.
# Então, pegará esse resultado, 50, e multiplicará pelo próximo elemento, 20, para obter 1000.
# Então, todo o processo de redução pode ser visualizado como: 5 * 10 * 20 = 1000.
r = reduce(lambda x, y: x * y, num)

# `print(r)` gera o resultado da operação `reduce` para o console.
# Nesse caso, ele imprimirá `1000`, que é o produto de todos os números na lista.
print(r)

lst = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
r = lst[-5:-1]
print(r)

# Define uma lista chamada 'lst' contendo elementos de 'a' a 'h'
lst = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']

# Fatia a lista 'lst' para incluir elementos começando do 5º último elemento até o segundo último elemento
# Explicação da indexação:
# Em Python, índices negativos são usados ​​para especificar posições do final de uma lista.
# -1 se refere ao último elemento, -2 ao segundo último e assim por diante.
# Portanto, `-5` se refere ao 5º elemento do final e `-1` se refere ao elemento imediatamente anterior ao último.

# A sintaxe de fatiamento de lista lst[start:end] busca elementos do índice 'start' até, mas NÃO incluindo, o índice 'end'.
r = lst[-5:-1]

# Agora 'r' armazenará a sublista de 'lst' que consiste em elementos:
# Começa no índice -5: 'd' (já que lst[-5] se refere a 'd')
# Termina antes do índice -1: 'g' (já que lst[-1] se refere a 'h' e não está incluído)
# Portanto, 'r' conterá ['d', 'e', ​​'f', 'g']

# Imprime a lista fatiada 'r'
print(r)

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

# Defina um conjunto chamado 'c' contendo três elementos emoji Unicode diferentes.
# Conjuntos são coleções que não são ordenadas, mutáveis ​​e não têm elementos duplicados.
c = {'🔴', '🟡', '🟢'}

# Tenta remover o elemento '🔵' do conjunto 'c'.
# O método `remove()` remove o elemento especificado do conjunto.
# Se o elemento especificado não existir no conjunto, o método `remove()` levantará um KeyError.
# Neste caso, '🔵' não é um elemento do conjunto 'c', então esta linha causará um KeyError.
c.remove('🔵')

# Imprima o conteúdo do conjunto 'c'.
# No entanto, devido ao KeyError levantado na etapa anterior, esta linha não será executada.
print(c)

from collections import defaultdict

int_dict = defaultdict(int)
int_dict['c'] += 1
result = int_dict['c']

print(result)

# Importa a classe defaultdict do módulo collections.
# defaultdict é uma subclasse do dicionário padrão do Python que retorna um valor padrão para uma chave inexistente.
from collections import defaultdict

# Cria um defaultdict que tem como valor padrão o tipo int.
# Se uma chave não existir no dicionário, ela será criada automaticamente e atribuída ao valor padrão, que é 0 para int.
int_dict = defaultdict(int)

# Incrementa o valor associado à chave 'c' no dicionário int_dict por 1.
# Se a chave 'c' ainda não existir, ela será criada automaticamente com o valor padrão 0, e em seguida incrementada para 1.
int_dict['c'] += 1

# Atribui o valor associado à chave 'c' do dicionário int_dict à variável result.
# Neste ponto, o valor de 'c' será 1, pois foi incrementado no passo anterior.
result = int_dict['c']

# Imprime o resultado no console.
# Espera-se que o valor impresso seja 1.
print(result)

import numpy as np
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
c = a + b
print(c)

# Importa a biblioteca NumPy, que é amplamente utilizada para operações matemáticas em arrays e matrizes.
import numpy as np

# Cria um array NumPy chamado 'a' com três elementos: 1, 2 e 3.
# Arrays NumPy são similares às listas do Python, porém mais eficientes para operações numéricas.
a = np.array([1, 2, 3])

# Cria um segundo array NumPy chamado 'b' com três elementos: 4, 5 e 6.
b = np.array([4, 5, 6])

# Realiza a adição dos arrays 'a' e 'b'.
# O NumPy permite operações aritméticas elemento a elemento entre arrays de mesmo tamanho.
# Neste caso, 'c' será um novo array onde cada elemento é a soma dos elementos correspondentes de 'a' e 'b'.
c = a + b

# Imprime o resultado da soma dos arrays 'a' e 'b'.
# Espera-se que a saída seja um array [5, 7, 9] porque:
# 1 + 4 = 5
# 2 + 5 = 7
# 3 + 6 = 9
print(c)

n = [5, 10, 15, 20, 25, 30]
fn = list(filter(lambda x: x > 15, n))
print(fn)

# Lista inicial de números inteiros
n = [5, 10, 15, 20, 25, 30]

# A função filter() é usada para criar uma lista de elementos que atendem a uma determinada condição.
# Aqui usamos a função lambda (uma pequena função anônima) para definir a condição
# A condição é que x (cada elemento da lista n) deve ser maior que 15
# A função lambda x: x > 15 retorna True para valores maiores que 15, e False caso contrário
# Somente os elementos que retornam True são mantidos na nova lista
fn = list(filter(lambda x: x > 15, n))

# A função filter() retorna um objeto filter, que precisa ser convertido para uma lista
# usando a função list(), para podermos ver os resultados como uma lista de Python normal
# Portanto, fn agora contém apenas os valores de n que são maiores que 15

# Por fim, imprimimos o resultado
print(fn)  # Saída: [20, 25, 30]

def minha_funcao(lst):
    lst.append(4)

lista = [1, 2, 3]
minha_funcao(lista)

print(lista)

# Definimos uma função chamada 'minha_funcao' que recebe um parâmetro chamado 'lst'.
# Este parâmetro espera receber uma lista.
def minha_funcao(lst):
    # Utilizamos o método 'append' para adicionar o número 4 ao final da lista fornecida.
    lst.append(4)

# Criamos uma lista chamada 'lista' que contém os elementos 1, 2 e 3.
lista = [1, 2, 3]

# Chamamos a função 'minha_funcao' passando a 'lista' como argumento.
# Após essa chamada, a lista original será modificada, pois listas são objetos mutáveis.
minha_funcao(lista)

# Usamos a função 'print' para exibir o conteúdo da lista após a chamada da função.
# Esperamos que a lista agora contenha os elementos 1, 2, 3, e 4, nesta ordem.
print(lista)

s = ["newsletter", "sobre", "Python"]
sentenca = "-".join(s)
print(sentenca)

# Criamos uma lista de strings com o nome 's'
s = ["newsletter", "sobre", "Python"]

# Usamos o método 'join' para concatenar as strings dentro da lista 's'
# O método 'join' pega cada elemento da lista e os junta em uma única string, 
# usando o delimitador especificado, que neste caso é o hífen "-"
# Portanto, cada elemento da lista será separado por um hífen na string final
sentenca = "-".join(s)

# Usamos a função 'print' para mostrar a saída no console
print(sentenca)