def potencia(n):
    return n ** n

resultado = map(potencia, [1, 2, 3])
print(list(resultado))

# Definindo uma função chamada 'potencia' que recebe um único argumento 'n'.
def potencia(n):
    # A função retorna o valor de 'n' elevado à 'n', ou seja, n^n.
    return n ** n

# Utilizamos a função 'map' para aplicar a função 'potencia' a cada elemento na lista [1, 2, 3].
# 'map' retorna um iterador que aplica a função passada como primeiro argumento ('potencia')
# a cada item da sequência fornecida como segundo argumento ([1, 2, 3]).
resultado = map(potencia, [1, 2, 3])

# Convertemos o iterador 'resultado' em uma lista usando 'list()' para que possamos ver os resultados finais.
print(list(resultado))  # Exibe a lista resultante da aplicação de 'potencia': [1, 4, 27]

preco_frutas = {}
preco_frutas[['maçã', 'banana']] = 3.99
print(preco_frutas)

# Criando um dicionário vazio chamado preco_frutas
preco_frutas = {}

# Aqui estamos tentando usar uma lista ['maçã', 'banana'] como chave em um dicionário.
# Dicionários em Python exigem que as chaves sejam de um tipo "hashable", como strings ou números.
# Listas não são "hashable" porque são mutáveis (seus valores podem ser alterados).
# Isso vai gerar um erro do tipo 'TypeError'.
preco_frutas[['maçã', 'banana']] = 3.99

# Tentar imprimir o dicionário não será executado, pois o erro acima impede que esta linha seja alcançada.
print(preco_frutas)

# Inicializando um dicionário vazio para armazenar o preço das frutas
preco_frutas = {}

# Adicionamos um par "chave: valor" ao dicionário
# Neste caso, "maçã" e "banana" são as chaves individuais associadas ao seu preço
preco_frutas['maçã'] = 3.99  # Definindo o preço da maçã como 3.99
preco_frutas['banana'] = 3.99  # Adicionando o preço da banana como 3.99 para exemplo

# Imprimindo o dicionário com os preços das frutas
print(preco_frutas)

nl = [1, 2, [3, 4], [5, [6, 7]], 8]
print(nl[3][1][1])

# Definimos uma lista chamada 'nl' que contém múltiplos tipos de elementos:
# 1. O número inteiro 1
# 2. O número inteiro 2
# 3. Outra lista contendo os números 3 e 4
# 4. Outra lista que contém:
#    - O número 5
#    - Uma lista interna que contém os números 6 e 7
# 5. Finalmente, o número inteiro 8
nl = [1, 2, [3, 4], [5, [6, 7]], 8]

# Vamos então acessar um elemento específico dentro dessa estrutura aninhada.
# Primeiramente, nl[3] acessa o quarto elemento da lista principal 'nl', que é a sublista [5, [6, 7]]
# Dentro desta sublista, nl[3][1] acessa o segundo elemento, que é outra lista [6, 7]
# Finalmente, nl[3][1][1] acessa o segundo elemento dessa lista interna, que é 7
print(nl[3][1][1])  # Este comando irá imprimir o valor '7' na tela

r = int(3.5) + int("4")
print(r)

# Este código realiza uma operação de soma usando dois valores que são convertidos para inteiros.

# Primeiro, convertemos o número de ponto flutuante 3.5 para um inteiro.
# A função int() truncará o valor 3.5 para 3, descartando a parte decimal.
primeiro_numero = int(3.5)

# Em seguida, convertemos a string "4" para um inteiro.
# A função int() também pode converter strings que representam números inteiros para inteiros.
segundo_numero = int("4")

# Agora somamos os dois inteiros que obtivemos.
# Como resultado, a soma será 3 (do primeiro número) + 4 (do segundo número) = 7.
r = primeiro_numero + segundo_numero

# Por fim, exibimos o resultado da soma.
# O print() irá imprimir o valor de r, que é 7.
print(r)

texto = "python"
texto[0] = 'P'
print(texto)

# Inicializamos uma variável chamada 'texto' com a string 'python'.
texto = "python"

# Tentamos modificar o primeiro caractere da string de 'p' para 'P'.
# Esse comando tentará alterar diretamente a string.
# No entanto, precisamos lembrar que strings em Python são imutáveis,
# o que significa que, uma vez criadas, seus valores não podem ser alterados.
# Portanto, essa linha de código causará um erro: TypeError: 'str' object does not support item assignment.
texto[0] = 'P'

# Este comando está tentando imprimir o valor de 'texto'.
# No entanto, devido à linha anterior (texto[0] = 'P'), esta linha não será executada
# porque o programa já terá terminado com um erro.
print(texto)

a = 10
b = a
a += 5

print(a, b)

# Atribui o valor 10 à variável 'a'
a = 10

# Atribui o valor da variável 'a' (que é 10) à variável 'b'
b = a

# Incrementa o valor da variável 'a' em 5.
# Isso é equivalente a a = a + 5.
# Agora, 'a' passa a ter o valor 15.
a += 5

# Imprime os valores das variáveis 'a' e 'b'.
# Esperamos que 'a' seja 15 e 'b' seja 10.
print(a, b)

frutas = {'🍎', '🍌', '🍒', '🍉', '🍏'}
print( '🍉' in frutas)

# Criamos um conjunto chamado 'frutas' que contém emojis de diferentes frutas.
# Conjuntos em Python são coleções não ordenadas de elementos únicos.
frutas = {'🍎', '🍌', '🍒', '🍉', '🍏'}

