{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"id": "bsX7qzeTwOwc"
},
"source": [
"# Capítulo 5: Funções e Modularização"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Definindo Funções\n",
"\n",
"**🎙️ Ouça a explicação sobre condicionais (if-elif-else):** \n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"Funções são blocos de código (subprogramas) reutilizáveis que executam tarefas específicas e são essenciais para a estruturação de programas em Python. Elas permitem modularizar seu código, tornando-o mais gerenciável, legível e fácil de manter. Neste capítulo, exploraremos os conceitos essenciais sobre funções, incluindo diferentes tipos de funções e boas práticas de utilização.\n",
"\n",
"Para definir uma função, utilizamos a palavra reservada `def`. A estrutura básica de uma função inclui:\n",
"\n",
"- **Palavra-chave `def`:** Indica o início da definição de uma função.\n",
"- **Nome da função:** Deve ser descritivo e seguir as convenções de nomenclatura de Python, conforme descrito na [PEP 8](https://peps.python.org/pep-0008/). Use letras minúsculas com palavras separadas por underscores (convenção snake_case).\n",
"- **Parênteses `()`** contendo os **parâmetros** (se houver) separados por vírgulas.\n",
"- **Dois pontos `:`** para terminar a linha de cabeçalho.\n",
"- **Bloco de código indentado** que constitui o corpo da função.\n",
"- **(Opcional) `return`** para retornar um valor da função. Se omitido, a função retorna `None` por padrão.\n",
"\n",
"\n",
"**Exemplo** simples de uma função para calcular e retornar a soma de dois números.\n",
"\n",
"
\n",
" \n",
" Figura: Fluxo dos dados em uma função\n",
"
\n",
"\n",
"\n",
"Compare o fluxo dos dados com a função real abaixo:\n",
"```python\n",
"def soma2(parametro1, parametro2):\n",
" resultado = parametro1 + parametro2\n",
" return resultado \n",
"\n",
"# Chamando a função\n",
"resultado = soma2(3, 4)\n",
"print(resultado)\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"7\n",
"```\n",
"\n",
"### Docstrings e Type Hints\n",
"\n",
"Antes de avançar no uso de funções em Python, é importante conhecer **docstrings** e **type hints**. Essas práticas são recomendadas para tornar o código mais claro, documentado e fácil de usar.\n",
"\n",
"- **Docstrings** são strings de documentação que ficam logo após a definição de uma função, classe ou módulo. Elas descrevem o que a função faz, explicam os parâmetros e informam o valor de retorno. Isso melhora a compreensão do código e permite que ferramentas de documentação capturem essas informações automaticamente. As docstrings também aparecem quando usamos a função `help` no Python, facilitando o acesso às informações sobre a função sem precisar ler o código fonte.\n",
"\n",
" **Exemplo de docstring:**\n",
"\n",
" ```python\n",
" def saudacao(nome):\n",
" \"\"\"\n",
" Exibe uma saudação personalizada para o usuário.\n",
"\n",
" Args:\n",
" nome: O nome da pessoa a ser saudada.\n",
" \n",
" Retorna:\n",
" None.\n",
" \"\"\"\n",
" print(f\"Olá, {nome}!\")\n",
" ```\n",
"\n",
" Aqui, a docstring explica o propósito da função `saudacao`, descreve o parâmetro `nome` e informa que o valor de retorno é `None`. Para ver essa docstring em ação, podemos chamar `help(saudacao)` no console, e o Python exibirá a explicação, o que é muito útil para quem estiver usando ou revisando o código.\n",
"\n",
"- **Type hints** (ou anotações de tipo) permitem especificar os tipos esperados dos parâmetros e do valor de retorno de uma função. Isso melhora a legibilidade, ajuda na identificação de inconsistências de tipo e facilita o uso de ferramentas que verificam tipos.\n",
"\n",
" **Exemplo de docstring e type hints:**\n",
"\n",
" ```python\n",
" def soma(a: float, b: float) -> float:\n",
" \"\"\"\n",
" Calcula a soma de dois números.\n",
"\n",
" Args:\n",
" a (float): Primeiro número.\n",
" b (float): Segundo número.\n",
" \n",
" Retorna:\n",
" float: A soma de 'a' e 'b'.\n",
" \"\"\"\n",
" return a + b\n",
" ```\n",
"\n",
" Neste exemplo, estamos indicando que `a` e `b` devem ser `float`, e que a função `soma` retorna um valor `float`. Usando `help(soma)`, você verá a docstring com os detalhes dos parâmetros e do retorno.\n",
"\n",
"\n",
"### Funções sem Retorno (Procedimentos)\n",
"\n",
"Uma função sem retorno, também conhecida como procedimento, é um bloco de código que executa uma tarefa específica, mas não retorna nenhum valor explicitamente (retorna `None` implicitamente). É útil quando você deseja realizar uma ação ou exibir informações sem a necessidade de obter um resultado para uso posterior.\n",
"\n",
"**Exemplo:**\n",
"\n",
"```python\n",
"def saudacao(nome_pessoa: str) -> None:\n",
" \"\"\"\n",
" Exibe uma saudação personalizada.\n",
" \n",
" Args:\n",
" nome_pessoa: Nome da pessoa a ser saudada.\n",
" \"\"\"\n",
" print(f\"Olá, {nome_pessoa}!\")\n",
"\n",
"# Chamando a função\n",
"saudacao(\"Aurora\")\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"Olá, Aurora!\n",
"```\n",
"\n",
"Observe o uso de type hints (`str` e `None`) no exemplo acima. Eles ajudam a documentar os tipos esperados dos parâmetros e do retorno da função, tornando o código mais claro e facilitando a detecção de erros.\n",
"\n",
"### Funções com Retorno\n",
"\n",
"Funções com retorno são aquelas que devolvem um valor para a parte do código que as chamou. Esse valor pode ser atribuído a variáveis ou usado em cálculos adicionais. Abaixo, apresentamos um exemplo sem valor padrão e, em seguida, um exemplo que utiliza **type hints** e um valor padrão.\n",
"\n",
"**Exemplo sem Valor Padrão:**\n",
"\n",
"```python\n",
"def soma(a: float, b: float) -> float:\n",
" \"\"\"\n",
" Calcula a soma de dois números.\n",
" \n",
" Args:\n",
" a: Primeiro número a ser somado.\n",
" b: Segundo número a ser somado.\n",
" \n",
" Retorna:\n",
" A soma dos valores 'a' e 'b'.\n",
" \"\"\"\n",
" return a + b\n",
"\n",
"# Chamando a função com argumentos\n",
"resultado = soma(3.5, 5.0)\n",
"print(f\"Resultado: {resultado}\")\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"Resultado: 8.5\n",
"```\n",
"\n",
"**Exemplo com Type Hints e Valor Padrão:**\n",
"\n",
"```python\n",
"def somaP(a: float, b: float = 0.0) -> float:\n",
" \"\"\"\n",
" Calcula a soma de dois números.\n",
"\n",
" Args:\n",
" a: Primeiro número a ser somado.\n",
" b: Segundo número a ser somado, padrão é 0.0.\n",
" \n",
" Retorna:\n",
" A soma dos valores 'a' e 'b'.\n",
" \"\"\"\n",
" return a + b\n",
"\n",
"# Chamando a função com diferentes argumentos\n",
"resultado1 = somaP(3.5, 5.0) # Dois argumentos\n",
"resultado2 = somaP(3.5) # Usando o valor padrão de b\n",
"print(f\"Resultados: {resultado1}, {resultado2}\")\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"Resultados: 8.5, 3.5\n",
"```\n",
"\n",
"No segundo exemplo, `b` tem um valor padrão de `0.0`, o que permite chamar a função apenas com o primeiro argumento. Isso demonstra como o uso de type hints e valores padrão facilita a flexibilidade e a clareza do código.\n",
"\n",
"\n",
"### Parâmetros Posicionais e Nomeados (Chave-Valor)\n",
"\n",
"Python permite que funções aceitem dois tipos principais de argumentos: **posicionais** e **nomeados (chave-valor)**.\n",
"\n",
"- **Parâmetros Posicionais:** São aqueles que são passados para a função na ordem em que aparecem na definição da função.\n",
"\n",
" **Exemplo:**\n",
" ```python\n",
" def exibir_info(nome: str, idade: int) -> None:\n",
" print(f\"Nome: {nome}, Idade: {idade}\")\n",
"\n",
" # Chamando a função com parâmetros posicionais\n",
" exibir_info(\"Alice\", 30)\n",
" ```\n",
"\n",
" **Saída do Código:**\n",
" ```\n",
" Nome: Alice, Idade: 30\n",
" ```\n",
"\n",
"- **Parâmetros Nomeados (Chave-Valor):** São aqueles que são passados para a função utilizando a sintaxe `chave=valor`.\n",
"\n",
" **Exemplo:**\n",
" ```python\n",
" def exibir_info(nome: str, idade: int) -> None:\n",
" print(f\"Nome: {nome}, Idade: {idade}\")\n",
"\n",
" # Chamando a função com parâmetros nomeados\n",
" exibir_info(idade=30, nome=\"Alice\")\n",
" ```\n",
" \n",
" **Saída do Código:**\n",
" ```\n",
" Nome: Alice, Idade: 30\n",
" ```\n",
"### Funções com Múltiplos Valores de Retorno\n",
"\n",
"Em Python, uma função pode retornar múltiplos valores, o que é muito útil para obter diferentes informações de um cálculo ou processamento em uma única chamada. Isso permite retornar resultados relacionados sem a necessidade de criar estruturas mais complexas, como classes ou dicionários.\n",
"\n",
"**Exemplo: Retornando Dois Valores**\n",
"\n",
"No exemplo abaixo, a função `soma_dif_valores` calcula a soma e a diferença de dois números, retornando ambos os valores ao mesmo tempo.\n",
"\n",
"```python\n",
"def soma_dif_valores(a: float, b: float) -> tuple[float, float]:\n",
" \"\"\"\n",
" Calcula a soma e a diferença de dois números.\n",
"\n",
" Args:\n",
" a: Primeiro número.\n",
" b: Segundo número.\n",
"\n",
" Retorna:\n",
" Uma tupla contendo a soma e a diferença dos números.\n",
" \"\"\"\n",
" soma_resultado = a + b\n",
" diferenca_resultado = a - b\n",
" return soma_resultado, diferenca_resultado\n",
"\n",
"# Chamando a função\n",
"soma_valores, diferenca_valores = soma_dif_valores(10, 5)\n",
"print(f\"A soma é: {soma_valores}\")\n",
"print(f\"A diferença é: {diferenca_valores}\")\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"A soma é: 15.0\n",
"A diferença é: 5.0\n",
"```\n",
"\n",
"O retorno múltiplo em Python utiliza tuplas. No momento da chamada, você pode \"desempacotar\" os valores em variáveis distintas, facilitando o uso.\n",
"\n",
"**Exemplo: Retornando Valores de Tipos Diferentes**\n",
"\n",
"A seguir, a função `analise_lista` retorna a soma dos elementos de uma lista e um valor booleano indicando se todos os números são positivos.\n",
"\n",
"```python\n",
"def analise_lista(numeros: list[int]) -> tuple[int, bool]:\n",
" \"\"\"\n",
" Analisa uma lista de números inteiros.\n",
"\n",
" Args:\n",
" numeros: Lista de números inteiros.\n",
"\n",
" Retorna:\n",
" - A soma dos elementos.\n",
" - Um valor booleano indicando se todos os números são positivos.\n",
" \"\"\"\n",
" soma_total = sum(numeros)\n",
" \n",
" # Verificando se todos os números são positivos sem usar all\n",
" todos_positivos = True\n",
" for num in numeros:\n",
" if num <= 0:\n",
" todos_positivos = False\n",
" break\n",
"\n",
" return soma_total, todos_positivos\n",
"\n",
"# Chamando a função\n",
"soma, positivos = analise_lista([3, -1, 5, 7, 2])\n",
"print(f\"Soma dos elementos: {soma}\")\n",
"print(f\"Todos os elementos são positivos? {positivos}\")\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"Soma dos elementos: 16\n",
"Todos os elementos são positivos? False\n",
"```\n",
"\n",
"A função retorna a soma dos elementos e verifica se todos são positivos, retornando `False` caso algum não seja.\n",
"\n",
"### Funções que Recebem Outras Funções como Argumentos\n",
"\n",
"Em Python, é possível passar funções como argumentos para outras funções, o que facilita a criação de soluções flexíveis e reutilizáveis. Essa abordagem é útil para transformar, filtrar ou aplicar operações em dados.\n",
"\n",
"**Exemplo: Passando Funções como Argumentos**\n",
"\n",
"O exemplo abaixo mostra uma função que aplica uma operação, definida por outra função, a cada elemento de uma lista.\n",
"\n",
"```python\n",
"def aplicar_operacao(operacao, lista: list[int]) -> list[int]:\n",
" \"\"\"\n",
" Aplica uma operação a cada elemento de uma lista.\n",
"\n",
" Args:\n",
" operacao: Função que define a operação a ser aplicada.\n",
" lista: Lista de elementos.\n",
"\n",
" Retorna:\n",
" Uma nova lista com os resultados da operação aplicada.\n",
" \"\"\"\n",
" return [operacao(elemento) for elemento in lista]\n",
"\n",
"# Funções para operações matemáticas\n",
"def quadrado(x: int) -> int:\n",
" return x * x\n",
"\n",
"def cubo(x: int) -> int:\n",
" return x * x * x\n",
"\n",
"# Aplicando a função quadrado a uma lista\n",
"numeros = [1, 2, 3, 4, 5]\n",
"resultado_quadrado = aplicar_operacao(quadrado, numeros)\n",
"print(f\"O quadrado de cada número na lista é: {resultado_quadrado}\")\n",
"\n",
"# Aplicando a função cubo a uma lista\n",
"resultado_cubo = aplicar_operacao(cubo, numeros)\n",
"print(f\"O cubo de cada número na lista é: {resultado_cubo}\")\n",
"\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"O quadrado de cada número na lista é: [1, 4, 9, 16, 25]\n",
"O cubo de cada número na lista é: [1, 8, 27, 64, 125]\n",
"```\n",
"- A função `aplicar_operacao` recebe:\n",
" - Uma função (`operacao`) que define a lógica de transformação.\n",
" - Uma lista (`lista`) cujos elementos serão processados.\n",
"- Usamos uma compreensão de lista para aplicar a operação a cada elemento da lista.\n",
"- As funções `quadrado` e `cubo` são exemplos de operações que podem ser passadas para `aplicar_operacao`.\n",
"\n",
"Esse modelo permite reutilizar o mesmo código para diferentes operações, simplificando a criação de soluções modulares e flexíveis."
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "-6SCX2vvz_Bp"
},
"source": [
"## Funções Anônimas (Lambda)\n",
"\n",
"As funções anônimas, também conhecidas como lambdas, são funções pequenas e temporárias definidas sem um nome formal. Elas são criadas usando a palavra-chave `lambda` seguida dos parâmetros da função, dois pontos (`:`) e a expressão a ser retornada.\n",
"\n",
"A sintaxe básica de uma função lambda é:\n",
"\n",
"```python\n",
"lambda parâmetros: expressão\n",
"```\n",
"\n",
"### Exemplo com uma variável\n",
"```python\n",
"(lambda x: x * 2)(3)\n",
"```\n",
"**Saída do Código:**\n",
"```\n",
"6\n",
"```\n",
"\n",
"Neste exemplo, uma função lambda que dobra um número é definida e imediatamente chamada com o valor `3`. A função calcula `3 * 2` e retorna `6`.\n",
"\n",
"As funções lambda são úteis quando você precisa de uma função simples e de uso único, sem a necessidade de defini-la formalmente usando a palavra-chave `def`.\n",
"\n",
"\n",
"### Exemplo com duas variáveis\n",
"```python\n",
"soma = lambda x, y: x + y\n",
"print(f\"A soma de 5 e 7 é: {soma(5, 7)}\")\n",
"```\n",
"**Saída do Código:**\n",
"```\n",
"A soma de 5 e 7 é: 12\n",
"```\n",
"\n",
"Aqui, a função lambda `lambda x, y: x + y` recebe dois parâmetros, `x` e `y`, e retorna sua soma. Ao atribuí-la à variável `soma`, ela pode ser chamada como uma função comum. Na última linha, o código demonstra como calcular a soma de dois valores, exibindo o resultado.\n",
"\n",
"\n",
"### Exemplo com listas e `map()`\n",
"```python\n",
"numeros = [1, 2, 3, 4, 5]\n",
"quadrados = list(map(lambda x: x ** 2, numeros))\n",
"print(f\"Os quadrados dos números {numeros} são: {quadrados}\")\n",
"```\n",
"**Saída do Código:**\n",
"```\n",
"Os quadrados dos números [1, 2, 3, 4, 5] são: [1, 4, 9, 16, 25]\n",
"```\n",
"\n",
"Neste exemplo, temos uma lista de números chamada `numeros`. Utilizamos a função `map()` juntamente com uma função lambda para calcular o quadrado de cada número na lista. A função lambda `lambda x: x ** 2` recebe um parâmetro `x` e retorna o quadrado desse valor. A função `map()` aplica a função lambda a cada elemento da lista `numeros`, retornando um objeto `map`. Em seguida, convertemos esse objeto em uma lista usando a função `list()` e atribuímos o resultado à variável `quadrados`. Por fim, imprimimos a lista original `numeros` e a lista `quadrados`.\n",
"\n",
"\n",
"### Exemplo com múltiplos retornos\n",
"```python\n",
"quadrado_e_cubo = lambda x: (x ** 2, x ** 3)\n",
"resultado = quadrado_e_cubo(5)\n",
"print(f\"O quadrado e o cubo de 5 são: {resultado}\")\n",
"```\n",
"**Saída do Código:**\n",
"```\n",
"O quadrado e o cubo de 5 são: (25, 125)\n",
"```\n",
"\n",
"Neste exemplo, a função lambda `lambda x: (x ** 2, x ** 3)` recebe um parâmetro `x` e retorna **dois valores**: o quadrado e o cubo de `x`, dentro de uma **tupla**. Ao passar `5` como argumento, a função retorna a tupla `(25, 125)`, que é impressa na tela.\n",
"\n",
"As funções lambda são uma forma concisa e elegante de criar funções simples e de uso único em Python, especialmente quando usadas em conjunto com funções de ordem superior, como `map()`, `filter()` e `reduce()`. Além disso, sua flexibilidade permite trabalhar com múltiplas variáveis, facilitando a criação de soluções rápidas e legíveis.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Funções Recursivas\n",
"\n",
"A recursividade é uma técnica em que uma função chama a si mesma, direta ou indiretamente, até atingir uma condição de parada. Essa abordagem é útil para problemas que podem ser divididos em subproblemas menores do mesmo tipo.\n",
"\n",
"### Exemplo: Soma de Números de 1 até N\n",
"\n",
"A soma dos números de 1 até um número `n` pode ser calculada recursivamente:\n",
"\n",
"```python\n",
"def soma(n):\n",
" if n == 1: # Condição de parada\n",
" return 1\n",
" else:\n",
" return n + soma(n - 1) # Chamada recursiva\n",
"\n",
"# Teste da função\n",
"print(soma(5))\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"15\n",
"```\n",
"\n",
"A função `soma(5)` chama `soma(4)`, que chama `soma(3)`, e assim por diante, até atingir `soma(1)`, que retorna 1. Os valores são somados de volta ao longo da cadeia de chamadas.\n",
"\n",
"**Representação Recursiva**\n",
"\n",
"A execução da função pode ser visualizada como uma pilha de chamadas:\n",
"\n",
"```python\n",
"soma(5)\n",
" |\n",
" +--> 5 + soma(4)\n",
" |\n",
" +--> 4 + soma(3)\n",
" |\n",
" +--> 3 + soma(2)\n",
" |\n",
" +--> 2 + soma(1)\n",
" |\n",
" +--> 1 (condição de parada)\n",
"```\n",
"\n",
"**Resolução acumulada na volta:**\n",
"\n",
"```python\n",
"soma(1) = 1\n",
"soma(2) = 2 + 1 = 3\n",
"soma(3) = 3 + 3 = 6\n",
"soma(4) = 4 + 6 = 10\n",
"soma(5) = 5 + 10 = 15\n",
"```\n",
"\n",
"\n",
"### Exemplo: Soma de Números em um Intervalo\n",
"\n",
"Para calcular a soma dos números entre `a` e `b`:\n",
"\n",
"```python\n",
"def soma_intervalo(a, b):\n",
" if a > b: # Condição de parada\n",
" return 0\n",
" else:\n",
" return a + soma_intervalo(a + 1, b) # Chamada recursiva\n",
"\n",
"# Teste da função\n",
"print(soma_intervalo(3, 7))\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"23\n",
"```\n",
"\n",
"A função soma os números incrementando `a` até que `a > b`.\n",
"\n",
"\n",
"### Exemplo: Fatorial de um Número\n",
"\n",
"O cálculo do fatorial de um número `n` é feito multiplicando todos os inteiros de 1 até `n`:\n",
"\n",
"```python\n",
"def fatorial(n):\n",
" if n == 0 or n == 1: # Condição de parada\n",
" return 1\n",
" else:\n",
" return n * fatorial(n - 1) # Chamada recursiva\n",
"\n",
"# Teste da função\n",
"print(fatorial(5))\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"120\n",
"```\n",
"\n",
"A função chama a si mesma com `n - 1` até que `n` seja 0 ou 1, retornando 1.\n",
"\n",
"\n",
"### Exemplo: Soma dos Elementos de uma Lista\n",
"\n",
"A soma dos elementos de uma lista pode ser feita de forma recursiva:\n",
"\n",
"```python\n",
"def soma_lista(lista):\n",
" if len(lista) == 0: # Caso base: lista vazia\n",
" return 0\n",
" else:\n",
" return lista[0] + soma_lista(lista[1:]) # Chamada recursiva\n",
"\n",
"# Teste da função\n",
"lista_exemplo = [1, 2, 3, 4, 5]\n",
"print(f\"A soma dos números na lista é: {soma_lista(lista_exemplo)}\")\n",
"```\n",
"\n",
"**Saída do Código:**\n",
"```\n",
"A soma dos números na lista é: 15\n",
"```\n",
"\n",
"A função pega o primeiro elemento da lista e chama a si mesma com o restante. O processo continua até que a lista esteja vazia.\n",
"\n",
"\n",
"### Vantagens e Desvantagens da Recursividade\n",
"\n",
"| **Vantagens** | **Desvantagens** |\n",
"|-----------------------------------------|---------------------------------------------------------------------------------|\n",
"| Torna o código mais elegante e claro. | Consome mais memória devido ao empilhamento de chamadas. |\n",
"| Ideal para problemas que seguem uma estrutura recursiva natural, como árvores. | Pode ser ineficiente para problemas grandes. |\n",
"| Evita o uso de variáveis auxiliares ou estruturas de controle complexas. | Erros como loops infinitos podem ocorrer caso a condição de parada não seja bem definida. |\n",
"\n",
"A recursividade é uma ferramenta poderosa, mas deve ser utilizada com cuidado. Em problemas de grande escala, pode ser melhor optar por uma abordagem iterativa para economizar recursos computacionais."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Funções *Built-in*\n",
"\n",
"As funções *built-in* do Python são ferramentas essenciais que simplificam tarefas comuns e oferecem funcionalidades robustas prontas para uso. Estão sempre disponíveis sem a necessidade de importação, com exceção de algumas funções que pertencem a módulos específicos, como `math`.\n",
"\n",
"A tabela abaixo apresenta uma lista ampliada das principais funções *built-in*, categorizadas para facilitar a consulta.\n",
"\n",
"| **Categoria** | **Função** | **Descrição** | **Exemplo** | **Saída** |\n",
"|-------------------------|--------------------|-----------------------------------------------------------|---------------------------------------|------------------------------------|\n",
"| **Saída e Entrada** | `print()` | Imprime mensagens ou valores na saída padrão. | `print(\"Olá, mundo!\")` | `Olá, mundo!` |\n",
"| | `input()` | Solicita entrada do usuário. | `nome = input(\"Digite seu nome: \")` | (aguarda entrada do usuário) |\n",
"| **Conversão de Tipo** | `int()` | Converte para inteiro. | `int(\"123\")` | `123` |\n",
"| | `float()` | Converte para ponto flutuante. | `float(\"3.14\")` | `3.14` |\n",
"| | `str()` | Converte para string. | `str(123)` | `'123'` |\n",
"| | `list()` | Converte para lista. | `list(\"abc\")` | `['a', 'b', 'c']` |\n",
"| | `tuple()` | Converte para tupla. | `tuple([1, 2, 3])` | `(1, 2, 3)` |\n",
"| | `set()` | Converte para conjunto. | `set([1, 2, 2, 3])` | `{1, 2, 3}` |\n",
"| | `dict()` | Cria um dicionário. | `dict(a=1, b=2)` | `{'a': 1, 'b': 2}` |\n",
"| **Manipulação de Sequências** | `len()` | Retorna o tamanho de uma sequência. | `len(\"Python\")` | `6` |\n",
"| | `max()` | Retorna o valor máximo em uma sequência. | `max([2, 8, 5])` | `8` |\n",
"| | `min()` | Retorna o valor mínimo em uma sequência. | `min([2, 8, 5])` | `2` |\n",
"| | `sum()` | Soma os elementos de uma sequência numérica. | `sum([1, 2, 3])` | `6` |\n",
"| | `sorted()` | Retorna uma lista ordenada. | `sorted([3, 1, 2])` | `[1, 2, 3]` |\n",
"| **Tipo e Valor** | `type()` | Retorna o tipo de um objeto. | `type(\"texto\")` | `` |\n",
"| | `id()` | Retorna o identificador único de um objeto. | `id([1, 2, 3])` | (depende do objeto) |\n",
"| | `isinstance()` | Verifica se um objeto é de um tipo específico. | `isinstance(10, int)` | `True` |\n",
"| | `hash()` | Retorna o valor hash de um objeto. | `hash(\"texto\")` | (valor numérico do hash) |\n",
"| **Matemática** | `abs()` | Retorna o valor absoluto de um número. | `abs(-10)` | `10` |\n",
"| | `pow()` | Retorna x elevado à potência y. | `pow(2, 3)` | `8` |\n",
"| | `math.sqrt()` | Retorna a raiz quadrada de um número. | `math.sqrt(16)` | `4.0` |\n",
"| | `math.factorial()` | Calcula o fatorial de um número. | `math.factorial(5)` | `120` |\n",
"| | `round()` | Arredonda um número para o inteiro mais próximo ou para casas decimais específicas. | `round(3.14159, 2)` | `3.14` |\n",
"| **Tratar Erros** | `assert` | Verifica uma condição e gera um erro se for falsa. | `assert x > 0, \"Erro\"` | (depende da condição) |\n",
"| **Iteração** | `range()` | Cria um intervalo para iteração. | `list(range(5))` | `[0, 1, 2, 3, 4]` |\n",
"| **Outros** | `help()` | Exibe a documentação de um objeto. | `help(print)` | (documentação do `print`) |\n",
"| | `dir()` | Lista os atributos e métodos de um objeto. | `dir(\"texto\")` | (lista de métodos e atributos) |\n",
"| | `open()` | Abre um arquivo e retorna um objeto de arquivo. | `open('arquivo.txt', 'r')` | (objeto de arquivo) |\n",
"| | `eval()` | Avalia uma expressão em forma de string. | `eval(\"2 + 2\")` | `4` |\n",
"| | `exec()` | Executa um código Python em forma de string. | `exec(\"x = 5\")` | (define `x` no ambiente atual) |\n",
"\n",
"---\n",
"\n",
"### Observação sobre o módulo `math` \n",
"As funções matemáticas como `math.sqrt()` e `math.factorial()` exigem a importação do módulo `math`. Por exemplo:\n",
"\n",
"```python\n",
"import math\n",
"raiz = math.sqrt(16)\n",
"print(raiz)\n",
"```\n",
"\n",
" **Saída do Código:**\n",
"```\n",
"4\n",
"```\n",
"\n",
"Para explorar todas as funções *built-in* e obter mais informações, consulte a [documentação oficial do Python](https://docs.python.org/3/library/functions.html)."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Exercícios\n",
"\n",
"1. **Menor e Maior entre Três Números**\n",
"\n",
"Desenvolva um programa que determine o menor e o maior número entre três valores fornecidos pelo usuário. O programa deve utilizar funções para realizar as operações necessárias. Siga as instruções:\n",
"\n",
"- Crie uma função chamada `ler_numeros()` que solicite ao usuário que insira três números e retorne esses valores.\n",
"\n",
"- Implemente uma função chamada `encontrar_menor_maior(a, b, c)` que receba três números como parâmetros e retorne uma tupla contendo o menor e o maior valor, nesta ordem.\n",
"\n",
"- No programa principal, utilize as funções criadas para:\n",
" - Obter os três números do usuário.\n",
" - Calcular o menor e o maior valor.\n",
" - Exibir os resultados.\n",
"\n",
"Exemplo de uso no programa principal:\n",
"\n",
"```python\n",
"num1, num2, num3 = ler_numeros()\n",
"menor, maior = encontrar_menor_maior(num1, num2, num3)\n",
"print(f\"O menor número é: {menor}\")\n",
"print(f\"O maior número é: {maior}\")\n",
"```\n",
"\n",
"Certifique-se de que o programa trate adequadamente diferentes tipos de entrada, incluindo números inteiros e decimais.\n",
"\n",
"```python\n",
"# Teste 1\n",
"Entrada: 10, 5, 8\n",
"Saída: \n",
"O menor número é: 5\n",
"O maior número é: 10\n",
"\n",
"# Teste 2\n",
"Entrada: 3.14, 1.71, 1.41\n",
"Saída:\n",
"O menor número é: 1.41\n",
"O maior número é: 3.14\n",
"\n",
"# Teste 3\n",
"Entrada: -5, 0, -10\n",
"Saída:\n",
"O menor número é: -10\n",
"O maior número é: 0\n",
"\n",
"# Teste 4\n",
"Entrada: 1, 3.14, 2\n",
"Saída:\n",
"O menor número é: 1\n",
"O maior número é: 3.14\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "qRPqFHlZN-SR"
},
"source": [
"2. **Cálculo do IMC Utilizando Funções**\n",
"\n",
"Desenvolva um programa em Python para calcular o Índice de Massa Corporal (IMC) de uma pessoa, utilizando funções para organizar e modularizar o código.\n",
"\n",
"O programa deve incluir as seguintes funções:\n",
"- Uma função para ler os dados do usuário (peso em kg e altura em metros).\n",
"- Uma função para calcular o IMC usando a fórmula: IMC = peso / (altura * altura).\n",
"- Uma função para classificar o IMC de acordo com as faixas padrão.\n",
"\n",
"A classificação do IMC deve seguir a tabela abaixo:\n",
"\n",
"| IMC (kg/m²) | Classificação |\n",
"|-------------|---------------|\n",
"| < 18.5 | Abaixo do peso |\n",
"| 18.5 - 24.9 | Peso normal |\n",
"| 25.0 - 29.9 | Sobrepeso |\n",
"| 30.0 - 34.9 | Obesidade grau 1 |\n",
"| 35.0 - 39.9 | Obesidade grau 2 |\n",
"| ≥ 40.0 | Obesidade grau 3 |\n",
"\n",
"No programa principal, chame as funções na ordem adequada para:\n",
"- Obter os dados do usuário.\n",
"- Calcular o IMC.\n",
"- Determinar a classificação.\n",
"\n",
"Por exemplo:\n",
"```python\n",
"peso, altura = ler_dados()\n",
"imc = calcular_imc(peso, altura)\n",
"classificacao = classificar_imc(imc)\n",
"print(f\"Seu IMC é {imc:.2f} - Classificação: {classificacao}\")\n",
"```\n",
"Certifique-se de tratar possíveis erros de entrada do usuário, como valores negativos ou zero para peso e altura. O programa deve ser robusto e capaz de lidar com diferentes cenários de entrada.\n",
"\n",
"```python\n",
"# Teste 1\n",
"Entrada: 90.5, 1.85\n",
"Saída: Seu IMC é 26.44 - Classificação: Sobrepeso\n",
"\n",
"# Teste 2\n",
"Entrada: 65.0, 1.75\n",
"Saída: Seu IMC é 21.22 - Classificação: Peso normal\n",
"\n",
"# Teste 3\n",
"Entrada: 45.0, 1.60\n",
"Saída: Seu IMC é 17.58 - Classificação: Abaixo do peso\n",
"\n",
"# Teste 4\n",
"Entrada: 120.0, 1.70\n",
"Saída: Seu IMC é 41.52 - Classificação: Obesidade grau 3\n",
"```\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"3. **Calculadora de Área de Formas Geométricas**\n",
"\n",
"Crie um programa que funcione como uma calculadora de área para diferentes formas geométricas, incluindo triângulo, círculo e retângulo. O programa deve fornecer um menu fácil de usar para que o usuário selecione a forma desejada e, em seguida, insira as dimensões necessárias para calcular a área.\n",
"\n",
"Crie uma função principal chamada `calcular_area()` que representa a abstração de um menu ao usuário com as seguintes opções:\n",
"- **Opção 1**: Calcular a área de um triângulo (base e altura)\n",
"- **Opção 2**: Calcular a área de um círculo (raio)\n",
"- **Opção 3**: Calcular a área de um retângulo (comprimento e largura)\n",
"- **Opção 4**: Sair do programa\n",
"\n",
"Crie individualmente uma função para o cálculo das áreas de cada forma geométrica:\n",
"- `area_triangulo(base, altura)`\n",
"- `area_circulo(raio)`\n",
"- `area_retangulo(comprimento, largura)`\n",
"\n",
"Exemplos de teste:\n",
"\n",
"```python\n",
"# Teste 1\n",
"Entrada: \n",
"1\n",
"5\n",
"10\n",
"Saída: A área do triângulo é: 25.00\n",
"\n",
"# Teste 2\n",
"Entrada:\n",
"2\n",
"3\n",
"Saída: A área do círculo é: 28.27\n",
"\n",
"# Teste 3\n",
"Entrada:\n",
"3\n",
"4\n",
"6\n",
"Saída: A área do retângulo é: 24.00\n",
"\n",
"# Teste 4\n",
"Entrada: 4\n",
"Saída: Programa encerrado.\n",
"```\n",
"Observações:\n",
"- Use a biblioteca `math` para obter o π (pi) nos cálculos do círculo.\n",
"- Arredonde todos os resultados para duas casas decimais."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**4. Sistema de Bonificação para Atletas Olímpicos**\n",
"\n",
"O Comitê Olímpico Nacional decidiu criar um sistema de bonificação para atletas que ganharam medalhas nas Olimpíadas. O sistema funciona da seguinte forma:\n",
"\n",
"Cada atleta recebe uma bonificação base de acordo com a medalha:\n",
"- Ouro: R$ 50.000\n",
"- Prata: R$ 30.000\n",
"- Bronze: R$ 10.000\n",
"\n",
"Além disso, há bônus adicionais baseados em critérios específicos:\n",
"- Quebra de recorde mundial: +R$ 100.000\n",
"- Primeira medalha do país na modalidade: +R$ 50.000\n",
"\n",
"Crie uma função chamada `calcular_bonificacao` que receba os seguintes parâmetros:\n",
"- `medalhas`: uma lista de strings representando as medalhas ganhas (\"ouro\", \"prata\" ou \"bronze\")\n",
"- `recorde_mundial`: Uma String, Sim ou Nao, indicando se o atleta quebrou um recorde mundial\n",
"- `primeira_medalha_pais`: Uma String, Sim ou Nao, indicando se é a primeira medalha do país na modalidade\n",
"\n",
"A função deve retornar o valor total da bonificação do atleta.\n",
"\n",
"```python\n",
"# Teste 1\n",
"Entrada:Ouro,Sim,Nao\n",
"Saída: 150000\n",
"\n",
"# Teste 2\n",
"Entrada:Prata,Bronze,Nao,Sim\n",
"Saída: 90000\n",
"\n",
"# Teste 3\n",
"Entrada:Bronze,Bronze,Bronze,Nao,Nao\n",
"Saída: 30000\n",
"\n",
"# Teste 4\n",
"Entrada:Ouro,Prata,Bronze,Nao,Sim\n",
"Saída: 140000\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**5. Calculando as Raízes de Equações Quadráticas**\n",
"\n",
"Neste exercício, você terá a oportunidade de aplicar conceitos matemáticos para resolver o problema de Bhaskara, escrevendo um código para calcular as raízes de uma equação quadrática.\n",
"\n",
"Dada uma equação quadrática na forma $Ax^2 + Bx + C = 0$, escreva um programa que leia três valores de ponto flutuante e calcule as raízes da equação usando a Fórmula de Bhaskara. Se não for possível calcular as raízes, mostre a mensagem \"Impossível calcular\", caso haja uma divisão por zero ou raiz de número negativo.\n",
"\n",
"$ R1 = \\frac{-B + \\sqrt{B^2 - 4AC}}{2A} $\n",
"\n",
"$ R2 = \\frac{-B - \\sqrt{B^2 - 4AC}}{2A} $\n",
"\n",
"Observações:\n",
"- Se $A$ é igual a zero, não é possível calcular as raízes.\n",
"- Se o discriminante $\\Delta = B^2 - 4AC $ é negativo, não é possível calcular as raízes.\n",
"- As raízes da equação devem ter 2 dígitos após o ponto decimal.\n",
"- Escreva uma função para leitura dos dados, outra para verificar se é possível calcular as raízes, e uma terceira para calcular e retornar as raízes.\n",
"\n",
"```python\n",
"# Teste 1\n",
"Entrada: 10.0, 19.1, 5.2\n",
"Saída:\n",
"R1 = -0.33\n",
"R2 = -1.58\n",
"\n",
"# Teste 2\n",
"Entrada: 0.0, 20.0, 5.0\n",
"Saída: Impossível calcular\n",
"\n",
"# Teste 3\n",
"Entrada: 1.0, -3.0, 2.0\n",
"Saída:\n",
"R1 = 2.00\n",
"R2 = 1.00\n",
"\n",
"# Teste 4\n",
"Entrada: 1.0, 2.0, 5.0\n",
"Saída: Impossível calcular\n",
"```\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**6. Contando: Pares, Ímpares, Positivos e Negativos**\n",
"\n",
"Escreva uma função chamada `contar_pares_impares` que receba uma lista de números como argumento e retorne duas variáveis: a contagem de números pares e a contagem de números ímpares na lista.\n",
"\n",
"Escreva outra função chamada `contar_positivos_negativos` que receba a mesma lista de números como argumento e retorne duas variáveis: a contagem de números positivos e a contagem de números negativos na lista.\n",
"\n",
"O programa principal deve ler uma lista de números inteiros na entrada, passar essa lista para as funções acima. Em seguida, o programa deve imprimir as contagens de números pares, ímpares, positivos e negativos, cada uma em uma linha separada.\n",
"\n",
"```python\n",
"# Teste 1\n",
"Entrada: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16, -17, -18, -19, -20, -21, -22, -23, -24, -25\n",
"Saída:\n",
"Quantidade de números pares: 24\n",
"Quantidade de números ímpares: 26\n",
"Quantidade de números positivos: 25\n",
"Quantidade de números negativos: 25\n",
"\n",
"# Teste 2\n",
"Entrada: 30, -31, 32, -33, 34, -35, 36, -37, 38, -39, 40, -41, 42, -43, 44, -45, 46, -47, 48, -49, 50, -51, 52, -53, 54, -55, 56, -57, 58, -59, 60, -61, 62, -63, 64, -65, 66, -67, 68, -69, 70, -71, 72, -73, 74, -75\n",
"Saída:\n",
"Quantidade de números pares: 23\n",
"Quantidade de números ímpares: 23\n",
"Quantidade de números positivos: 23\n",
"Quantidade de números negativos: 23\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**7. Soma Recursiva de uma Lista**\n",
"\n",
"Escreva uma função recursiva chamada `soma_recursiva` que receba uma lista de números inteiros como entrada e retorne a soma de todos os elementos da lista.\n",
"\n",
"Por exemplo, se a lista de entrada for `[1, 2, 3, 4, 5]`, a função deve retornar `15` (que é a soma de todos os números na lista).\n",
"\n",
"Observações:\n",
"\n",
"- A função `soma_recursiva` deve ter uma condição base, que é quando a lista está vazia.\n",
"- A função deve chamar a si mesma com uma versão menor da lista, até chegar na condição base.\n",
"- A função deve realizar a soma dos elementos da lista de forma recursiva.\n",
"\n",
"Teste sua função com as seguintes entradas:\n",
"\n",
"```python\n",
"# Teste 1\n",
"entrada = 1, 2, 3, 4, 5, 50, 60, 70, 80, 90, 0, 1\n",
"saida = 366\n",
"\n",
"# Teste 2\n",
"entrada = 10, 20, 30, 40, 50, 1, 2, 3, 4, 5, 6, 7, -15, -20\n",
"saida = 143\n",
"```\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**8. Cálculo da Sequência de Fibonacci**\n",
"\n",
"Imagine que você tem uma lista de números. O objetivo é calcular o *n*-ésimo número da sequência de Fibonacci para cada número dessa lista e imprimir a soma total desses números.\n",
"\n",
"A sequência de Fibonacci é como uma escada em espiral, onde cada número é a soma dos dois anteriores. Ela começa com 0 e 1, e continua infinitamente: 0, 1, 1, 2, 3, 5, 8, 13, 21...\n",
"\n",
"Para isso, você precisará criar duas funções recursivas:\n",
"\n",
"1. **A função Fibonacci:** Essa função será o coração da operação. Ela receberá um número como entrada e, usando a recursão, calculará o número correspondente na sequência de Fibonacci.\n",
"\n",
"2. **A função Soma Recursiva:** Essa função receberá a lista de resultados da função Fibonacci e, novamente usando a recursão, somará todos os elementos dessa lista.\n",
"\n",
"No final, você imprimirá na tela a soma total de todos os números da sequência de Fibonacci calculados para cada número da lista de entrada.\n",
"\n",
"Lembre-se: a recursão é como um espelho que reflete a si mesmo. A função chama a si mesma para resolver problemas menores até chegar a um ponto de parada, chamado de \"condição base\". É como descer uma escada: você dá um passo de cada vez até chegar ao chão.\n",
"\n",
"\n",
"```python\n",
"# Teste 1\n",
"Entrada: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15\n",
"Saída: 1596\n",
"\n",
"# Teste 2\n",
"Entrada: 10, 11, 9, 15, 17, 23, 13, 27, 12, 11, 22\n",
"Saída: 245637\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**9. Cálculo da Potência de Forma Recursiva**\n",
"\n",
"Escreva uma função recursiva chamada `calcular_potencia` que receba dois números como entrada: a base (`base`) e o expoente (`expoente`). A função deve calcular e retornar o resultado da base elevada ao expoente, sem utilizar a função `math.pow()` ou qualquer outra função matemática avançada, apenas operações matemáticas elementares.\n",
"\n",
"Por exemplo, se a base for `2` e o expoente for `3`, a função deve retornar `8` (que é o resultado de 2 elevado a 3).\n",
"\n",
"Observações:\n",
"\n",
"- A função `calcular_potencia` deve ter uma condição base, que é quando o expoente é igual a 0.\n",
"- A função deve chamar a si mesma com uma versão menor do expoente, até chegar na condição base.\n",
"- A função deve realizar o cálculo da potência de forma recursiva, usando apenas operações matemáticas básicas (multiplicação, divisão, adição e subtração).\n",
"\n",
"Teste sua função com as seguintes entradas:\n",
"\n",
"```python\n",
"# Teste 1\n",
"Entrada: 2, 3\n",
"Saída: 2^3 = 8\n",
"\n",
"# Teste 2\n",
"Entrada: 4, 5\n",
"Saída: 4^5 = 1024\n",
"\n",
"# Teste 3\n",
"Entrada: 6, 4\n",
"Saída: 6^4 = 1296\n",
"\n",
"# Teste 4\n",
"Entrada: 34, 0\n",
"Saída: 34^0 = 1\n",
"```\n",
"\n",
"Lembre-se de implementar a função `calcular_potencia` de forma recursiva, usando apenas operações matemáticas básicas."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**10. Torre de Hanói: Um Desafio Recursivo da Computação e Matemática**\n",
"\n",
"A Torre de Hanói é um problema clássico e intrigante no campo da computação e matemática. Envolve a movimentação estratégica de discos entre três pinos, seguindo um conjunto específico de regras. O desafio parece simples à primeira vista, mas sua complexidade aumenta exponencialmente à medida que o número de discos cresce.\n",
"\n",
"**O Problema:**\n",
"Imagine três pinos, rotulados como A, B e C. No início do jogo, todos os discos, que variam em tamanho, estão empilhados em ordem decrescente de tamanho no pino A, com o disco maior embaixo e o menor no topo. O objetivo é transferir todos os discos do pino A para o pino C.\n",
"\n",
"**As Regras:**\n",
"- Você só pode mover um disco por vez.\n",
"- Cada movimento envolve tirar o disco de cima de uma pilha e colocá-lo em cima de outra pilha.\n",
"- Nunca coloque um disco maior em cima de um menor. Os discos devem ser empilhados em ordem de tamanho.\n",
"- O pino B é auxiliar. Você pode usá-lo como um pino intermediário para ajudar na movimentação dos discos.\n",
"\n",
"**Visualizando o Jogo:**\n",
"\n",
"Estado inicial:\n",
"\n",
"```\n",
" | | |\n",
" | | |\n",
" === | |\n",
" ===== | |\n",
" ======= | |\n",
"-----------------------------\n",
" A B C\n",
"```\n",
"\n",
"Estado intermediário (após mais duas jogadas):\n",
"\n",
"```\n",
" | | |\n",
" | | |\n",
" | | |\n",
" | | |\n",
" ======= ===== ===\n",
"-----------------------------\n",
" A B C\n",
"```\n",
"\n",
"Estado final:\n",
"\n",
"```\n",
" | | |\n",
" | | |\n",
" | | ===\n",
" | | =====\n",
" | | ======= \n",
"-----------------------------\n",
" A B C\n",
"```\n",
"\n",
"**Sua Tarefa:**\n",
"Implemente uma função recursiva chamada `torre_de_hanoi` que resolva esse problema. A função deve receber como entrada o número de discos (`n`) e os nomes dos pinos de origem, auxiliar e destino. Ela deve executar e imprimir os movimentos necessários para transferir todos os discos do pino de origem para o pino de destino.\n",
"\n",
"**Protótipo da Função:**\n",
"```python\n",
"def torre_de_hanoi(n, origem, auxiliar, destino):\n",
" # Implementação aqui\n",
"```\n",
"\n",
"**Dicas e Observações:**\n",
"- A função deve ter uma condição base para quando houver apenas um disco.\n",
"- Use a recursividade para dividir o problema em subproblemas menores.\n",
"- Imprima cada movimento no formato: \"Mover disco de [origem] para [destino]\".\n",
"- A solução recursiva deve:\n",
" - Mover n-1 discos para o pino auxiliar\n",
" - Mover o disco maior para o pino de destino\n",
" - Mover os n-1 discos do pino auxiliar para o pino de destino\n",
"\n",
"**Testes:**\n",
"\n",
"```python\n",
"# Teste 1\n",
"Entrada: 3, A, B, C\n",
"Saída:\n",
"Mover disco de A para C\n",
"Mover disco de A para B\n",
"Mover disco de C para B\n",
"Mover disco de A para C\n",
"Mover disco de B para A\n",
"Mover disco de B para C\n",
"Mover disco de A para C\n",
"\n",
"# Teste 2\n",
"Entrada: 4, A, B, C\n",
"Saída:\n",
"Mover disco de A para B\n",
"Mover disco de A para C\n",
"Mover disco de B para C\n",
"Mover disco de A para B\n",
"Mover disco de C para A\n",
"Mover disco de C para B\n",
"Mover disco de A para B\n",
"Mover disco de A para C\n",
"Mover disco de B para C\n",
"Mover disco de B para A\n",
"Mover disco de C para A\n",
"Mover disco de B para C\n",
"Mover disco de A para B\n",
"Mover disco de A para C\n",
"Mover disco de B para C\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Exercícios (Extra)\n",
"\n",
"**1. Analisador de Desempenho: Planeje seus Estudos!**\n",
"\n",
"Este exercício ajuda você a analisar seu desempenho acadêmico e planejar seus estudos de maneira eficiente. Com base nas notas obtidas em **7 disciplinas**, o sistema calculará métricas essenciais como médias, desvios padrões e a nota necessária para alcançar a meta de aprovação (5.0). Além disso, ele criará um ranking de prioridades de estudo com base na consistência, instabilidade e dificuldade de alcançar a média.\n",
"\n",
"As disciplinas são analisadas na seguinte ordem, cada uma com **3 unidades**: \n",
"1. Linguagem de Programação \n",
"2. Álgebra Linear \n",
"3. Modelagem do Mundo Físico I \n",
"4. Práticas de Leitura e Escrita II \n",
"5. Química Geral \n",
"6. Cálculo Diferencial e Integral I \n",
"7. Meio Ambiente e Desenvolvimento Urbano \n",
"\n",
"- **Entrada dos Dados**:\n",
" - Para cada disciplina, você fornecerá **6 notas**:\n",
" - 3 avaliações da **1ª unidade**.\n",
" - 3 avaliações da **2ª unidade**.\n",
" - O sistema calculará a **nota necessária na 3ª unidade** para atingir a média de 5.0. \n",
"\n",
"Total: **42 notas** para 7 disciplinas.\n",
"\n",
"**Cálculos Importantes:**\n",
"\n",
"O sistema calculará as seguintes métricas:\n",
"\n",
"- **Média da Unidade**:\n",
"\n",
" $\n",
" \\text{Média da Unidade} = \\frac{\\text{soma das 3 notas}}{3}\n",
" $\n",
"\n",
"- **Nota necessária na 3ª unidade para atingir a média de 5.0**:\n",
"\n",
" $\n",
" \\text{Nota Necessária} = 3 \\times \\text{Meta (5.0)} - (\\text{Média da 1ª Unidade} + \\text{Média da 2ª Unidade})\n",
" $\n",
"\n",
"- **Consistência da Disciplina**:\n",
" Avalia a estabilidade no desempenho entre as duas primeiras unidades. \n",
" Quanto menor a diferença percentual entre as médias, maior a consistência.\n",
"\n",
" $\n",
" \\text{Consistência} = 1 - \\frac{|\\text{Média da 2ª Unidade} - \\text{Média da 1ª Unidade}|}{\\text{Média da 1ª Unidade}}\n",
" $\n",
"\n",
" - **Consistência próxima de 1**: Desempenho estável entre as unidades. \n",
" - **Consistência próxima de 0**: Variação significativa entre as unidades.\n",
"\n",
"- **Instabilidade da Disciplina**:\n",
" Mede a variação na dispersão das notas entre as duas primeiras unidades. \n",
"\n",
" $\n",
" \\text{Instabilidade} = \\frac{\\text{Desvio Padrão da 2ª Unidade}}{\\text{Desvio Padrão da 1ª Unidade}}\n",
" $\n",
"\n",
" - **Instabilidade = 1**: Mesma dispersão entre as unidades. \n",
" - **Instabilidade > 1**: A segunda unidade foi mais dispersa. \n",
" - **Instabilidade < 1**: A primeira unidade foi mais dispersa.\n",
"\n",
"- **Ranking de Prioridade para Estudo**:\n",
" Determina quais disciplinas requerem mais atenção. \n",
" $\n",
" \\text{Prioridade} = \\text{Peso}_1 \\times (1 - \\text{Consistência}) + \\text{Peso}_2 \\times \\text{Instabilidade} + \\text{Peso}_3 \\times \\text{Nota Necessária}\n",
" $\n",
"\n",
" - Pesos padrão:\n",
" - Consistência: $ \\text{Peso}_1 = 2.0 $\n",
" - Instabilidade: $ \\text{Peso}_2 = 1.5 $\n",
" - Nota Necessária: $ \\text{Peso}_3 = 1.0 $\n",
"\n",
" **Tarefa:**\n",
"\n",
"Implemente a função principal **`analisar_desempenho`** para calcular todas as métricas acima e gerar os resultados para cada disciplina.\n",
"\n",
"**Observação:** Para criar o ranking de prioridades, você pode utilizar funções de ordenação disponíveis na linguagem, como [sorted](https://docs.python.org/pt-br/3/howto/sorting.html) em Python, para facilitar a implementação.\n",
"\n",
"**Protótipo**\n",
"```python\n",
"def analisar_desempenho(\n",
" notas: list[float],\n",
" calcular_media,\n",
" calcular_desvio_padrao,\n",
" calcular_nota_necessaria,\n",
" avaliar_consistencia,\n",
" gerar_ranking_prioridade\n",
") -> None:\n",
" \"\"\"\n",
" Analisa o desempenho acadêmico com base nas notas das disciplinas.\n",
"\n",
" Parâmetros:\n",
" notas (list[float]): Lista com as notas das disciplinas (42 valores).\n",
" calcular_media (function): Função para calcular a média.\n",
" calcular_desvio_padrao (function): Função para calcular o desvio padrão.\n",
" calcular_nota_necessaria (function): Função para calcular a nota necessária.\n",
" avaliar_consistencia (function): Função para avaliar a consistência.\n",
" gerar_ranking_prioridade (function): Função para gerar o ranking de prioridade.\n",
" \"\"\"\n",
" pass\n",
"```\n",
"\n",
"**Teste:**\n",
"\n",
"```python\n",
"# Teste 1\n",
"Entrada:\n",
"6.0, 7.0, 8.0, 5.0, 6.5, 6.0, \n",
"4.0, 5.5, 6.0, 4.5, 5.0, 4.0, \n",
"7.0, 8.0, 7.5, 6.0, 7.0, 6.5, \n",
"6.0, 6.5, 7.0, 6.0, 6.0, 5.5, \n",
"5.0, 5.5, 5.0, 4.5, 4.0, 4.0, \n",
"6.0, 7.0, 6.5, 5.5, 6.0, 5.0, \n",
"7.0, 6.5, 6.0, 6.5, 6.0, 5.5 \n",
"\n",
"Saída:\n",
"Ranking de prioridade para estudo:\n",
"1. Química Geral:\n",
" - Consistência: 0.81\n",
" - Instabilidade: 1.00\n",
" - Nota necessária na 3ª unidade: 5.67\n",
" - Prioridade: 7.55\n",
"2. Álgebra Linear:\n",
" - Consistência: 0.87\n",
" - Instabilidade: 0.48\n",
" - Nota necessária na 3ª unidade: 5.33\n",
" - Prioridade: 6.31\n",
"3. Cálculo Diferencial e Integral I:\n",
" - Consistência: 0.85\n",
" - Instabilidade: 1.00\n",
" - Nota necessária na 3ª unidade: 3.00\n",
" - Prioridade: 4.81\n",
"4. Meio Ambiente e Desenvolvimento Urbano:\n",
" - Consistência: 0.92\n",
" - Instabilidade: 1.00\n",
" - Nota necessária na 3ª unidade: 2.50\n",
" - Prioridade: 4.15\n",
"5. Práticas de Leitura e Escrita II:\n",
" - Consistência: 0.90\n",
" - Instabilidade: 0.58\n",
" - Nota necessária na 3ª unidade: 2.67\n",
" - Prioridade: 3.74\n",
"6. Linguagem de Programação:\n",
" - Consistência: 0.83\n",
" - Instabilidade: 0.76\n",
" - Nota necessária na 3ª unidade: 2.17\n",
" - Prioridade: 3.65\n",
"7. Modelagem do Mundo Físico I:\n",
" - Consistência: 0.87\n",
" - Instabilidade: 1.00\n",
" - Nota necessária na 3ª unidade: 1.00\n",
" - Prioridade: 2.77\n",
"```\n"
]
}
],
"metadata": {
"colab": {
"provenance": [],
"toc_visible": true
},
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.20"
}
},
"nbformat": 4,
"nbformat_minor": 4
}
![\"function\"](\"function.svg\")
\n",
"