{ "cells": [ { "cell_type": "markdown", "metadata": { "id": "ULxWGdhVqcRt" }, "source": [ "# Capítulo 3: Operadores e Expressões" ] }, { "cell_type": "markdown", "metadata": { "id": "ebERi_S7Z4OC" }, "source": [ "![ch3](ch3.jpeg)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Compreender os operadores e expressões é importante para a manipulação eficiente de dados e a execução de operações fundamentais em qualquer linguagem. Estes elementos, abrangendo operadores aritméticos, relacionais, lógicos e de atribuição, assumem papéis específicos, desde cálculos matemáticos até avaliações condicionais. Entender tais conceitos não apenas facilita a escrita de códigos mais eficazes, mas também permite a resolução de problemas complexos e a compreensão de códigos existentes. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Operadores Aritméticos\n", "\n", "Os operadores aritméticos são fundamentais em qualquer linguagem de programação. Eles permitem realizar operações matemáticas essenciais em variáveis e valores numéricos. Vamos explorar os principais operadores aritméticos em Python, seus símbolos e como eles funcionam na prática:\n", "\n", "| Operador | Símbolo | Descrição | Exemplo | Resultado |\n", "|---|---|---|---|---|\n", "| **Adição** | `+` | Soma dois valores. | `3 + 5` | `8` |\n", "| **Subtração** | `-` | Subtrai o valor à direita do valor à esquerda. | `10 - 3` | `7` |\n", "| **Multiplicação** | `*` | Multiplica dois valores. | `4 * 2` | `8` |\n", "| **Divisão** | `/` | Divide o valor à esquerda pelo valor à direita. | `10 / 2` | `5.0` |\n", "| **Módulo** | `%` | Retorna o resto da divisão. | `10 % 3` | `1` |\n", "| **Divisão Inteira** | `//` | Retorna a parte inteira da divisão. | `10 // 3` | `3` |\n", "| **Exponenciação** | `**` | Eleva o valor à esquerda à potência do valor à direita. | `2 ** 3` | `8` |\n", "\n", "**Exemplos de Uso:**\n", "\n", "```python\n", "# Adição (+)\n", "soma = 5 + 3\n", "\n", "# Subtração (-)\n", "subtracao = 7 - 4\n", "\n", "# Multiplicação (*)\n", "multiplicacao = 6 * 2\n", "\n", "# Divisão (/)\n", "divisao = 10 / 3\n", "\n", "# Módulo (%)\n", "modulo = 15 % 4\n", "\n", "# Divisão Inteira (//)\n", "divisao_inteira = 20 // 3\n", "\n", "# Exponenciação (**)\n", "potencia = 2 ** 4\n", "\n", "print(\"Adição:\", soma)\n", "print(\"Subtração:\", subtracao)\n", "print(\"Multiplicação:\", multiplicacao)\n", "print(\"Divisão:\", divisao)\n", "print(\"Módulo:\", modulo)\n", "print(\"Divisão Inteira:\", divisao_inteira)\n", "print(\"Potência:\", potencia)\n", "```\n", "\n", "**Saída do Código:**\n", "```python\n", "Adição: 8\n", "Subtração: 3\n", "Multiplicação: 12\n", "Divisão: 3.3333333333333335\n", "Módulo: 3\n", "Divisão Inteira: 6\n", "Potência: 16\n", "```\n", "\n", "### Precedência dos Operadores Aritméticos\n", "\n", "A ordem de precedência dos operadores determina **quais operações serão realizadas primeiro** em uma expressão. A tabela abaixo resume essa hierarquia:\n", "\n", "| Operadores Matemáticos | Prioridade |\n", "|---|---|\n", "| Exponenciação | Alta (primeira) |\n", "| Multiplicação, Divisão e Módulo | Média |\n", "| Adição e Subtração | Baixa (última) |\n", "\n", "> Para alterar a ordem de execução, você pode usar parênteses `()`.\n", "\n", "**Exemplo de Precedência:**\n", "```python\n", "resultado1 = (2 + 3) * 4 # Aqui, somamos antes e depois multiplicamos\n", "print(resultado1) # 20\n", "\n", "resultado2 = 2 + 3 * 4 # Aqui, multiplicamos primeiro e depois somamos\n", "print(resultado2) # 14\n", "```\n", "\n", "**Exemplo de Combinação de Operadores:**\n", "```python\n", "resultado = 2 ** 3 + 4 * 5 - 10 / 2\n", "```\n", "Vamos entender passo a passo:\n", "1. **Exponenciação (`**`)**: `2 ** 3` resulta em **8**.\n", "2. **Multiplicação e Divisão (`*`, `/`)**: `4 * 5` resulta em **20** e `10 / 2` resulta em **5.0**.\n", "3. **Adição e Subtração (`+`, `-`)**: Agora, somamos e subtraímos na ordem: `8 + 20 = 28`, depois `28 - 5 = 23.0`.\n", "\n", "Resultado final:\n", "```python\n", "resultado = 23.0\n", "```\n", "\n", "### Operadores Unários\n", "\n", "Os operadores unários atuam em um único operando. Um exemplo comum é o operador de negação (`-`). Vamos ver como ele funciona com outros operadores:\n", "\n", "```python\n", "res_unario = -5 + 2 * 3\n", "```\n", "Aqui:\n", "- Primeiro aplicamos o operador unário `-` a **5**, resultando em **-5**.\n", "- Depois, multiplicamos **2 por 3**, resultando em **6**.\n", "- Finalmente, somamos **-5** com **6**, resultando em **1**.\n", "\n", "Resultado:\n", "```python\n", "res_unario = 1\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Operadores Relacionais\n", "\n", "Os operadores relacionais permitem a comparação entre valores, retornando um resultado booleano (`True` ou `False`). Essa capacidade é fundamental para controlar o fluxo de um programa e tomar decisões baseadas em condições. Vamos explorar como esses operadores funcionam e onde eles são mais usados:\n", "\n", "- **Instruções condicionais (`if`)**: Executam diferentes ações de acordo com o resultado da comparação.\n", "- **Comparação de strings**: Verifica se duas strings são iguais ou diferentes, como em validações de dados.\n", "- **Validação de dados**: Garante que valores fornecidos pelo usuário estejam dentro de limites específicos.\n", "- **Ordenação de listas**: Compara elementos de uma lista para ordená-los.\n", "- **Cálculos condicionais**: Usa comparações para decidir como realizar operações matemáticas.\n", "\n", "### Principais Operadores Relacionais\n", "\n", "| Operador | Símbolo | Descrição | Exemplo | Resultado |\n", "|-------------------|---------|------------------------------------------------------------|---------|-----------|\n", "| **Igualdade** | `==` | Retorna `True` se os operandos forem iguais. | `5 == 5` | `True` |\n", "| **Diferença** | `!=` | Retorna `True` se os operandos não forem iguais. | `5 != 3` | `True` |\n", "| **Menor que** | `<` | Retorna `True` se o operando esquerdo for menor que o direito| `3 < 5` | `True` |\n", "| **Maior que** | `>` | Retorna `True` se o operando esquerdo for maior que o direito| `3 > 5` | `False` |\n", "| **Menor ou igual** | `<=` | Retorna `True` se o operando esquerdo for menor ou igual ao direito| `3 <= 5` | `True` |\n", "| **Maior ou igual** | `>=` | Retorna `True` se o operando esquerdo for maior ou igual ao direito| `3 >= 5` | `False` |\n", "\n", "**Exemplos:**\n", "\n", "Aqui estão alguns exemplos simples de uso de operadores relacionais:\n", "\n", "```python\n", "# Comparando números\n", "numero1 = 10\n", "numero2 = 5\n", "\n", "igual_a = (numero1 == numero2)\n", "diferente_de = (numero1 != numero2)\n", "menor_que = (numero1 < numero2)\n", "maior_que = (numero1 > numero2)\n", "menor_ou_igual_a = (numero1 <= numero2)\n", "maior_ou_igual_a = (numero1 >= numero2)\n", "\n", "print(\"Igual a:\", igual_a)\n", "print(\"Diferente de:\", diferente_de)\n", "print(\"Menor que:\", menor_que)\n", "print(\"Maior que:\", maior_que)\n", "print(\"Menor ou igual a:\", menor_ou_igual_a)\n", "print(\"Maior ou igual a:\", maior_ou_igual_a)\n", "```\n", "\n", "**Saída do Código:**\n", "\n", "```python\n", "Igual a: False\n", "Diferente de: True\n", "Menor que: False\n", "Maior que: True\n", "Menor ou igual a: False\n", "Maior ou igual a: True\n", "```\n", "\n", "### Comparação de Strings\n", "\n", "As **strings** também podem ser comparadas. A comparação de strings segue a ordem lexicográfica (ordem alfabética):\n", "\n", "```python\n", "nome1 = \"João\"\n", "nome2 = \"Maria\"\n", "\n", "igual_a = (nome1 == nome2)\n", "diferente_de = (nome1 != nome2)\n", "\n", "print(\"Igual a:\", igual_a)\n", "print(\"Diferente de:\", diferente_de)\n", "```\n", "\n", "**Saída do Código:**\n", "\n", "```python\n", "Igual a: False\n", "Diferente de: True\n", "```\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Operadores Lógicos\n", "\n", "Os operadores lógicos em Python são usados para combinar condições e construir expressões booleanas mais complexas. Eles são fundamentais em várias situações de programação, como:\n", "\n", "- **Combinação de condições em instruções `if`:** Executa diferentes ações com base em combinações de resultados de comparações.\n", "- **Validação de dados complexos:** Verifica se várias condições são atendidas simultaneamente.\n", "- **Controle de fluxo do programa:** Direciona o programa de acordo com diferentes condições.\n", "- **Criação de algoritmos complexos:** Permite a combinação de múltiplas condições para realizar tarefas mais sofisticadas.\n", "\n", "**Principais Operadores Lógicos**\n", "\n", "| Operador | Símbolo | Descrição | Exemplo | Resultado | Precedência |\n", "|---|---|---|---|---|---|\n", "| **Negação** | `not` | Inverte o valor do operando. | `not True` | `False` | Alta |\n", "| **E lógico** | `and` | Retorna `True` se ambos os operandos forem `True`. | `True and False` | `False` | Média |\n", "| **Ou lógico** | `or` | Retorna `True` se pelo menos um dos operandos for `True`. | `True or False` | `True` | Baixa |\n", "\n", "### Precedência dos Operadores Lógicos\n", "\n", "Os operadores lógicos têm uma ordem de precedência que define como as expressões são avaliadas quando combinados. O operador `not` tem a maior precedência, seguido por `and` e, finalmente, `or`, com a menor precedência.\n", "\n", "Aqui estão exemplos que demonstram como a precedência funciona:\n", "\n", "```python\n", "# Exemplo 1: Sem parênteses\n", "result1 = True or True and False\n", "print(result1)\n", "\n", "# Exemplo 2: Com parênteses, alterando a precedência\n", "result2 = (True or True) and False\n", "print(result2)\n", "```\n", "**Saída do Código:**\n", "\n", "```python\n", "True\n", "False\n", "```\n", "\n", "**Explicação dos Resultados:**\n", "\n", "- No **primeiro exemplo**, sem parênteses, o operador `and` é avaliado antes do `or`, pois `and` tem uma precedência maior. Assim, a expressão **`True and False`** é avaliada primeiro, resultando em `False`. Em seguida, a expressão se torna **`True or False`**, o que resulta em `True`, já que o operador `or` retorna `True` se pelo menos um dos operandos for verdadeiro.\n", " \n", "- No **segundo exemplo**, o uso de parênteses altera a ordem de avaliação. A expressão dentro dos parênteses **`True or True`** é avaliada primeiro, resultando em `True`. Em seguida, temos a expressão **`True and False`**, que resulta em `False`, pois o operador `and` exige que ambos os operandos sejam `True` para retornar `True`.\n", "\n", "\n", "**Tabela Verdade do Operador `and`:**\n", "\n", "| A | B | A and B |\n", "|-------|-------|---------|\n", "| True | True | True |\n", "| True | False | False |\n", "| False | True | False |\n", "| False | False | False |\n", "\n", "**Tabela Verdade do Operador `or`:**\n", "\n", "| A | B | A or B |\n", "|-------|-------|---------|\n", "| True | True | True |\n", "| True | False | True |\n", "| False | True | True |\n", "| False | False | False |\n", "\n", "**Tabela Verdade do Operador `not`:**\n", "\n", "| A | not A |\n", "|-------|-------|\n", "| True | False |\n", "| False | True |\n", "\n", "**Exemplo: Verificando se um número é par e maior que 10**\n", "\n", "```python\n", "numero = int(input(\"Digite um número: \"))\n", "\n", "# E lógico: verifica se ambas as condições são verdadeiras\n", "par_e_maior_que_10 = (numero % 2 == 0) and (numero > 10)\n", "\n", "if par_e_maior_que_10:\n", " print(\"O número é par e maior que 10.\")\n", "else:\n", " print(\"O número não é par ou não é maior que 10.\")\n", "```\n", "\n", "**Saída do Código:**\n", "\n", "```python\n", "Digite um número: 12\n", "O número é par e maior que 10.\n", "```\n", "\n", "**Exemplo: Verificando se o usuário digitou \"sim\" ou \"não\"**\n", "\n", "```python\n", "resposta = input(\"Digite sim ou não: \").lower()\n", "\n", "# Ou lógico: verifica se pelo menos uma das condições é verdadeira\n", "resposta_valida = (resposta == \"sim\") or (resposta == \"não\")\n", "\n", "if resposta_valida:\n", " print(\"Resposta válida.\")\n", "else:\n", " print(\"Resposta inválida. Digite apenas 'sim' ou 'não'.\")\n", "```\n", "\n", "**Saída do Código:**\n", "\n", "```python\n", "Digite sim ou não: não\n", "Resposta válida.\n", "```\n", "\n", "**Exemplo: Uso do operador `not` para inverter uma condição**\n", "\n", "```python\n", "idade = int(input(\"Digite sua idade: \"))\n", "\n", "# Verificando se a idade não é maior ou igual a 18 (ou seja, é menor de 18)\n", "if not (idade >= 18):\n", " print(\"Você não é maior de idade.\")\n", "else:\n", " print(\"Você é maior de idade.\")\n", "```\n", "\n", "**Saída do Código:**\n", "\n", "```python\n", "Digite sua idade: 17\n", "Você não é maior de idade.\n", "```\n", "\n", "**Observações Relevantes**\n", "\n", "- **Precedência dos Operadores:** O operador `not` tem a maior precedência, seguido de `and`, e depois `or`. Para controlar a ordem de execução, use parênteses.\n", " \n", "- **Uso de Tipos Booleanos:** Os operadores lógicos operam apenas em valores booleanos (`True` ou `False`). Certifique-se de que as condições estejam retornando valores corretos para evitar erros de tipo.\n", "\n", "- **Negação:** O operador `not` pode ser usado para negar o resultado de qualquer expressão booleana.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Operadores de Associação\n", "\n", "Os operadores de associação em Python são utilizados para verificar se um valor está presente em uma sequência. Eles são muito úteis em diversas situações de programação, como:\n", "\n", "- **Verificação de elementos em coleções:** Busca valores em listas, tuplas ou strings.\n", "- **Validação de dados:** Verifica se uma entrada está dentro de um conjunto de valores válidos.\n", "- **Filtragem de dados:** Seleciona elementos com base em critérios de pertencimento.\n", "- **Controle de fluxo do programa:** Direciona o programa com base na presença ou ausência de elementos.\n", "\n", "**Principais Operadores de Associação**\n", "\n", "| Operador | Símbolo | Descrição | Exemplo | Resultado | \n", "|---|---|---|---|---|\n", "| **Pertence** | `in` | Verifica se um valor está presente na sequência. | `'a' in 'python'` | `False` |\n", "| **Não pertence** | `not in` | Verifica se um valor não está presente na sequência. | `'a' not in 'python'` | `True` |\n", "\n", "### Exemplos de Uso\n", "\n", "Os operadores de associação podem ser utilizados com diferentes tipos de sequências em Python. Aqui estão alguns exemplos práticos:\n", "\n", "**Exemplo: Verificando valores válidos em um menu**\n", "\n", "```python\n", "opcoes_validas = ['1', '2', '3', '4']\n", "opcao = input(\"Digite uma opção (1-4): \")\n", "\n", "if opcao in opcoes_validas:\n", " print(\"Opção válida!\")\n", "else:\n", " print(\"Opção inválida! Digite um número de 1 a 4.\")\n", "```\n", "\n", "**Saída do Código:**\n", "\n", "```python\n", "Digite uma opção (1-4): 5\n", "Opção inválida! Digite um número de 1 a 4.\n", "```\n", "\n", "**Exemplo: Verificando vogais em uma string**\n", "\n", "```python\n", "letra = input(\"Digite uma letra: \").lower()\n", "vogais = 'aeiou'\n", "\n", "if letra in vogais:\n", " print(f\"A letra '{letra}' é uma vogal.\")\n", "else:\n", " print(f\"A letra '{letra}' é uma consoante.\")\n", "```\n", "\n", "**Saída do Código:**\n", "\n", "```python\n", "Digite uma letra: E\n", "A letra 'e' é uma vogal.\n", "```\n", "\n", "**Exemplo: Verificando elementos em uma lista de permissões**\n", "\n", "```python\n", "usuarios_permitidos = ['admin', 'gerente', 'supervisor']\n", "usuario = input(\"Digite seu nível de acesso: \").lower()\n", "\n", "if usuario not in usuarios_permitidos:\n", " print(\"Acesso negado!\")\n", "else:\n", " print(\"Acesso permitido!\")\n", "```\n", "\n", "**Saída do Código:**\n", "\n", "```python\n", "Digite seu nível de acesso: visitante\n", "Acesso negado!\n", "```\n", "\n", "**Observações Relevantes**\n", "\n", "- **Tipos de Sequências:** Os operadores de associação funcionam com strings, listas, tuplas, sets e dicionários (neste último caso, a verificação é feita nas chaves).\n", "\n", "- **Case Sensitive:** Em strings, a verificação é case sensitive. Para ignorar maiúsculas/minúsculas, converta a string para minúsculo ou maiúsculo antes da comparação.\n", "\n", "- **Performance:** Em listas grandes, usar o operador `in` pode ser menos eficiente que outras estruturas de dados como sets ou dicionários.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Operadores de Atribuição\n", "\n", "Os operadores de atribuição são usados para armazenar valores em variáveis e atualizar esses valores posteriormente. Eles são essenciais na manipulação de dados e ajudam a criar programas mais eficientes. A tabela abaixo apresenta os principais operadores de atribuição em Python, seus símbolos, descrições, exemplos e resultados:\n", "\n", "| Operador | Descrição | Exemplo | Resultado |\n", "|---|---|---|---|\n", "| `=` | Atribuição simples | `x = 5` | `x` recebe o valor `5` |\n", "| `+=` | Soma e atribui | `a += 2` | `a` é incrementado em `2` (equivalente a `a = a + 2`) |\n", "| `-=` | Subtrai e atribui | `b -= 3` | `b` é decrementado em `3` (equivalente a `b = b - 3`) |\n", "| `*=` | Multiplica e atribui | `c *= 5` | `c` é multiplicado por `5` (equivalente a `c = c * 5`) |\n", "| `/=` | Divide e atribui | `d /= 2` | `d` é dividido por `2` (equivalente a `d = d / 2`) |\n", "| `%=` | Calcula o módulo e atribui | `e %= 4` | `e` recebe o resto da divisão por `4` (equivalente a `e = e % 4`) |\n", "\n", "Todos os operadores de atribuição em Python têm **baixa precedência**. Isso significa que, em uma expressão com múltiplos operadores de atribuição, eles serão avaliados da **direita para a esquerda**.\n", "\n", "Embora Python não tenha operadores de incremento (`++`) e decremento (`--`) como algumas outras linguagens, o mesmo efeito pode ser alcançado usando `x += 1` (para `x++`) e `x -= 1` (para `x--`).\n", "\n", "**Exemplos:**\n", "\n", "```python\n", "# Atribuição simples\n", "numero = 10\n", "nome = \"João\"\n", "\n", "# Atribuição com operações aritméticas\n", "valor = 5\n", "valor += 3 # Equivalente a: valor = valor + 3\n", "\n", "resultado = 15\n", "resultado /= 3 # Equivalente a: resultado = resultado / 3\n", "\n", "# Incremento e decremento simulados\n", "x = 10\n", "x += 1 # Equivalente a x++\n", "x -= 1 # Equivalente a x--\n", "\n", "# Exibindo os valores\n", "print(\"Número:\", numero)\n", "print(\"Nome:\", nome)\n", "print(\"Valor:\", valor)\n", "print(\"Resultado:\", resultado)\n", "print(\"Valor final de x:\", x)\n", "```\n", "\n", "**Saída do Código:**\n", "\n", "```python\n", "Número: 10\n", "Nome: João\n", "Valor: 8\n", "Resultado: 5.0\n", "Valor final de x: 10\n", "```\n", "\n", "Os operadores de atribuição combinados com operações aritméticas são uma maneira prática de realizar cálculos e atribuir o resultado em uma única etapa. Lembre-se sempre da ordem de precedência dos operadores para garantir o comportamento esperado das expressões. Além disso, certifique-se de que o tipo da variável seja compatível com o valor atribuído.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Operações com Bits\n", "\n", "As operações a nível de bits são fundamentais em computação, especialmente em áreas como criptografia, manipulação de dados, compressão e comunicação com hardware. Elas permitem que os programadores manipulem dados de forma eficiente, controlando diretamente os bits individuais que compõem um número. Isso é útil em situações onde o desempenho e o uso de memória são críticos, como em sistemas embarcados, algoritmos de processamento de sinais e computação gráfica.\n", "\n", "### Inversão Bit a Bit (`~`)\n", "\n", "O operador unário de inversão de bits, representado pelo caractere `~`, inverte cada bit em uma representação binária de um número, transformando 0 em 1 e 1 em 0. Essa operação é particularmente útil em manipulações de bits de baixo nível.\n", "\n", "**Exemplo de Inversão de Bits:**\n", "\n", "```python\n", "# Número original em decimal\n", "numero_original = 5\n", "\n", "# Representação binária do número original\n", "binario_original = bin(numero_original)\n", "\n", "# Inverte os bits usando o operador ~\n", "numero_invertido = ~numero_original\n", "\n", "# Representação binária do número invertido\n", "binario_invertido = bin(numero_invertido)\n", "\n", "# Exibindo os resultados\n", "print(\"Número original:\", numero_original)\n", "print(\"Representação binária do número original:\", binario_original)\n", "print(\"Número invertido:\", numero_invertido)\n", "print(\"Representação binária do número invertido:\", binario_invertido)\n", "```\n", "\n", "**Saída do Código:**\n", "\n", "```python\n", "Número original: 5\n", "Representação binária do número original: 0b101\n", "Número invertido: -6\n", "Representação binária do número invertido: -0b110\n", "```\n", "\n", "Ao inverter os bits de um número, o operador `~` atua diretamente sobre a sua representação binária. Por exemplo, o número decimal `5` é representado como `0b101` em binário. Ao inverter os bits, `0` se torna `1` e `1` se torna `0`, resultando em `-0b110`. O resultado final é `-6` porque Python utiliza a **representação em complemento de dois** para números negativos, o que faz com que a inversão de bits gere um número negativo.\n", "\n", "### Conversão de Binário para Decimal\n", "\n", "Além de inverter bits, é essencial saber como converter um número binário para sua forma decimal. Isso pode ser feito facilmente com a função `int()` e o parâmetro de base 2.\n", "\n", "**Exemplo: Conversão de Binário para Decimal a partir de uma String**\n", "\n", "```python\n", "# Número binário representado como string\n", "binario = \"1101\"\n", "\n", "# Convertendo para decimal\n", "numero_decimal = int(binario, 2)\n", "\n", "print(\"O número decimal é:\", numero_decimal)\n", "```\n", "\n", "**Saída do Código:**\n", "\n", "```python\n", "O número decimal é: 13\n", "```\n", "\n", "Neste exemplo, a string `\"1101\"` é interpretada como um número binário e convertida para o valor decimal `13`.\n", "\n", "**Exemplo: Conversão de Representação Binária com Prefixo `0b`**\n", "\n", "Se você tiver uma representação binária gerada pela função `bin()`, que inclui o prefixo `\"0b\"`, a conversão pode ser feita diretamente, conforme mostrado a seguir:\n", "\n", "```python\n", "# Número original em decimal\n", "numero_original = 28\n", "\n", "# Representação binária com prefixo '0b'\n", "binario_original = bin(numero_original) # '0b11100'\n", "\n", "# Convertendo a representação binária de volta para decimal\n", "numero_convertido = int(binario_original, 2)\n", "\n", "print(\"Número original:\", numero_original)\n", "print(\"Representação binária:\", binario_original)\n", "print(\"Número convertido de volta para decimal:\", numero_convertido)\n", "```\n", "\n", "**Saída do Código:**\n", "\n", "```python\n", "Número original: 28\n", "Representação binária: 0b11100\n", "Número convertido de volta para decimal: 28\n", "```\n", "\n", "Mesmo com o prefixo `\"0b\"`, a função `int()` é capaz de converter corretamente o valor binário de volta para o decimal.\n", "\n", "### Deslocamento de Bits\n", "\n", "Além da inversão e conversão de bits, o deslocamento de bits é uma operação comum que pode otimizar cálculos em determinadas situações. Esses deslocamentos são úteis em operações de multiplicação e divisão rápida, em sistemas que precisam de eficiência de desempenho.\n", "\n", "**Números com e sem Sinal**\n", "\n", "Antes de entender o deslocamento de bits, é importante compreender a diferença entre números com e sem sinal:\n", "\n", "- **Números sem sinal** (unsigned): Representam apenas valores não negativos. Cada bit é usado para o valor numérico, o que permite representar uma maior faixa de números positivos.\n", "- **Números com sinal** (signed): Permitem a representação de valores negativos e positivos. Normalmente, o bit mais à esquerda (bit de maior peso) é usado como o \"bit de sinal\", indicando se o número é positivo ou negativo.\n", "\n", "Em Python, a distinção entre números com e sem sinal não é explícita para tipos inteiros, pois os inteiros são de precisão arbitrária. No entanto, ao trabalhar com deslocamentos de bits, é importante ter em mente como os números são tratados internamente, especialmente ao usar linguagens de programação com tipos numéricos fixos.\n", "\n", "**Operadores de Deslocamento**\n", "\n", "- **Deslocamento à Esquerda (`<<`)**: Este operador move os bits para a esquerda, adicionando zeros à direita. Cada deslocamento à esquerda multiplica o número por 2.\n", "\n", " ```python\n", " numero = 5\n", " resultado_esquerda = numero << 1 # Desloca 1 posição à esquerda\n", " print(\"Resultado:\", resultado_esquerda)\n", " ```\n", "\n", " **Saída do Código:**\n", "\n", " ```python\n", " Resultado: 10\n", " ```\n", "\n", " Neste caso, `5 << 1` resulta em `10`, que é equivalente a multiplicar `5` por `2`.\n", "\n", "- **Deslocamento à Direita (`>>`)**: Este operador move os bits para a direita. Para **números com sinal**, o bit mais à esquerda (bit de sinal) é mantido, preservando o sinal do número, enquanto para **números sem sinal**, os bits deslocados para a direita são substituídos por zeros. Cada deslocamento à direita divide o número por 2.\n", "\n", " ```python\n", " numero = 5\n", " resultado_direita = numero >> 1 # Desloca 1 posição à direita\n", " print(\"Resultado:\", resultado_direita)\n", " ```\n", "\n", " **Saída do Código:**\n", "\n", " ```python\n", " Resultado: 2\n", " ```\n", "\n", " Aqui, `5 >> 1` resulta em `2`, que é equivalente a dividir `5` por `2`.\n", "\n", "Operações a nível de bits, como inversão e deslocamento, são essenciais para a manipulação eficiente de dados e são amplamente utilizadas em áreas que exigem um controle preciso sobre o processamento de informações. Entender a distinção entre números com e sem sinal, assim como as operações de deslocamento, é crucial para otimizar cálculos em sistemas de baixo nível." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Precedência dos Operadores (Tabela)\n", "Por fim, a tabela a seguir apresenta a ordem de precedência dos principais tipos de operadores em Python, da maior para a menor precedência:\n", "\n", "| Tipo de Operador | Precedência | Exemplo | Descrição |\n", "|---|---|---|---|\n", "| **Parênteses** | Mais alta | `(2 + 3) * 4` | Agrupa expressões |\n", "| **Exponenciação** | Alta | `2 ** 3` | Potenciação |\n", "| **Unário** | Alta | `-x`, `~x`, `not x` | Negação e complemento |\n", "| **Deslocamento de Bits** | Alta | `x << 1`, `y >> 2` | Operações com bits |\n", "| **Multiplicação e Divisão** | Média-alta | `2 * 3`, `4 / 2`, `5 // 2`, `6 % 2` | Operações aritméticas |\n", "| **Adição e Subtração** | Média | `2 + 3`, `4 - 1` | Operações aritméticas |\n", "| **Operadores de Associação** | Média-baixa | `x in lista`, `y not in tupla` | Verificação de pertencimento |\n", "| **Comparação** | Baixa | `2 < 3`, `4 >= 1`, `5 == 5`, `6 != 3` | Comparações relacionais |\n", "| **Operador and** | Baixa | `x and y` | Operação lógica AND |\n", "| **Operador or** | Mais baixa | `x or y` | Operação lógica OR |\n", "| **Atribuição** | Mais baixa | `x = 2`, `y += 3` | Atribuição de valores |\n", "\n", "Notas importantes:\n", "- Operadores na mesma linha têm a mesma precedência\n", "- Quando operadores têm a mesma precedência, a avaliação é feita da esquerda para a direita\n", "- Use parênteses para garantir a ordem de avaliação desejada\n", "- A precedência pode ser sobrescrita usando parênteses" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": { "id": "gb8mmUPo9iil" }, "source": [ "## Exercícios\n", "\n", "\"Antes de começar os exercícios, é importante notar que para testes com múltiplas entradas em uma mesma linha, é útil utilizar o método `.split()`. Este método divide a string recebida pelo `input()` em substrings, utilizando espaços em branco como delimitadores. Ele retorna uma lista contendo as substrings resultantes.\n", "\n", "Por exemplo, para uma entrada: 1 1 6 6 4 4\n", "```python\n", "entrada = input().split()\n", "print(entrada)\n", "```\n", "Ao executar o código acima com a entrada `1 1 6 6 4 4`, a saída será:\n", "```python\n", "['1', '1', '6', '6', '4', '4']\n", "```\n", "\n", "---\n", "\n", "1. Dada a expressão matemática: $a = 4 * (2 + 3) - 7$. Crie uma variável chamada `a` e atribua a ela o resultado dessa expressão. Em seguida, crie uma variável chamada `b` e atribua a ela o valor de `a` multiplicado por 2. Por fim, imprima os valores de `a` e `b`.\n", "\n", "```python\n", "# Teste 1\n", "Entrada: Sem entrada\n", "Saída:\n", "O valor de 'a' é: 13\n", "O valor de 'b' é: 26\n", "``` \n", "\n", "2. Escreva um programa que solicita ao usuário um número inteiro positivo entre 100 e 1000. Em seguida, o programa deve calcular o resto da divisão desse número por 5, armazenar o resultado em uma variável chamada resto e imprimir este valor.\n", "\n", "Certifique-se de que o programa lide adequadamente com entradas inválidas. Caso o usuário insira um número negativo ou fora do intervalo especificado, exiba a seguinte mensagem de erro: \"Por favor, insira um número inteiro positivo entre 100 e 1000.\"\n", "\n", "```python\n", "# Teste 1\n", "Entrada: 172\n", "Saída: O resto da divisão de 172 por 5 é 2.\n", "\n", "# Teste 2\n", "Entrada: -10\n", "Saída: Por favor, insira um número inteiro positivo entre 100 e 1000.\n", "\n", "# Teste 3\n", "Entrada: 2000\n", "Saída: Por favor, insira um número inteiro positivo entre 100 e 1000.\n", "\n", "# Teste 4\n", "Entrada: 500\n", "Saída: O resto da divisão de 500 por 5 é 0.\n", "```\n", "\n", "3. Escreva um programa que converta uma temperatura de Celsius para Fahrenheit. Utilize a fórmula: $F = \\frac{9}{5} * C + 32$.\n", "\n", "- Solicite ao usuário que digite a temperatura em Celsius.\n", "- Em seguida, converta a temperatura digitada para Fahrenheit utilizando a fórmula fornecida.\n", "- Por fim, exiba na tela o resultado da conversão para o usuário, formatado com 2 casas decimais.\n", "\n", "```python\n", "# Teste 1\n", "Entrada: 20.5\n", "Saída: A temperatura em Fahrenheit é: 68.90\n", "\n", "# Teste 2\n", "Entrada: 0.75\n", "Saída: A temperatura em Fahrenheit é: 33.35\n", "```\n", "\n", "4. Escreva um programa que recebe na entrada um número inteiro entre 10 e 20. O programa deverá converter esse número para sua representação binária, removendo o prefixo `'0b'` da conversão. Em seguida, cada bit dessa representação binária será salvo em uma lista, onde cada posição da lista conterá um dos bits. Por fim, o programa deverá imprimir o resultado.\n", "\n", "```python\n", "# Teste 1\n", "Entrada: 10\n", "Saída: ['1', '0', '1', '0']\n", "\n", "# Teste 2\n", "Entrada: 16\n", "Saída: ['1', '0', '0', '0', '0']\n", "\n", "# Teste 3\n", "Entrada: 34\n", "Saída: O número inserido não está dentro do intervalo permitido.\n", "```\n", "\n", "5. Utilizando tuplas, você deve receber as coordenadas de um retângulo no plano cartesiano, onde `(x_min, y_min)` representa o canto inferior esquerdo e `(x_max, y_max)` representa o canto superior direito. Além disso, você tem um ponto representado por um par de coordenadas `(x, y)`.\n", "\n", "Sua tarefa é escrever um programa que determine se o ponto está dentro, tocando na borda ou fora do retângulo. O programa deve imprimir uma mensagem na saída padrão indicando o resultado da verificação.\n", "\n", "Veja o exemplo didático do desenho ASCII para o Teste 1:\n", "- O `+` representa os cantos do retângulo.\n", "- O `.` representa o ponto.\n", "- As coordenadas do retângulo são `(x_min, y_min) = (1,1)` e `(x_max, y_max) = (6,6)`.\n", "- As coordenadas do ponto são `(x, y) = (4,4)`.\n", "\n", "```markdown\n", "7 | \n", "6 | +--------------+ (6,6)\n", "5 | | |\n", "4 | | .(4,4) |\n", "3 | | |\n", "2 | | |\n", "1 | +--------------+\n", "0 | (1,1) \n", " -+--+--+--+--+--+--+--+\n", " 0 1 2 3 4 5 6 7\n", "\n", "```\n", "\n", "```python\n", "# Teste 1\n", "Entrada: 1 1 6 6 4 4\n", "Saída: O ponto está dentro do retângulo.\n", "\n", "# Teste 2\n", "Entrada: 1 1 6 6 6 6\n", "Saída: O ponto está tocando a borda do retângulo.\n", "\n", "# Teste 3\n", "Entrada: 1 1 6 6 0 1\n", "Saída: O ponto está fora do retângulo.\n", "\n", "# Teste 4\n", "Entrada: 1 1 6 6 1 7\n", "Saída: O ponto está fora do retângulo.\n", "\n", "# Teste 5\n", "Entrada: 1 1 6 6 6 1\n", "Saída: O ponto está tocando a borda do retângulo.\n", "\n", "# Teste 6\n", "Entrada: 1 1 6 6 4 6\n", "Saída: O ponto está tocando a borda do retângulo.\n", "```\n", "\n", "6. Desenvolva um sistema de autenticação que utilize um dicionário chamado `usuarios_senhas` para armazenar os nomes e as senhas de dois usuários. O programa deve solicitar que o usuário insira seu nome de usuário e senha. Em seguida, o sistema deve verificar se as credenciais inseridas correspondem às armazenadas no dicionário. Se as credenciais estiverem corretas, o programa deve exibir uma mensagem de “Login bem-sucedido! Bem-vindo, usuário.”. Caso contrário, deve informar ao usuário \"Acesso negado. Credenciais inválidas.\".\n", "\n", "Obs: Serão armazenados apenas três usuários.\n", "\n", "```python\n", "# Teste 1\n", "Entrada: usuario1 senha123 usuario2 abc456 usuario3 123456 usuario1 senha123\n", "Saída: >> Login bem-sucedido! Bem-vindo, usuario1.\n", "\n", "# Teste 2\n", "Entrada: usuario1 senha143 usuario2 abc452 usuario3 654321 usuario2 123abc\n", "Saída: >> Acesso negado. Credenciais inválidas.\n", "```\n", "7. Você é um biólogo trabalhando em um parque natural e está encarregado de monitorar três espécies de aves migratórias. Cada espécie tem um conjunto de ilhas preferidas para nidificação durante a temporada de migração. As preferências das espécies são as seguintes:\n", "\n", "- **Espécie 1**: Prefere as ilhas com IDs de 1 a 10.\n", "- **Espécie 2**: Prefere as ilhas com IDs de 6 a 17.\n", "\n", "Algumas ilhas são compartilhadas entre as espécies, o que pode levar à competição por recursos. Seu trabalho é identificar quais ilhas são compartilhadas para implementar medidas de conservação. Dessa forma, dada uma entrada do usuário correspondente ao ID de uma das ilhas, verifique se essa ilha específica é uma área de competição ou se é exclusiva de uma das espécies.\n", "\n", "```python\n", "# Teste 1\n", "Entrada: 2\n", "Saída: Ilha 2 é exclusiva da Espécie 1. \n", "Portanto, não é compartilhada com outras espécies.\n", "\n", "# Teste 2\n", "Entrada: 6\n", "Saída: Ilha 6 é compartilhada entre espécie(s):1 2.\n", "\n", "# Teste 3\n", "Entrada: 10\n", "Saída: Ilha 10 é compartilhada entre espécie(s):1 2.\n", "\n", "# Teste 4\n", "Entrada: 17\n", "Saída: \n", "Ilha 17 é exclusiva da Espécie 2. \n", "Portanto, não é compartilhada com outras espécies.\n", "```\n", "\n", "8. Auxiliando o Hacker Neo a Desvendar a Verdade Sobre a Realidade.\n", "\n", "**História da Matrix:**\n", "Neo, um hacker talentoso, vive uma vida dupla. No mundo que ele conhece, ele é um programador comum. Mas, e se existisse uma realidade escondida, uma verdade que ele nunca imaginou?\n", "\n", "Após ser contatado por Morpheus, Neo se depara com uma escolha crítica: tomar a pílula vermelha e desvendar a verdade, ou tomar a pílula azul e continuar vivendo sua vida como sempre.\n", "\n", "**Fases do Programa:**\n", "\n", "**Fase 1: A Escolha** ● ●\n", "- Neo deve escolher entre a pílula vermelha e a pílula azul. A escolha é feita através de um input do usuário:\n", " - Se o usuário digitar \"vermelha\", Neo avança para a fase 2.\n", " - Se o usuário digitar \"azul\", Neo continua vivendo sua vida normal e o programa termina.\n", "\n", "**Fase 2: Desvendando a Realidade**\n", "- Neo precisa questionar a realidade em que vive. Ele deve responder a três perguntas:\n", " - A realidade que você conhece é real? (Sim ou Não)\n", " - Existe uma realidade escondida? (Sim ou Não)\n", " - Você quer desvendar a verdade? (Sim ou Não)\n", "\n", "**Fase 3: Explorando a Verdade**\n", "- Se Neo responder \"Sim\" a todas as perguntas da fase 2, ele terá acesso a informações sobre a verdade, e o programa termina com uma mensagem de sucesso.\n", "- Se Neo responder \"Não\" a qualquer uma das perguntas da fase 2, ele continua vivendo sua vida normal, e o programa termina com uma mensagem de que a escolha é dele.\n", "\n", "**Exemplos de Teste:**\n", "\n", "```python\n", "# Teste 1\n", "Entrada: Vermelha Sim Não Sim\n", "Saída: A escolha é sua, Neo continua vivendo sua vida normal.\n", "\n", "# Teste 2\n", "Entrada: Azul\n", "Saída: Neo continua vivendo sua vida normal.\n", "\n", "# Teste 3\n", "Entrada: Vermelha Não Sim Sim \n", "Saída: A escolha é sua, Neo continua vivendo sua vida normal.\n", "\n", "# Teste 4\n", "Entrada: Vermelha Sim Sim Sim\n", "Saída: Neo terá acesso a informações sobre a verdade.\n", "```\n", "\n", "9. Você é um fotógrafo profissional. Durante um trabalho, você se depara com um lago cristalino cercado por imensas montanhas. Seu objetivo é capturar uma foto aérea épica do lago, utilizando um drone. Para garantir a melhor perspectiva, você precisa determinar a altura ideal de voo do drone. Para isso, será necessário saber a distância horizontal entre você e a margem do lago, bem como a altura vertical que deseja alcançar com o drone.\n", "\n", "A hipotenusa, que representa a distância diagonal percorrida pelo drone, pode ser calculada utilizando o Teorema de Pitágoras:\n", "\n", "$ Hipotenusa = \\sqrt(CatetoAdjacente^2 + CatetoOposto^2) $\n", "\n", "Seu programa receberá como entrada, em metros, o comprimento do cateto adjacente e do cateto oposto, e calculará a hipotenusa correspondente.\n", "\n", "**Exemplos de Teste:**\n", "\n", "```python\n", "# Teste 1\n", "Entrada: 50 30\n", "Saída: 58.00 metros\n", "\n", "# Teste 2\n", "Entrada: 40 20\n", "Saída: 44.72 metros\n", "\n", "# Teste 3\n", "Entrada: 70 50\n", "Saída: 86.02 metros\n", "```\n", "\n", "10. Um artesão está trabalhando em duas peças: um cone de metal e um paralepípedo de madeira. Para ajudá-lo em seu projeto, você precisa desenvolver um programa que receba as informações de dimensões em cm desses objetos e calcule seus volumes e massas.\n", "\n", "- Receber na entrada as seguintes informações para o cone: Altura e Raio.\n", "- Em seguida, receber as informações para o paralepípedo: Altura, Largura e Comprimento.\n", "\n", "Considerando as fórmulas matemáticas adequadas para calcular o volume de cada objeto:\n", "\n", "Volume do Cone: $V_{\\text{cone}} = \\frac{1}{3} \\pi r^2 h$\n", "\n", "Volume do Paralepípedo: $ V_{\\text{paralel}} = l \\times w \\times h $\n", "\n", "Calcule a massa de cada objeto, considerando que a densidade do metal é de 8 g/cm³ e a densidade da madeira é de 0,5 g/cm³. Qual dos dois objetos, cone ou paralepípedo, é mais pesado? Considere que eles possuem o mesmo peso se a diferença entre as massas for menor do que 5g.\n", "\n", "**Exemplos de Teste:**\n", "\n", "```python\n", "# Teste 1\n", "Entrada: 10 5 19 8 6\n", "Saída: O cone é mais pesado com 2094.4g.\n", "\n", "# Teste 2\n", "Entrada: 4 2 10 8 8\n", "Saída: O paralelepípedo é mais pesado com 320.0g.\n", "\n", "# Teste 3\n", "Entrada: 10 2.44 10 10 10\n", "Saída: O paralepípedo e o cone possuem o mesmo peso.\n", "\n", "# Teste 4\n", "Entrada: 20 4.886 20 20 20\n", "Saída: O paralepípedo e o cone possuem o mesmo peso.\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 }