# Aqui, estamos verificando se o emoji da melancia '🍉' está presente no conjunto 'frutas'.
# O operador 'in' retorna True se o elemento estiver presente no conjunto e False caso contrário.
print('🍉' in frutas)  # Espera-se que imprima True porque '🍉' está dentro do conjunto 'frutas'.

lfuc = lambda x: x + 10
print(lfuc(7))

# Definindo uma função lambda. Em Python, uma função lambda é uma pequena função anônima.
# A palavra-chave 'lambda' cria funções que consistem em uma única expressão.
# A sintaxe geral é: lambda argumentos: expressão

# Aqui, 'lfuc' é uma variável que armazena a função lambda.
# Essa função recebe um argumento, 'x', e retorna o resultado da expressão 'x + 10'.
lfuc = lambda x: x + 10

# Usamos 'print' para exibir o resultado da função lambda quando chamada com o argumento 7.
# Quando lfuc(7) é avaliado, a função lambda calcula 7 + 10.
print(lfuc(7))  # Esperamos que esta linha imprima 17

# Resumo:
# - 'lambda x: x + 10' é uma função anônima que soma 10 ao seu argumento.
# - 'lfuc(7)' chama essa função com 7 como o argumento, então o resultado é 17.

import logging

logging.basicConfig(level=logging.WARNING)

logging.debug("Esta é uma mensagem de depuração.")
logging.info("Esta é uma mensagem informativa.")
logging.warning("Esta é uma mensagem de aviso.")
logging.error("Esta é uma mensagem de erro.")
logging.critical("Esta é uma mensagem crítica.")

# Importa o módulo de logging do Python, que é usado para registrar mensagens de log.
import logging

# Configura o sistema de registro de logs para definir o nível mínimo de mensagens que serão exibidas.
# Neste caso, o nível é configurado para WARNING (aviso).
# Os níveis de log em ordem crescente de importância são: DEBUG, INFO, WARNING, ERROR, CRITICAL.
# Somente mensagens com nível WARNING ou superior serão mostradas.
logging.basicConfig(level=logging.WARNING)

# Tenta registrar uma mensagem de depuração.
# Mensagens de depuração são detalhadas e geralmente usadas para diagnosticar problemas.
# Como o nível atual é WARNING, esta mensagem não será exibida.
logging.debug("Esta é uma mensagem de depuração.")

# Tenta registrar uma mensagem informativa.
# Mensagens informativas dão detalhes gerais sobre o funcionamento da aplicação.
# Esta mensagem também não será exibida porque o nível atual é WARNING.
logging.info("Esta é uma mensagem informativa.")

# Registra uma mensagem de aviso.
# Mensagens de aviso indicam potenciais problemas que não impedem o funcionamento do programa.
# Como esta é uma mensagem de nível WARNING, ela será exibida no console.
logging.warning("Esta é uma mensagem de aviso.")

# Registra uma mensagem de erro.
# Mensagens de erro indicam falhas que impedem uma parte do programa de ser executada.
# Esta mensagem será exibida porque ERROR é superior a WARNING.
logging.error("Esta é uma mensagem de erro.")

# Registra uma mensagem crítica.
# Mensagens críticas indicam erros severos que podem fazer o programa parar.
# Esta mensagem será exibida porque CRITICAL é superior a WARNING.
logging.critical("Esta é uma mensagem crítica.")

import numpy as np
arr = np.arange(10)
print(arr[::2])

# Importando a biblioteca NumPy, uma biblioteca popular para operações numéricas em Python
import numpy as np

# Usando a função arange do NumPy para criar um array unidimensional
# A função np.arange(10) gera uma sequência de números de 0 a 9
arr = np.arange(10)

# Imprimindo elementos do array 'arr' usando slicing
# Slicing [::2] significa começar do início até o final do array,
# mas pulando a cada dois elementos. O primeiro ":" indica que começamos do início
# até o final (ou podemos especificar um range como 1:10, por exemplo),
# e o "2" indica o passo ou intervalo
print(arr[::2])

import numpy as np
arr = np.zeros((2, 2))
print(np.sum(arr))

# Importamos o módulo numpy, que é uma biblioteca poderosa para manipulação de arrays e matrizes
import numpy as np

# Criamos uma matriz 2x2 preenchida com zeros.
# A função np.zeros((2, 2)) cria um array bidimensional (2D) com 2 linhas e 2 colunas, onde todos os elementos são inicializados com o valor zero.
arr = np.zeros((2, 2))

# Calculamos a soma de todos os elementos da matriz usando a função np.sum().
# Como nossa matriz só contém zeros, o resultado da soma será 0.
# np.sum(arr) itera sobre todos os elementos do array 'arr' e calcula o total.
print(np.sum(arr))

import numpy as np
arr = np.array([1, 2, 3, 4, 5])
print(arr.shape)

# Importa a biblioteca numpy e a atribui ao alias 'np'.
# O NumPy é uma poderosa biblioteca para computação numérica em Python.
# Ela fornece suporte para arrays e matrizes, e contém uma coleção de funções matemáticas de alto nível.
import numpy as np

# Cria um array do NumPy a partir de uma lista de números inteiros [1, 2, 3, 4, 5].
# O NumPy oferece a capacidade de criar arrays, que são mais eficientes do que as listas do Python para muitas operações
# devido à sua alocação de memória contígua e operação vetorizada.
arr = np.array([1, 2, 3, 4, 5])

# Imprime a forma (shape) do array 'arr'.
# A forma de um array descreve quantos elementos ele possui em cada dimensão.
# Neste caso, 'arr' é um array unidimensional com 5 elementos, logo, sua shape será (5,).
print(arr.shape)