{ "cells": [ { "cell_type": "markdown", "metadata": { "id": "ULxWGdhVqcRt" }, "source": [ "# Capítulo 2: Tipos de dados e Estruturas Condicionais\n", "\n" ] }, { "cell_type": "markdown", "metadata": { "id": "euhixBFzp2a9" }, "source": [ "\"Cap\n", "\n", "Variáveis são essenciais para armazenar informações durante a execução de um programa. Compreender os tipos de dados é fundamental para escrever programas funcionais e legíveis, pois cada tipo de dado é projetado para armazenar um tipo específico de informação, como inteiros, números reais, strings e booleanos. Sempre que precisar de mais detalhes sobre os tópicos, é recomendado acessar a documentação oficial do Python {cite}`python_docs`.\n", "\n", "## Definindo Variáveis \n", "\n", "Uma variável é um identificador que representa um valor. A declaração de uma variável é feita usando o operador de atribuição (`=`). Por exemplo, a linha a seguir cria uma variável chamada `nome` e atribui o valor \"Maria\" a ela:\n", "\n", "```python\n", "nome = \"Maria\"\n", "```\n", "Para acessar o valor armazenado em uma variável, basta utilizar o seu nome. O exemplo a seguir mostra como imprimir o valor armazenado na variável `nome`:\n", "\n", "```python\n", "print(nome)\n", "```\n", "**Saída do Código**\n", "```\n", "Maria\n", "```\n", "\n", "## Formatando a Saída de Dados \n", "Vamos começar pela formatação, pois isso vai auxiliar no entendimento de todos os exemplos a seguir. A função `print()` é usada para exibir informações na tela, podendo imprimir strings, números e outros tipos de dados. \n", "\n", "**Exibindo uma Mensagem Simples** \n", "```python\n", "print(\"Olá, mundo!\")\n", "```\n", "**Saída do Código**\n", "```\n", "Olá, mundo!\n", "```\n", "\n", "**Mostrando Informações Concatenadas com Vírgulas** \n", "```python\n", "nome = \"Maria\"\n", "idade = 30\n", "print(\"O nome dela é\", nome, \"e ela tem\", idade, \"anos.\")\n", "```\n", "**Saída do Código**\n", "```\n", "O nome dela é Maria e ela tem 30 anos.\n", "```\n", "Nesse exemplo, as variáveis `nome` e `idade` são concatenadas com strings e separadas por vírgulas para criar a mensagem final. O `print()` insere automaticamente um espaço entre os elementos.\n", "\n", "**Personalizando o Separador (`sep`)** \n", "Podemos modificar o separador usando o argumento `sep`, que define o que será inserido entre os itens: \n", "```python\n", "print(\"Maria\", \"30 anos\", sep=\" - \")\n", "```\n", "**Saída do Código**\n", "```\n", "Maria - 30 anos\n", "```\n", "Por padrão, o separador é um espaço (`\" \"`), mas podemos alterá-lo conforme necessário.\n", "\n", "**Utilizando f-strings**\n", "\n", "```python\n", "nome = \"Maria\"\n", "idade = 30\n", "print(f\"O nome dela é {nome} e ela possui {idade} anos.\")\n", "```\n", "**Saída do Código**\n", "```\n", "O nome dela é Maria e ela possui 30 anos.\n", "```\n", "As f-strings permitem incorporar diretamente as variáveis dentro da string, tornando o código mais legível e conciso.\n", "\n", "**Exibindo Informações em Múltiplas Linhas com `\\n`**\n", "\n", "```python\n", "nome = \"Maria\"\n", "idade = 30\n", "print(\"O nome dela é\", nome, \"\\ne ela possui\", idade, \"anos.\")\n", "\n", "# Usando f-string para obter a mesma saída\n", "print(f\"O nome dela é {nome}\\ne ela possui {idade} anos.\")\n", "```\n", "**Saída do Código**\n", "```\n", "O nome dela é Maria \n", "e ela possui 30 anos.\n", "```\n", "A quebra de linha (`\\n`) é utilizada para formatar a saída em múltiplas linhas.\n", "\n", "**Formatando Números com Casas Decimais**\n", "\n", "```python\n", "valor = 123.456789\n", "print(f\"O valor formatado é: {valor:.2f}\")\n", "```\n", "\n", "**Saída do Código**\n", "```\n", "O valor formatado é: 123.46\n", "```\n", "\n", "Neste caso, o número armazenado na variável `valor` é formatado para exibir apenas duas casas decimais usando a expressão `:.2f` dentro da f-string.\n", "\n", "O arredondamento segue a regra do **round half to even**, que arredonda números com dígito final 5 para o número par mais próximo. No entanto, nesse caso específico, como `123.456789` está mais próximo de `123.46` do que de `123.45`, o arredondamento ocorre de maneira intuitiva." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Números Inteiros\n", "\n", "O tipo de dado **inteiro** é utilizado para representar números inteiros, tanto positivos quanto negativos, como `1`, `2`, `3`, `-1`, `-2`, `-3`, entre outros. Esses valores são usados para expressar quantidades e índices em programação, desempenhando um papel importante em diversas aplicações.\n", "\n", "**Exemplos de Uso de Inteiros**\n", "\n", "```python\n", "# Declaração e inicialização de uma variável do tipo inteiro\n", "x = 10\n", "print(f\"O valor de x é: {x}, e seu tipo é: {type(x)}\")\n", "\n", "# Atribuição de um novo valor a uma variável do tipo inteiro\n", "x = 20\n", "print(f\"O novo valor de x é: {x}, e seu tipo continua sendo: {type(x)}\")\n", "\n", "# Soma de dois inteiros\n", "resultado = x + 10\n", "print(f\"O resultado da soma é: {resultado}, e seu tipo é: {type(resultado)}\")\n", "```\n", "\n", "**Saída do Código**\n", "\n", "```\n", "O valor de x é: 10, e seu tipo é: \n", "O novo valor de x é: 20, e seu tipo continua sendo: \n", "O resultado da soma é: 30, e seu tipo é: \n", "```\n", "\n", "No exemplo acima, a variável `x` é inicialmente declarada e inicializada com o valor `10`. Em seguida, `x` recebe um novo valor, `20`, mantendo seu tipo `int`. Por fim, a operação `x + 10` resulta em `30`, também do tipo `int`, que é impresso na tela." ] }, { "cell_type": "markdown", "metadata": { "id": "qzfww3aOmwmp" }, "source": [ "### Números de Ponto Flutuante \n", "O tipo de dado **ponto flutuante**, representado pelo tipo `float` em Python, é utilizado para expressar valores decimais. \n", "\n", "**Exemplos de Uso:** \n", "\n", "```python \n", "# Declaração e inicialização de uma variável do tipo float \n", "y = 3.14 \n", "print(f\"O valor de y é: {y}, e seu tipo é: {type(y)}\") \n", "\n", "# Atribuição de um novo valor a uma variável do tipo float \n", "y = 2.5 \n", "print(f\"O novo valor de y é: {y}, e seu tipo continua sendo: {type(y)}\") \n", "\n", "# Subtração de dois floats \n", "resultado = y - 1.0 \n", "print(f\"O resultado da subtração é: {resultado}, e seu tipo é: {type(resultado)}\") \n", "``` \n", "\n", "**Saída do Código**\n", "``` \n", "O valor de y é: 3.14, e seu tipo é: \n", "O novo valor de y é: 2.5, e seu tipo continua sendo: \n", "O resultado da subtração é: 1.5, e seu tipo é: \n", "``` \n", "\n", "Os valores `float` são essenciais para cálculos que envolvem precisão decimal, como operações matemáticas, científicas e financeiras." ] }, { "cell_type": "markdown", "metadata": { "id": "t04u6LqcatGa" }, "source": [ "### Strings \n", "O tipo de dado **string**, representado por `str` em Python, é utilizado para armazenar sequências de caracteres como texto. \n", "\n", "**Exemplos de Uso:** \n", "\n", "```python \n", "# Declaração e inicialização de uma variável do tipo string \n", "z = \"Olá, turma!\" \n", "print(f\"O valor de z é: {z}, e seu tipo é: {type(z)}\") \n", "\n", "# Atribuição de um novo valor \n", "z = \"123\" \n", "print(f\"O novo valor de z é: {z}, e seu tipo continua sendo: {type(z)}\") \n", "\n", "# Concatenação de strings \n", "resultado = z + \", como vai?\" \n", "print(f\"O resultado da concatenação é: {resultado}, e seu tipo é: {type(resultado)}\") \n", "``` \n", "\n", "**Saída do Código**\n", "``` \n", "O valor de z é: Olá, turma!, e seu tipo é: \n", "O novo valor de z é: 123, e seu tipo continua sendo: \n", "O resultado da concatenação é: 123, como vai?, e seu tipo é: \n", "``` \n", "\n", "**Uso de Aspas em Strings** \n", "Python permite usar tanto aspas simples (`'`) quanto duplas (`\"`) para definir strings: \n", "\n", "```python \n", "# String com aspas simples \n", "texto1 = 'Texto com aspas simples.' \n", "print(f\"Exemplo 1: {texto1}\") \n", "\n", "# String com aspas duplas \n", "texto2 = \"Texto com aspas duplas.\" \n", "print(f\"Exemplo 2: {texto2}\") \n", "\n", "# String contendo aspas diferentes \n", "texto3 = \"Contém 'aspas simples' dentro.\" \n", "texto4 = 'Contém \"aspas duplas\" dentro.' \n", "print(f\"Exemplo 3: {texto3}\") \n", "print(f\"Exemplo 4: {texto4}\")\n", "``` \n", "\n", "**Saída do Código**\n", "``` \n", "Exemplo 1: Texto com aspas simples.\n", "Exemplo 2: Texto com aspas duplas.\n", "Exemplo 3: Contém 'aspas simples' dentro.\n", "Exemplo 4: Contém \"aspas duplas\" dentro.\n", "``` \n", "\n", "Strings são fundamentais para manipulação de texto em Python, permitindo operações como concatenação, formatação e acesso a caracteres individuais." ] }, { "cell_type": "markdown", "metadata": { "id": "t04u6LqcatGa" }, "source": [ "**Utilização do `len` para Calcular o Tamanho da String**\n", "\n", "O `len` é uma função incorporada [Built-in Functions](https://docs.python.org/3/library/functions.html) em Python que retorna o comprimento (número de caracteres) de uma sequência, como uma string. Vamos calcular o tamanho da string `\"Olá, turma!\"` usando `len`:\n", "\n", "```python\n", "texto = \"Olá, turma!\"\n", "tamanho = len(texto)\n", "print(\"O tamanho da string é:\", tamanho)\n", "```\n", "**Saída do Código**\n", "```\n", "O tamanho da string é: 11\n", "```\n", "\n", "**Como Funcionam os Índices em uma String**\n", "\n", "Em Python, os índices de uma string começam em `0` e vão até `(comprimento da string - 1)`. Isso significa que o primeiro caractere está no índice `0`, o segundo no índice `1`, e assim por diante. Podemos imprimir caracteres específicos e partes da string usando esses índices:\n", "\n", "```python\n", "texto = \"Olá, turma!\"\n", "\n", "# Impressão de caracteres usando índices\n", "print(\"Primeiro caractere:\", texto[0])\n", "print(\"Segundo caractere:\", texto[1])\n", "\n", "# Impressão do último caractere usando índice -1\n", "print(\"Último caractere:\", texto[-1])\n", "\n", "# Impressão de partes da string usando índices\n", "print(\"Parte da string:\", texto[4:9])\n", "\n", "# Inverte a string (passo -1 percorre de trás pra frente)\n", "print(\"String invertida:\", texto[::-1])\n", "```\n", "**Saída do Código**\n", "```\n", "Primeiro caractere: O\n", "Segundo caractere: l\n", "Último caractere: !\n", "Parte da string: turma\n", "String invertida: !amrut ,álO\n", "```\n", "\n", "> 📌 No exemplo acima, `texto[4:9]` imprime a parte da string que vai do índice `4` até o índice `8` (o índice `9` não é incluído).\n", "\n", "**Manipulação de Strings**\n", "Mais adiante neste material, faremos um estudo aprofundado sobre a manipulação de strings. Exploraremos uma série de métodos e operações que são essenciais para o processamento de texto. Por exemplo:\n", "\n", "**Utilizando `.upper()` e `.lower()`**\n", "- **`.upper()`**: Este método é utilizado para converter todos os caracteres de uma string para **maiúsculas**. É útil quando queremos padronizar a entrada de dados ou destacar uma mensagem.\n", "\n", "```python\n", "texto = \"Olá, Mundo!\"\n", "print(texto.upper())\n", "```\n", "**Saída do Código**\n", "```\n", "OLÁ, MUNDO!\n", "```\n", "\n", "- **`.lower()`**: Em contraste, `.lower()` transforma todos os caracteres de uma string para **minúsculas**. Isso é particularmente útil para comparações de strings, onde a capitalização pode ser ignorada.\n", "\n", "```python\n", "texto = \"Olá, Mundo!\"\n", "print(texto.lower())\n", "```\n", "**Saída do Código**\n", "```\n", "olá, mundo!\n", "```\n", "\n", "Esses métodos são apenas o começo do que podemos fazer com a manipulação de strings em Python. À medida que avançarmos, descobriremos mais técnicas e funções que nos permitirão manipular e analisar strings em diversas situações.\n" ] }, { "cell_type": "markdown", "metadata": { "id": "DMSWpKnEandh" }, "source": [ "### Booleanos\n", "\n", "Os tipos booleanos representam valores lógicos, ou seja, podem ser `True` ou `False`. Esses valores são comumente utilizados para representar condições, resultados de testes e expressões lógicas.\n", "\n", "É importante destacar que em Python, o número `0` é frequentemente interpretado como `False` e o número `1` como `True` em contextos booleanos, ampliando a flexibilidade na expressão de condições e avaliação de expressões lógicas.\n", "\n", "Aqui estão alguns exemplos de uso de booleanos:\n", "\n", "```python\n", "# Declaração de uma variável do tipo booleano\n", "a = True\n", "\n", "# Atribuição de um valor a uma variável do tipo booleano\n", "a = False\n", "\n", "# Comparação de dois valores\n", "print(10 > 20)\n", "```\n", "\n", "**Saída do Código**\n", "```\n", "False\n", "```\n", "\n", "No exemplo acima, a expressão `10 > 20` resulta em `False` porque `10` não é maior que `20`. Esse tipo de avaliação é fundamental em operações lógicas e estruturas de controle que encontraremos em seções futuras.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Características da Dinamicidade de Tipo\n", "\n", "Conforme discutido anteriormente, o Python se destaca como uma linguagem de programação dinamicamente tipada, o que implica que o tipo de uma variável é determinado durante a execução do programa, não durante a compilação. Ao contrário de linguagens estaticamente tipadas, como C++ ou Java, onde o tipo de uma variável deve ser declarado explicitamente antes de ser utilizada, o Python permite atribuir valores a variáveis sem a necessidade de declarar o tipo previamente.\n", "\n", "É fundamental ressaltar a flexibilidade proporcionada pela Atribuição Dinâmica, especialmente quando combinada com `None`:\n", "\n", "```python\n", "# Atribuição dinâmica de valores\n", "variavel_dinamica = 42\n", "print(variavel_dinamica)\n", "\n", "variavel_dinamica = \"Olá, mundo!\"\n", "print(variavel_dinamica)\n", "\n", "# Declarando variáveis como None\n", "variavel_nula = None\n", "print(variavel_nula)\n", "\n", "# Atribuindo um valor posteriormente\n", "variavel_nula = 100\n", "print(variavel_nula)\n", "```\n", "**Saída do Código**\n", "```\n", "42\n", "Olá, mundo!\n", "None\n", "100\n", "```\n", "\n", "No exemplo acima, a variável `variavel_dinamica` é inicialmente atribuída ao inteiro 42 e, posteriormente, à string \"Olá, mundo!\". Isso ilustra a flexibilidade e a dinamicidade de tipos em Python. Além disso, a variável `variavel_nula` é inicializada com `None`, indicando a ausência de valor, e mais tarde é atribuída ao valor inteiro 100.\n", "\n", "Outro recurso importante a ser mencionado é a instrução `del`, que possibilita remover uma variável existente.\n", "\n", "```python\n", "# Removendo uma variável com o comando 'del'\n", "del variavel_nula\n", "# Tentar imprimir a variável após deletá-la resultará em um erro\n", "print(variavel_nula)\n", "```\n", "**Saída do Código**\n", "```\n", "Traceback (most recent call last):\n", " File \"\", line 5, in \n", " print(variavel_nula)\n", "NameError: name 'variavel_nula' is not defined\n", "```\n", "\n", "No exemplo acima, o comando `del` é usado para remover a variável `variavel_nula`. Tentar imprimir essa variável após deletá-la resultará em um erro `NameError`, indicando que a variável não está mais definida. O uso de `del` é útil para liberar recursos e gerenciar a estrutura do programa de forma mais eficiente." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Conversão de tipos (Casting) e Base numéricas\n", "\n", "Refere-se à conversão de um tipo de dado para outro. Isso pode ser necessário quando você deseja operar ou comparar valores de tipos diferentes. Um exemplo comum é a conversão de uma string para um número, como ao utilizar `float(input())` para converter a entrada do usuário em um número de ponto flutuante. \n", "\n", "**Conversão de String para Inteiro**\n", "\n", "```python\n", "# Solicita ao usuário para digitar um número inteiro\n", "entrada_usuario = input(\"Digite um número inteiro: \")\n", "\n", "# Converte a entrada para um número inteiro\n", "numero_inteiro = int(entrada_usuario)\n", "\n", "# Imprime o resultado\n", "print(\"Número inteiro digitado:\", numero_inteiro)\n", "```\n", "**Saída do Código**\n", "```\n", "Digite um número inteiro: 15\n", "Número inteiro digitado: 15\n", "```\n", "\n", "**Conversão de String para Ponto Flutuante**\n", "\n", "```python\n", "# Solicita ao usuário para digitar um número de ponto flutuante\n", "entrada_usuario = input(\"Digite um número de ponto flutuante: \")\n", "\n", "# Converte a entrada para um número de ponto flutuante\n", "numero_float = float(entrada_usuario)\n", "\n", "# Imprime o resultado\n", "print(\"Número de ponto flutuante digitado:\", numero_float)\n", "```\n", "**Saída do Código**\n", "```\n", "Digite um número de ponto flutuante: 3.14\n", "Número de ponto flutuante digitado: 3.14\n", "```\n", "\n", "**Conversão entre Bases Numéricas em Python**\n", "\n", "Python oferece suporte nativo para conversão entre diferentes bases numéricas. As representações incluem prefixos que indicam a base:\n", "1. `0b` para binário (base 2)\n", "2. `0o` para octal (base 8)\n", "3. `0x` para hexadecimal (base 16)\n", "\n", "**Decimal para Binário:**\n", "```python\n", "numero_decimal = 10\n", "numero_binario = bin(numero_decimal) # Retorna string com prefixo 0b\n", "print(numero_binario) # 0b1010 (onde 0b indica formato binário)\n", "```\n", "**Saída do Código**\n", "```\n", "0b1010\n", "```\n", "\n", "**Binário para Decimal:**\n", "```python\n", "numero_binario = 0b1010 # Prefixo 0b permite escrever literal binário\n", "numero_decimal = int(numero_binario) # Converte para inteiro decimal\n", "print(numero_decimal)\n", "```\n", "**Saída do Código**\n", "```\n", "10\n", "```\n", "\n", "Uma ilustração a seguir para ajudar a entender a matemática envolvida.\n", "\n", "\"Descrição\"\n", "\n", "\n", "\n", "**Decimal para Hexadecimal:**\n", "```python\n", "numero_decimal = 255\n", "numero_hexadecimal = hex(numero_decimal) # Retorna string com prefixo 0x\n", "print(numero_hexadecimal) # 0xff (onde 0x indica formato hexadecimal)\n", "```\n", "**Saída do Código**\n", "```\n", "0xff\n", "```\n", "\n", "**Hexadecimal para Decimal:**\n", "```python\n", "numero_hexadecimal = 0xff # Prefixo 0x permite escrever literal hexadecimal\n", "numero_decimal = int(numero_hexadecimal) # Converte para inteiro decimal\n", "print(numero_decimal)\n", "```\n", "**Saída do Código**\n", "```\n", "255\n", "```\n", "\n", "**Observações importantes:**\n", "- As funções `bin()`, `oct()` e `hex()` retornam strings com os respectivos prefixos\n", "- Você pode usar os prefixos diretamente no código para representar literais nessas bases\n", "- A função `int()` pode converter strings desses formatos para decimal quando usado com o parâmetro base:\n", " ```python\n", " int('1010', 2) # Binário → 10\n", " int('0xff', 16) # Hexadecimal → 255\n", " ```\n", "\n", "Estas conversões são especialmente úteis em programação de baixo nível, manipulação de bits e trabalhos com hardware.\n", "\n", "\n", "**Aplicações Práticas das Conversões entre Bases Numéricas**\n", "\n", "- **Eletrônica/Embarcados** \n", " - Controle de registradores (hex/bin) em microcontroladores\n", " - Configuração de GPIOs com máscaras binárias\n", "\n", "- **Desenvolvimento Web** \n", " - Cores em hexadecimal (#RRGGBB)\n", " - Permissões de arquivo (octal) em sistemas Unix\n", "\n", "- **Redes e Segurança** \n", " - Endereçamento IP e máscaras de sub-rede\n", " - Análise de pacotes e hashes criptográficos\n", "\n", "- **Otimização de Código** \n", " - Operações bitwise para manipulação eficiente de dados\n", " - Compactação de informações em estruturas binárias\n", "\n", "- **Sistemas Legados** \n", " - Leitura de dumps de memória (hex)\n", " - Interpretação de arquivos binários e headers\n", "\n", "Estes conceitos são a base para áreas como IoT, criptografia, desenvolvimento de drivers e análise forense digital." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Tipos de Dados Compostos (Coleções)\n", "\n", "As coleções são estruturas fundamentais em Python que permitem o armazenamento e organização eficiente de dados diversos. Essas estruturas oferecem flexibilidade ao acomodar diferentes tipos de dados, facilitando a manipulação e análise de informações de maneira abrangente.\n", "\n", "### Listas\n", "\n", "[Listas](https://docs.python.org/pt-br/3.13/tutorial/datastructures.html#more-on-lists) são estruturas de dados **mutáveis, ordenadas e heterogêneas** que permitem armazenar coleções de itens. São representadas por colchetes `[]` e itens separados por vírgulas.\n", "\n", "**Características Principais:**\n", "- **Mutáveis**: Podem ser alteradas após criação \n", "- **Ordenadas**: Mantêm a ordem de inserção \n", "- **Heterogêneas**: Aceitam diferentes tipos de dados \n", "- **Dinâmicas**: Crescem ou diminuem conforme necessidade \n", "\n", "```python\n", "# Exemplo básico\n", "lista = [1, \"Python\", 3.14, True]\n", "```\n", "\n", "#### Operações Básicas com Listas\n", "\n", "**Criando Listas**\n", "```python\n", "lista_vazia = [] # Sintaxe literal\n", "lista_vazia = list() # Usando construtor\n", "numeros = [1, 2, 3] # Lista de inteiros\n", "```\n", "\n", "**Acessando Elementos**\n", "```python\n", "linguagens = [\"Python\", \"Java\", \"C++\"]\n", "\n", "print(linguagens[0]) # Saída: \"Python\"\n", "print(linguagens[-1]) # Saída: \"C++\"\n", "```\n", "**Saída do Código:**\n", "```\n", "Python\n", "C++\n", "```\n", "\n", "**Modificando Listas**\n", "```python\n", "linguagens[1] = \"JavaScript\"\n", "print(linguagens)\n", "```\n", "**Saída do Código:**\n", "```\n", "['Python', 'JavaScript', 'C++']\n", "```\n", "\n", "#### Métodos Principais de Listas\n", "\n", "| Método | Descrição | Exemplo | Saída |\n", "|------------------|----------------------------------------|-------------------------------------|------------------------------|\n", "| `append(x)` | Adiciona `x` ao final | `[1, 2].append(3)` | `[1, 2, 3]` |\n", "| `extend(iter)` | Adiciona itens de outro iterável | `[1, 2].extend([3, 4])` | `[1, 2, 3, 4]` |\n", "| `insert(i, x)` | Insere `x` na posição `i` | `['a', 'c'].insert(1, 'b')` | `['a', 'b', 'c']` |\n", "| `remove(x)` | Remove primeira ocorrência de `x` | `[1, 2, 2, 3].remove(2)` | `[1, 2, 3]` |\n", "| `pop([i])` | Remove e retorna item no índice `i` | `[1, 2, 3].pop(1)` | Retorna `2`, lista: `[1, 3]` |\n", "| `clear()` | Remove todos os itens | `[1, 2, 3].clear()` | `[]` |\n", "| `index(x)` | Retorna índice da primeira ocorrência | `['a', 'b', 'c'].index('b')` | `1` |\n", "| `count(x)` | Conta ocorrências de `x` | `[1, 2, 2, 3].count(2)` | `2` |\n", "| `sort()` | Ordena a lista (in-place) | `[3, 1, 2].sort()` | `[1, 2, 3]` |\n", "| `reverse()` | Inverte a ordem (in-place) | `[1, 2, 3].reverse()` | `[3, 2, 1]` |\n", "| `copy()` | Retorna cópia superficial | `[1, 2].copy()` | `[1, 2]` |\n", "\n", "#### Combinação de Listas\n", "\n", "**Usando `+` (cria nova lista)**\n", "```python\n", "lista1 = [1, 2]\n", "lista2 = [3, 4]\n", "combinada = lista1 + lista2\n", "print(combinada)\n", "```\n", "**Saída do Código:**\n", "```\n", "[1, 2, 3, 4]\n", "```\n", "\n", "**Usando `+=` (modifica a primeira lista)**\n", "```python\n", "lista1 = [1, 2]\n", "lista2 = [3, 4]\n", "lista1 += lista2\n", "print(lista1)\n", "```\n", "**Saída do Código:**\n", "```\n", "[1, 2, 3, 4]\n", "```\n", "\n", "**Usando `extend()`**\n", "```python\n", "lista1 = ['a', 'b']\n", "lista2 = ['c', 'd']\n", "lista1.extend(lista2)\n", "print(lista1)\n", "```\n", "**Saída do Código:**\n", "```\n", "['a', 'b', 'c', 'd']\n", "```\n", "\n", "**Usando desempacotamento (Python 3.5+)**\n", "```python\n", "lista1 = [1, 2]\n", "lista2 = [3, 4]\n", "combinada = [*lista1, *lista2, 5]\n", "print(combinada)\n", "```\n", "**Saída do Código:**\n", "```\n", "[1, 2, 3, 4, 5]\n", "```\n", "\n", "#### Exemplo Prático Integrado\n", "\n", "```python\n", "# Criando lista de compras\n", "compras = [\"Maçã\", \"Leite\"]\n", "compras.append(\"Pão\")\n", "compras.extend([\"Ovos\", \"Queijo\"])\n", "compras.insert(1, \"Banana\")\n", "\n", "# Concatenando com outra lista\n", "bebidas = [\"Suco\", \"Água\"]\n", "lista_final = compras + bebidas\n", "\n", "print(\"Lista de compras completa:\", lista_final)\n", "```\n", "**Saída do Código:**\n", "```\n", "Lista de compras completa: ['Maçã', 'Banana', 'Leite', 'Pão', 'Ovos', 'Queijo', 'Suco', 'Água']\n", "```\n", "\n", "#### Boas Práticas\n", "\n", "- Prefira `append()`/`extend()` ao invés de `+` para listas grandes (melhor performance) \n", "- Use `lista.copy()` ou `list(lista)` para evitar modificações indesejadas \n", "- Utilize `lista.clear()` para esvaziar listas de forma legível \n", "- Verifique existência de elementos com `x in lista` (retorna `True` ou `False`)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Tuplas\n", "\n", "As [tuplas](https://docs.python.org/pt-br/3.13/tutorial/datastructures.html#tuples-and-sequences) são estruturas de dados fundamentais em Python, caracterizadas por serem **imutáveis, ordenadas e heterogêneas**. Sua sintaxe utiliza parênteses `()` com elementos separados por vírgulas – sendo a vírgula, e não os parênteses, o elemento definidor da tupla.\n", "\n", "**Características Essenciais:**\n", "- **Imutabilidade**: Uma vez criada, não pode ser alterada.\n", "- **Preservação de ordem**: Mantém a sequência de inserção.\n", "- **Flexibilidade tipográfica**: Aceita diferentes tipos de dados na mesma estrutura.\n", "- **Eficiência**: Consome menos recursos que listas para dados constantes.\n", "\n", "```python\n", "# Demonstração básica\n", "linguagem = (\"Python\", 1991, \"Guido van Rossum\", True)\n", "```\n", "\n", "#### Operações Fundamentais\n", "\n", "**Criação de Tuplas**\n", "```python\n", "vazia = () # Tupla vazia\n", "vazia = tuple() # Tupla vazia\n", "unitária = (42,) # Tupla com único elemento (vírgula obrigatória)\n", "coordenadas = (23.5, -46.6) # Tupla de floats\n", "registro = (\"ID123\", \"João\", 28) # Tupla heterogênea\n", "\n", "# Conversão de outros iteráveis\n", "de_lista = tuple([1, 2, 3])\n", "de_string = tuple(\"Python\")\n", "```\n", "**Saída do Código:**\n", "```\n", "('P', 'y', 't', 'h', 'o', 'n')\n", "```\n", "\n", "\n", "**Acesso a Elementos**\n", "```python\n", "dados = (\"Python\", 3.11, \"Open Source\")\n", "\n", "print(dados[0]) # Acesso por índice positivo\n", "print(dados[-1]) # Acesso por índice negativo\n", "```\n", "**Saída do Código:**\n", "```\n", "Python\n", "Open Source\n", "```\n", "\n", "\n", "**Tentativa de Modificação**\n", "```python\n", "tupla = (1, 2, 3)\n", "try:\n", " tupla[1] = 99 # Tentativa de alteração\n", "except TypeError as e:\n", " print(f\"Erro: {e}\")\n", "```\n", "**Saída do Código:**\n", "```\n", "Erro: 'tuple' object does not support item assignment\n", "```\n", "\n", "\n", "#### Métodos Nativos\n", "\n", "| Método | Descrição | Exemplo | Resultado |\n", "|--------------|----------------------------------------|----------------------------------|-----------|\n", "| `count()` | Conta ocorrências de um valor | `(1,2,2,3).count(2)` | `2` |\n", "| `index()` | Posição da primeira ocorrência | `('a','b','c').index('b')` | `1` |\n", "\n", "\n", "#### Combinação de Tuplas\n", "\n", "**Concatenação (`+`)**\n", "```python\n", "t1 = (1, 2)\n", "t2 = (3, 4)\n", "combinada = t1 + t2\n", "print(combinada)\n", "```\n", "**Saída do Código:**\n", "```\n", "(1, 2, 3, 4)\n", "```\n", "\n", "**Repetição (`*`)**\n", "```python\n", "saudacao = (\"Olá\",) * 3\n", "print(saudacao)\n", "```\n", "**Saída:**\n", "```\n", "('Olá', 'Olá', 'Olá')\n", "```\n", "\n", "**Desempacotamento Moderno**\n", "```python\n", "cores_base = (\"vermelho\", \"azul\")\n", "cores_extras = (\"verde\", \"amarelo\")\n", "paleta = (*cores_base, \"roxo\", *cores_extras)\n", "print(paleta)\n", "```\n", "**Saída:**\n", "```\n", "('vermelho', 'azul', 'roxo', 'verde', 'amarelo')\n", "```\n", "\n", "\n", "#### Aplicações Práticas\n", "\n", "**Sistemas de Coordenadas**\n", "```python\n", "ponto_a = (-23.55, -46.63) # São Paulo\n", "ponto_b = (-22.91, -43.17) # Rio de Janeiro\n", "print(f\"Rota: {ponto_a} -> {ponto_b}\")\n", "```\n", "**Saída do Código:**\n", "```\n", "Rota: (-23.55, -46.63) -> (-22.91, -43.17)\n", "```\n", "\n", "**Chaves Compostas em Dicionários**\n", "```python\n", "estoque = {\n", " (\"camiseta\", \"M\"): 42,\n", " (\"calça\", \"40\"): 15\n", "}\n", "print(estoque[(\"camiseta\", \"M\")])\n", "```\n", "**Saída do Código:**\n", "```\n", "42\n", "```\n", "\n", "**Sintaxe Alternativa**\n", "```python\n", "# Tupla sem parênteses (packing)\n", "valores = 10, 20, 30\n", "print(type(valores))\n", "\n", "# Unpacking\n", "x, y, z = valores\n", "print(f\"x={x}, y={y}, z={z}\")\n", "```\n", "**Saída do Código:**\n", "```\n", "\n", "x=10, y=20, z=30\n", "```\n", "\n", "\n", "#### Exemplo prático com função\n", "Para quando tiver estudado o Capítulo 5.\n", "\n", "```python\n", "# Sistema de geolocalização\n", "def calcular_distancia(p1, p2):\n", " from math import sqrt\n", " return sqrt((p2[0]-p1[0])**2 + (p2[1]-p1[1])**2)\n", "\n", "sp = (-23.55, -46.63)\n", "rj = (-22.91, -43.17)\n", "\n", "distancia_km = calcular_distancia(sp, rj) * 111\n", "print(f\"Distância SP-RJ: {distancia_km:.1f} km\")\n", "```\n", "**Saída do Código:**\n", "```\n", "Distância SP-RJ: 358.1 km\n", "```\n", "\n", "#### Boas Práticas\n", "\n", "- **Dados constantes**: Use tuplas para informações imutáveis.\n", "- **Chaves compostas**: Ideal para dicionários com múltiplos índices.\n", "- **Retorno múltiplo**: Padrão eficiente para funções.\n", "- **Segurança de dados**: Proteção contra modificações acidentais.\n", "- **Desempenho**: Prefira para coleções estáticas de grande porte." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Dicionários\n", "\n", "Os [dicionários](https://docs.python.org/pt-br/3.13/tutorial/datastructures.html#dictionaries) são estruturas de dados **mutáveis** que armazenam informações como pares **chave-valor**, oferecendo acesso rápido aos dados através de **chaves únicas**. São representados por chaves `{}` e cada elemento consiste em uma chave e seu valor correspondente, separados por dois pontos.\n", "\n", "**Características principais:**\n", "- Acesso eficiente aos valores através de chaves únicas\n", "- Não permitem chaves duplicadas\n", "- Podem ser modificados após criação\n", "- Aceitam diversos tipos de dados como valores\n", "- Otimizados para operações básicas em tempo constante\n", "\n", "```python\n", "# Exemplo básico de dicionário\n", "pessoa = {\n", " \"nome\": \"Maria\",\n", " \"idade\": 28,\n", " \"profissao\": \"Engenheira\",\n", " \"habilidades\": [\"Python\", \"CAD\", \"Gestão\"]\n", "}\n", "```\n", "\n", "#### Operações básicas com dicionários\n", "\n", "**Criação:**\n", "```python\n", "vazio = {} # Sintaxe literal\n", "vazio = dict() # Usando construtor\n", "\n", "cadastro = {\n", " \"id\": \"user123\",\n", " \"ativo\": False,\n", " \"ultimo_acesso\": \"2023-10-15\"\n", "}\n", "```\n", "\n", "**Acesso e modificação:**\n", "```python\n", "# Acesso direto\n", "print(pessoa[\"nome\"]) \n", "\n", "# Acesso seguro com get()\n", "print(pessoa.get(\"salario\", \"Não informado\")) # Retorna valor padrão se chave não existe\n", "\n", "# Adicionando ou atualizando valores\n", "pessoa[\"salario\"] = 7500.00\n", "pessoa.update({\"empresa\": \"Tech Solutions\", \"setor\": \"TI\"})\n", "```\n", "\n", "**Saída do Código:**\n", "```\n", "Maria\n", "Não informado\n", "{'nome': 'Maria', 'idade': 28, 'profissao': 'Engenheira', 'habilidades': ['Python', 'CAD', 'Gestão'], 'salario': 7500.0, 'empresa': 'Tech Solutions', 'setor': 'TI'}\n", "```\n", "\n", "**Remoção de itens:**\n", "```python\n", "del pessoa[\"habilidades\"] # Remove a chave especificada\n", "idade = pessoa.pop(\"idade\") # Remove e retorna o valor\n", "ultimo = pessoa.popitem() # Remove e retorna o último item inserido\n", "```\n", "\n", "**Saída do Código:**\n", "```\n", "28\n", "('setor', 'TI')\n", "{'nome': 'Maria', 'profissao': 'Engenheira', 'salario': 7500.0, 'empresa': 'Tech Solutions'}\n", "```\n", "\n", "#### Métodos úteis\n", "\n", "| Método | Descrição | Exemplo | Saída típica |\n", "|-----------------|------------------------------------------|----------------------------------|----------------------------------------|\n", "| keys() | Retorna todas as chaves | pessoa.keys() | dict_keys(['nome', 'profissao', ...]) |\n", "| values() | Retorna todos os valores | pessoa.values() | dict_values(['Maria', 'Engenheira', ...]) |\n", "| items() | Retorna pares (chave, valor) como tuplas | pessoa.items() | dict_items([('nome', 'Maria'), ...]) |\n", "| get(chave, pad) | Retorna valor ou padrão se chave ausente | pessoa.get(\"idade\", 30) | 30 |\n", "| update() | Atualiza com pares de outro dicionário | pessoa.update({\"idade\": 29}) | {'nome': 'Maria', 'idade': 29, ...} |\n", "| clear() | Remove todos os itens | pessoa.clear() | {} |\n", "\n", "#### Exemplos práticos\n", "\n", "**Dicionário simples:**\n", "```python\n", "aluno = {\n", " \"nome\": \"João Silva\",\n", " \"matricula\": \"2023001\",\n", " \"curso\": \"C&T\"\n", "}\n", "print(aluno)\n", "```\n", "\n", "**Saída do Código:**\n", "```\n", "{'nome': 'João Silva', 'matricula': '2023001', 'curso': 'Ciência da Computação'}\n", "```\n", "\n", "**Acesso e modificação:**\n", "```python\n", "print(aluno[\"nome\"]) \n", "aluno[\"curso\"] = \"Engenharia de Software\"\n", "print(aluno)\n", "```\n", "\n", "**Saída do Código:**\n", "```\n", "João Silva\n", "{'nome': 'João Silva', 'matricula': '2023001', 'curso': 'Engenharia de Software'}\n", "```\n", "\n", "**Verificação de chaves:**\n", "```python\n", "tem_matricula = \"matricula\" in aluno\n", "print(tem_matricula) \n", "```\n", "\n", "**Saída do Código:**\n", "```\n", "True\n", "```\n", "\n", "**Dicionário com diferentes tipos:**\n", "```python\n", "produto = {\n", " \"codigo\": 123,\n", " \"nome\": \"Teclado\",\n", " \"preco\": 99.90,\n", " \"disponivel\": True\n", "}\n", "print(produto)\n", "```\n", "\n", "**Saída do Código:**\n", "```\n", "{'codigo': 123, 'nome': 'Teclado', 'preco': 99.9, 'disponivel': True}\n", "```\n", "\n", "**Dicionário com lista como valor:**\n", "```python\n", "contatos = {\n", " \"João\": [\"joao@email.com\", \"(83) 9999-1111\"],\n", " \"Maria\": [\"maria@email.com\", \"(84) 8888-2222\"]\n", "}\n", "print(contatos[\"Maria\"])\n", "```\n", "\n", "**Saída do Código:**\n", "```\n", "['maria@email.com', '(84) 8888-2222']\n", "```\n", "\n", "#### Boas práticas\n", "\n", "- Use `chave in dicionario` para verificar existência de chaves \n", "- Prefira `get()` para evitar erros com chaves inexistentes \n", "- Tuplas podem ser usadas como chaves quando necessário \n", "- Dicionários mantêm a ordem de inserção (Python 3.7+) \n", "- `clear()` é mais eficiente que criar novo dicionário vazio \n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Conjuntos\n", "\n", "Os [conjuntos](https://docs.python.org/pt-br/3.13/tutorial/datastructures.html#sets) são estruturas de dados que armazenam elementos **únicos**, sem duplicatas. São úteis para operações matemáticas como união, interseção e diferença entre coleções.\n", "\n", "**Características principais:**\n", "- Armazenam elementos únicos (não permitem duplicatas)\n", "- Não mantêm ordem específica dos elementos\n", "- Não suportam indexação\n", "- Otimizados para verificação rápida de pertencimento\n", "- Aceitam tipos de dados imutáveis como elementos\n", "\n", "```python\n", "# Exemplo básico de conjunto\n", "vogais = {'a', 'e', 'i', 'o', 'u'}\n", "```\n", "\n", "#### Operações básicas com conjuntos\n", "\n", "**Criação:**\n", "```python\n", "vazio = set() # Conjunto vazio\n", "numeros = {1, 2, 3} # Conjunto com elementos\n", "```\n", "\n", "**Adição e remoção:**\n", "```python\n", "numeros.add(4) # Adiciona um elemento\n", "numeros.remove(2) # Remove elemento (gera erro se não existir)\n", "numeros.discard(5) # Remove se existir (não gera erro)\n", "```\n", "\n", "**Saída do Código:**\n", "```python\n", "print(numeros) # Saída: {1, 3, 4}\n", "```\n", "\n", "#### Operações entre conjuntos\n", "\n", "**União:**\n", "```python\n", "A = {1, 2, 3}\n", "B = {3, 4, 5}\n", "print(A | B) # Ou A.union(B)\n", "```\n", "\n", "**Saída do Código:**\n", "```\n", "{1, 2, 3, 4, 5}\n", "```\n", "\n", "**Interseção:**\n", "```python\n", "print(A & B) # Ou A.intersection(B)\n", "```\n", "\n", "**Saída do Código:**\n", "```\n", "{3}\n", "```\n", "\n", "**Diferença:** \n", "```python\n", "print(A - B) # Mostra os elementos que estão apenas no PRIMEIRO conjunto\n", "```\n", "\n", "**Saída do Código:**\n", "```\n", "{1, 2}\n", "```\n", "Veja a tabela completa a seguir.\n", "\n", "#### Métodos úteis\n", "\n", "| Método | Descrição | Exemplo | Saída típica |\n", "|-----------------|------------------------------------------|----------------------------------|--------------------------------|\n", "| add() | Adiciona um elemento | numeros.add(5) | {1, 3, 4, 5} |\n", "| remove() | Remove elemento (gera erro se não existe)| numeros.remove(3) | {1, 4, 5} |\n", "| discard() | Remove elemento (não gera erro) | numeros.discard(2) | {1, 4, 5} |\n", "| union() | Retorna união com outro conjunto | A.union(B) | {1, 2, 3, 4, 5} |\n", "| intersection() | Retorna interseção com outro conjunto | A.intersection(B) | {3} |\n", "| difference() | Retorna diferença entre conjuntos | A.difference(B) | {1, 2} |\n", "| clear() | Remove todos os elementos | numeros.clear() | set() |\n", "\n", "#### Exemplos práticos\n", "\n", "**Conjunto de vogais:**\n", "```python\n", "vogais = {'a', 'e', 'i', 'o', 'u'}\n", "print('a' in vogais) # Verifica pertencimento\n", "```\n", "\n", "**Saída do Código:**\n", "```\n", "True\n", "```\n", "\n", "**Removendo duplicatas de uma lista:**\n", "```python\n", "lista = [1, 2, 2, 3, 3, 3]\n", "unicos = set(lista)\n", "print(unicos)\n", "```\n", "\n", "**Saída do Código:**\n", "```\n", "{1, 2, 3}\n", "```\n", "\n", "**Conjunto de cores:**\n", "```python\n", "cores = {'vermelho', 'verde', 'azul'}\n", "cores.add('amarelo')\n", "print(cores)\n", "```\n", "\n", "**Saída do Código:**\n", "```\n", "{'vermelho', 'verde', 'azul', 'amarelo'}\n", "```\n", "\n", "#### Boas práticas\n", "\n", "- Use conjuntos para eliminar duplicatas de listas\n", "- Ideal para testar pertencimento de forma eficiente\n", "- Não use para dados que precisam de ordem\n", "- Elementos devem ser imutáveis (números, strings, tuplas)\n", "- Prefira `discard()` a `remove()` quando não tem certeza da existência" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Estruturas de Decisão\n", "\n", "As [**estruturas de decisão**](https://docs.python.org/pt-br/3.13/tutorial/controlflow.html#) controlam o fluxo de execução de um programa, permitindo que o código tome decisões com base em condições específicas e execute ações diferentes de acordo com o resultado dessas condições.\n", "\n", "### Estrutura `if`\n", "\n", "A estrutura `if` executa um bloco de código **somente** se uma condição for avaliada como **verdadeira** (`True`). Veja o exemplo:\n", "\n", "```python\n", "idade = 21\n", "\n", "if idade >= 18:\n", " print(\"Você é maior de idade.\")\n", "```\n", "\n", "**Saída do Código:**\n", "\n", "```\n", "Você é maior de idade.\n", "```\n", "\n", "No exemplo acima, a mensagem \"Você é maior de idade.\" será impressa, pois a condição `idade >= 18` é verdadeira.\n", "\n", "### Estrutura `if-else`\n", "\n", "A estrutura `if-else` permite que o código execute uma ação quando a condição é verdadeira e outra quando a condição é falsa. Veja o exemplo:\n", "\n", "\n", "```python\n", "idade = 15\n", "\n", "if idade >= 18:\n", " print(\"Você é maior de idade.\")\n", "else:\n", " print(\"Você é menor de idade.\")\n", "```\n", "\n", "**Saída do Código:**\n", "\n", "```\n", "Você é menor de idade.\n", "```\n", "\n", "Se a condição `idade >= 18` for **falsa**, o código dentro do `else` será executado, imprimindo \"Você é menor de idade.\"\n", "\n", "### Estrutura `if-elif-else`\n", "\n", "A estrutura condicional `if-elif-else` é utilizada quando precisamos verificar **múltiplas condições** de forma sequencial. O `elif` (abreviação de \"else if\") permite testar condições intermediárias entre o `if` inicial e o `else` final.\n", "\n", "#### Exemplo Básico:\n", "```python\n", "idade = 30\n", "\n", "if idade < 18:\n", " print(\"Você é menor de idade.\")\n", "elif 18 <= idade < 65: # Forma pythonica\n", " print(\"Você é adulto.\")\n", "else:\n", " print(\"Você é um idoso.\")\n", "```\n", "\n", "**Saída do Código:**\n", "```\n", "Você é adulto.\n", "```\n", "\n", "#### Comparação de Sintaxes:\n", "| Forma | Exemplo | Observação |\n", "|----------------------|----------------------------------|--------------------------------|\n", "| **Tradicional** | `idade >= 18 and idade < 65` | Mais explícita |\n", "| **Pythonica** | `18 <= idade < 65` | Mais concisa e idiomática |\n", "\n", "Ambas as formas são válidas, mas a versão pythonica é preferível por:\n", "- Ser mais legível\n", "- Assemelhar-se à notação matemática\n", "- Reduzir a repetição da variável\n", "\n", "\n", "**Tabela Resumo das Estruturas de Decisão**\n", "\n", "| Estrutura | Descrição | Uso |\n", "|-------------------|--------------------------------------------------------------|--------------------------------------------------------------------------------------------|\n", "| **if** | Executa um bloco de código se a condição for verdadeira | Usado quando há **uma única condição** a ser verificada |\n", "| **if-else** | Executa um bloco se a condição for verdadeira e outro se for falsa | Usado quando há **duas condições** possíveis (verdadeiro ou falso) |\n", "| **if-elif-else** | Verifica múltiplas condições sequencialmente | Usado quando há **mais de duas condições** e é necessário tratar diferentes cenários |\n", "\n" ] }, { "cell_type": "markdown", "metadata": { "id": "bEQasNr1dpzk", "jp-MarkdownHeadingCollapsed": true }, "source": [ "## 📝 Exercícios\n", "\n", "1. Escreva um programa que solicita ao usuário dois valores, um do tipo inteiro (`int`) e outro do tipo ponto flutuante (`float`). Após receber esses valores como entrada, o programa deve atribuí-los a duas variáveis distintas e, em seguida, imprimir na tela o resultado das seguintes operações matemáticas:\n", "\n", "- Soma dos dois valores.\n", "- Subtração do valor do tipo float pelo valor do tipo inteiro.\n", "- Multiplicação dos dois valores.\n", "- Divisão do valor do tipo inteiro pelo valor do tipo float.\n", "\n", "Certifique-se de formatar adequadamente a saída dos resultados. \n", "\n", "```python\n", "# Teste 1\n", "Entrada:\n", "10\n", "2.5\n", "Saída:\n", "Soma: 12.5\n", "Subtração: -7.5\n", "Multiplicação: 25.0\n", "Divisão: 4.0\n", "\n", "# Teste 2\n", "Entrada:\n", "15\n", "3.0\n", "Saída:\n", "Soma: 18.0\n", "Subtração: -12.0\n", "Multiplicação: 45.0\n", "Divisão: 5.0 \n", "```\n", "\n", "2. Escreva um programa que solicite ao usuário que insira uma palavra ou frase. Em seguida, o programa deve imprimir o comprimento da string, a primeira letra da string, a última letra da string e a string invertida.\n", "\n", "```python\n", "# Teste 1\n", "Entrada: A felicidade está nas pequenas coisas\n", "Saída:\n", "37\n", "A\n", "s\n", "sasioc saneuqep san átse edadicilef A\n", " \n", "# Teste 2\n", "Entrada: A verdadeira liberdade está em conhecer a si mesmo\n", "Saída:\n", "50\n", "A\n", "o\n", "omsem is a recehnoc me átse edadrebil ariedadrev A\n", "```\n", "\n", "3. Escreva um programa que compare duas strings fornecidas pelo usuário, considerando valores booleanos `\"True\"` ou `\"False\"`. O programa deve ignorar diferenças de capitalização (maiúsculas e minúsculas) e imprimir na tela se as strings são **iguais** ou **diferentes**.\n", "\n", "```python\n", "# Teste 1\n", "Entrada: \n", "True\n", "true \n", "Saída: \n", "São iguais\n", " \n", "# Teste 2\n", "Entrada: \n", "True\n", "False\n", "Saída: \n", "São diferentes\n", "```\n", " \n", "4. Faça um programa que calcule o Índice de Massa Corporal (IMC) de uma pessoa. O IMC é calculado dividindo-se o peso da pessoa pela sua altura ao quadrado. O IMC é uma medida da relação entre o peso e a altura de uma pessoa. O programa deve imprimir o IMC da pessoa, classificando-o de acordo com a tabela abaixo:\n", "\n", "```\n", "IMC | Classificação\n", "\n", "< 18.5 | Abaixo do peso\n", "18.5 - 24.9 | Saudável\n", "25.0 - 29.9 | Sobrepeso\n", "30.0 - 34.9 | Obesidade grau I\n", "35.0 - 39.9 | Obesidade grau II\n", ">= 40.0 | Obesidade grau III\n", "```\n", "\n", "```python\n", "# Teste 1\n", "Entrada: \n", "71\n", "1.70\n", "Saída: \n", "Seu IMC é 24.57 (Saudável).\n", " \n", "# Teste 2\n", "Entrada: \n", "85\n", "1.60\n", "Saída: \n", "Seu IMC é 33.20 (Obesidade grau I).\n", "```\n", "\n", "5. Crie um programa que solicite ao usuário a inserção de cinco frutas diferentes. Antes da leitura dos dados, crie uma lista vazia chamada `frutas`. Em seguida, armazene as frutas fornecidas pelo usuário nessa lista e, ao final, imprima a lista completa na tela.\n", "\n", "```python\n", "# Teste 1\n", "Entrada: \n", "maçã\n", "banana\n", "laranja\n", "pera\n", "melancia\n", "Saída:\n", "Lista de frutas: ['maçã', 'banana', 'laranja', 'pera', 'melancia']\n", " \n", "# Teste 2\n", "Entrada: \n", "uva\n", "abacaxi\n", "morango\n", "manga\n", "kiwi\n", "Saída:\n", "Lista de frutas: ['uva', 'abacaxi', 'morango', 'manga', 'kiwi']\n", "```\n", "\n", "6. Escreva um programa que solicite ao usuário a inserção de duas coordenadas (x e y). Em seguida, crie uma tupla chamada `coordenadas` com esses valores e imprima o conteúdo da tupla na tela.\n", "\n", "```python\n", "# Teste 1\n", "Entrada: \n", "2.5\n", "3.8\n", "Saída:\n", "Coordenadas: (2.5, 3.8)\n", " \n", "# Teste 2\n", "Entrada:\n", "-1.0\n", "0.0\n", "Saída:\n", "Coordenadas: (-1.0, 0.0)\n", "```\n", "\n", "7. Crie um dicionário chamado `contato`. Solicite ao usuário que forneça os dados correspondentes às chaves `\"nome\"`, `\"telefone\"` e `\"endereco\"`. Em seguida, imprima o conteúdo completo do dicionário.\n", "\n", "```python\n", "# Teste 1\n", "Entrada: \n", "Python da Silva\n", "8499999999\n", "Rua da Programação, 123\n", "Saída:\n", "Nome: Python da Silva, Telefone: 8499999999, Endereço: Rua da Programação, 123.\n", " \n", "# Teste 2\n", "Entrada:\n", "João da Silva\n", "9876543210\n", "Avenida dos Códigos, 456\n", "Saída:\n", "Nome: João da Silva, Telefone: 9876543210, Endereço: Avenida dos Códigos, 456.\n", "```\n", "\n", "8. Crie, antes da leitura dos números, um conjunto vazio chamado `numeros` utilizando a função `set()`. Em seguida, armazene os valores fornecidos pelo usuário nesse conjunto, utilizando o método `.add()`. Ao final, exiba o conjunto completo na saída.\n", "\n", "```python\n", "# Teste 1\n", "Entrada:\n", "3\n", "5\n", "7\n", "9\n", "11\n", "Saída:\n", "{3, 5, 7, 9, 11}\n", " \n", "# Teste 2\n", "Entrada:\n", "-2\n", "0\n", "4\n", "6\n", "8\n", "Saída:\n", "{0, 4, 6, 8, -2}\n", "```\n", "\n", "9. Faça um programa que solicite ao usuário a inserção de três números inteiros distintos para cada conjunto. Os conjuntos `conjunto_a` e `conjunto_b` devem ser criados utilizando a função `set()` e preenchidos com os números fornecidos pelo usuário, utilizando o método `.add()`. Em seguida, realize as seguintes operações e imprima os resultados:\n", "\n", "- **União**: combinar os elementos únicos de ambos os conjuntos. \n", "- **Interseção**: encontrar os elementos que estão presentes em ambos os conjuntos. \n", "- **Diferença**: identificar os elementos que estão em `conjunto_a`, mas não em `conjunto_b`.\n", "\n", "```python\n", "# Teste 1\n", "Entrada:\n", "3\n", "5\n", "7\n", "7\n", "9\n", "11\n", "Saída:\n", "União: {3, 5, 7, 9, 11}\n", "Interseção: {7}\n", "Diferença: {3, 5}\n", " \n", "# Teste 2\n", "Entrada:\n", "1\n", "2\n", "3\n", "4\n", "5\n", "1\n", "Saída:\n", "União: {1, 2, 3, 4, 5}\n", "Interseção: {1}\n", "Diferença: {2, 3}\n", "```\n", "\n", "10. Dada duas strings fornecidas pelo usuário, realize as seguintes operações e imprima os resultados:\n", "- **Transformar em maiúsculas:** converta toda a primeira string para letras maiúsculas.\n", "- **Transformar em minúsculas:** converta toda a segunda string para letras minúsculas.\n", "- **Concatenar as strings:** combine a primeira e a segunda string em uma única string.\n", "- **Imprimir o resultado:** exiba a string concatenada na tela.\n", " \n", "```python\n", "# Teste 1\n", "Entrada:\n", "Olá, mundo.\n", "Mundo\n", "Saída:\n", "OLÁ, MUNDO.\n", "mundo\n", "OLÁ, MUNDO. mundo\n", " \n", "# Teste 2\n", "Entrada:\n", "A Verdade Está Lá Fora, Neo.\n", "Mas Você Tem Que Escolher Se Quer Vê-la.\n", "Saída:\n", "A VERDADE ESTÁ LÁ FORA, NEO.\n", "mas você tem que escolher se quer vê-la.\n", "A VERDADE ESTÁ LÁ FORA, NEO. mas você tem que escolher se quer vê-la.\n", "```\n", "11. Você deve criar um programa que verifica se os números em uma lista são pares ou ímpares. A lista possui tamanho 5 e será fornecida pelo usuário. Cada número na lista deve ser avaliado individualmente, sem o uso de estruturas de repetição (como loops). O programa deve exibir na tela se cada número é par ou ímpar.\n", "\n", "```python\n", "# Teste 1\n", "Entrada:\n", "4\n", "9\n", "12\n", "17\n", "6\n", "Saída:\n", "O número 4 é par.\n", "O número 9 é ímpar.\n", "O número 12 é par.\n", "O número 17 é ímpar.\n", "O número 6 é par.\n", " \n", "# Teste 2\n", "Entrada:\n", "5\n", "6\n", "7\n", "1\n", "2 \n", "Saída:\n", "O número 5 é ímpar.\n", "O número 6 é par.\n", "O número 7 é ímpar.\n", "O número 1 é ímpar.\n", "O número 2 é par.\n", "```\n", "12. Escreva um programa para coletar informações de um aluno. Utilizando um dicionário denominado \"aluno\", solicite ao usuário as seguintes informações:\n", "\n", "- Nome do aluno.\n", "- Matrícula do aluno.\n", "- Três notas do aluno.\n", "\n", "Posteriormente, exiba na tela os dados registrados, incluindo o nome, matrícula e a média das três notas do aluno. Utilize somente os métodos especiais dos dicionários para inserir e acessar os dados.\n", "\n", "```python\n", "# Teste 1\n", "Entrada:\n", "Linus Benedict Torvalds\n", "12345\n", "8.5\n", "7.2\n", "9.0\n", "Saída:\n", "Nome: Linus Benedict Torvalds\n", "Matrícula: 12345\n", "Média: 8.23\n", "\n", "# Teste 2\n", "Entrada:\n", "Ada Lovelace\n", "67890\n", "9.8\n", "8.7\n", "10.0\n", "Saída:\n", "Nome: Ada Lovelace\n", "Matrícula: 67890\n", "Média: 9.5\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Referências\n", "\n", "```{bibliography}\n", ":filter: docname in docnames\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 }