{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7OABYY5Uw1IG"
      },
      "source": [
        "# Aula 01 - Noções Básicas de Python\n",
        "## **1. Introdução - O que é Python e por que aprender?**\n",
        "\n",
        "### **Para que serve a programação ?**\n",
        "Programação é um conjunto de instruções determinados pelo programador que descrevem tarefas a serem realzadas pela máquina e atendem diversas finalidades para controlar o comportamento físico de lógico de uma máquina.\n",
        "\n",
        "Essas instruções são um conjunto das regras\n",
        "e procedimentos lógicos que levam à solução\n",
        "de um problema em um número finito de\n",
        "etapas e de maneira sistemática.\n",
        "\n",
        "### **Por que ser programador ?**\n",
        "- Profissão com alta demanda\n",
        "- Mercado em ascensão\n",
        "- Salários competitivos\n",
        "- Possibilidade de trabalho remoto\n",
        "- Resolve problemas mais rápido\n",
        "- Desenvolve criatividade\n",
        "- Espírito de comunidade\n",
        "- Aprendizado contínuo\n",
        "\n",
        "\n",
        "\n",
        "### **O que é Python e por que aprender ?**\n",
        "\n",
        "Python é uma linguagem de programação versátil e de fácil aprendizado. Além disso é Open-Source (código aberto) e utilizada em diversas áreas do conhecimento e aplicações.\n",
        "\n",
        "É interessante aprender Python por ser uma linguagem fácil de ler e escrever, versátil, com grande comunidade e ecosssistema rico (Há muitas bibliotecas e frameworks!).\n",
        "\n",
        "\n",
        "\n",
        "### **EMPRESAS QUE USAM PYTHON**\n",
        "\n",
        "| | | | |\n",
        "|---|---|---|---|\n",
        "| <img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/e/e7/Instagram_logo_2016.svg/200px-Instagram_logo_2016.svg.png\" width=\"60\"> | <img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/7/75/Netflix_icon.svg/200px-Netflix_icon.svg.png\" width=\"60\"> | <img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/0/08/Pinterest-logo.png/200px-Pinterest-logo.png\" width=\"60\">\n",
        "| **Instagram** | **Netflix** | **Pinterest** |\n",
        "\n",
        "| | | |\n",
        "|---|---|---|\n",
        "| <img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/1/19/Spotify_logo_without_text.svg/200px-Spotify_logo_without_text.svg.png\" width=\"60\"> | <img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/7/78/Dropbox_Icon.svg/200px-Dropbox_Icon.svg.png\" width=\"60\"> | <img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/c/cc/Uber_logo_2018.png/200px-Uber_logo_2018.png\" width=\"60\"> |\n",
        "| **Spotify** | **Dropbox** | **Uber** |\n",
        "\n",
        "---\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6Zf90IVwZ0kH"
      },
      "source": [
        "## **2. O que é um algoritmo?**\n",
        "Um algoritmo é uma sequência de instruções para resolver um problema.\n",
        "\n",
        "**Exemplo: Preparando um café**\n",
        "- Passo 01: Encha de água a panela;\n",
        "- Passo 02: Coloque a água para ferver;\n",
        "- Passo 03: Prepare o porta-filtro;\n",
        "- Passo 04: Se houver café, coloque duas duas colheres de sopa de café no filtro;\n",
        "- Passo 05: Se não houver café, desligue o fogo e vá atrás de café e repita as  etapas 2,3 e 5;\n",
        "- Passo 06: Após a água ter fervido, acrescente aos poucos meio litro de água sobre o filtro;\n",
        "- Passo 07: Aguarde coar;\n",
        "- Passo 08: Adoce a gosto."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ku3roDWV3Xlf"
      },
      "source": [
        "## **3. Engatinhando na linguagem e algumas noções básicas**\n",
        "\n",
        "### 3.1 **Seu primeiro programa Python !**\n",
        "\n",
        "O \"Hello World\" é um programa que utiliza o comando de 'Print' (Imprimir ) que imprime informações na tela. Parece ter pouca utilidade mas é uma parada obrigatória ao iniciar em uma nova linguagem, por ser um dos programas mais simples de realizar, acabou se tornando um rito entre os programadores para testar se etá tudo certo. Aqui está seu exemplar em Python. Aperte o botão de \"▶️\" para testar o trecho de código abaixo:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yUUmWfX4bfzE",
        "outputId": "f5963681-0378-4c48-8cb1-ebe6f2cd95e6"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Olá, esse é meu primeiro programa me Python ! ^^ \n"
          ]
        }
      ],
      "source": [
        "# Um programa simples em Python, conhecido como \"Hello World\" ou \"Olá mundo\", imprime um texto na tela:\n",
        "print(\"Olá, esse é meu primeiro programa me Python ! ^^ \")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2979d0_n49hg"
      },
      "source": [
        "### 3.2 **Comentários**\n",
        "Comentários são textos que o interpretador Python irá ignorar. Servem para explicar o código ou deixar lembrestes. É uma forma muito útil de se organizar ao desenvolver aplicações com muitas linhas de código.\n",
        "\n",
        "Para inserir um comentário em Python, basta inserir um '#' antes do texto."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NJOmHUzQ4f_Q"
      },
      "outputs": [],
      "source": [
        "# Olá, eu sou um comentário Python !"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yPbKmjg369Xf"
      },
      "source": [
        "### 3.3 **Variáves**\n",
        "\n",
        "Variáveis são espaços na memória do computador que armazenam algum tipo de dado que pode ou não ser modificado durante a execução do algoritmo. Imagine uma caixa que guarda algum tipo de informação.\n",
        "\n",
        "O programa a seguir mostra uma variável \"X\" sendo declarada e tendo um valor de \"10\" atribuído a ela. Caso essa variável seja maior ou igual a 5, o programa irá imprimir na tela a mensagem com essa confirmação, caso não, exibirá a mensagem indicando que o valor de \"X\" é menor do que 5.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pq_AfEcRfk-G",
        "outputId": "38feccb5-3fff-4776-82e5-978374908dbb"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "X é maior ou igual a 5\n"
          ]
        }
      ],
      "source": [
        "x = 10 #Momento em que a variável é declarada. Variáveis podem ser declaradas antes e durante a execução do algoritmo;\n",
        "if x>=5:  #Estrutura lógica \"if\" ou \"se\", condição de que se X for maior do que 5, algo irá acontecer.\n",
        "  print(\"X é maior ou igual a 5\") #Saída do programa caso X seja maior do que 5\n",
        "else:\n",
        "  print(\"X é menor que 5\") #Saída do programa caso X seja menor do que 5"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0Nm5rJi2hCVX"
      },
      "source": [
        "## 💡 DICA: Experimente mudar o valor de 5 atribuído a variável X, rode a célula novamente e observe as outras possibilidades de saída."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ButSdTt2824g"
      },
      "source": [
        "### 3.4 **Tipos de dados**\n",
        "\n",
        "Em geral em linguagens de programação é necessário definir um tipo de dado para se guardar uma variável. Felizmente o Python é uma linguagem dinâmica e consegue definir sem necessidade de declaração.\n",
        "\n",
        "Porém, para bom uso em aplicações é importante conhecer os diferentes tipos de dados, alguns dos mais importantes estão dispostos na tabela:\n",
        "\n",
        "<div align=\"center\">\n",
        "\n",
        "| Tipo | Nome | Exemplo | Descrição |\n",
        "|:----:|:----:|:-------:|-----------|\n",
        "| **int** | Inteiro | `42`, `-3`, `1000` | Números inteiros (positivos ou negativos) |\n",
        "| **float** | Decimal | `3.14`, `-0.5`, `2.0` | Números com casas decimais |\n",
        "| **str** | String | `\"Python\"`, `'Olá'` | Texto (entre aspas) |\n",
        "| **bool** | Booleano | `True`, `False` | Verdadeiro ou Falso |\n",
        "| **list** | Lista | `[1, 2, 3]` | Coleção ordenada e mutável |\n",
        "| **tuple** | Tupla | `(1, 2, 3)` | Coleção ordenada e imutável |\n",
        "| **dict** | Dicionário | `{\"nome\": \"João\"}` | Pares chave-valor |\n",
        "| **set** | Conjunto | `{1, 2, 3}` | Coleção não ordenada sem duplicatas |\n",
        "| **NoneType** | Nulo | `None` | Ausência de valor |\n",
        "\n",
        "</div>\n",
        "\n",
        "\n",
        "Abaixo está um pequeno exemplo de um programa que guardará informações sobre uma pessoa, com a divisão de dados por tipo adequada."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yt6n80FS61so",
        "outputId": "31e969b4-95ff-40b3-ffb6-e3d5c89392be"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Nome: Dominic\n",
            "Idade: 24\n",
            "Altura: 1.65\n",
            "É estudante? True\n"
          ]
        }
      ],
      "source": [
        "nome = \"Gui\"  # String (texto)\n",
        "idade = 24       # Inteiro (número inteiro)\n",
        "altura = 1.75   # Float (número decimal)\n",
        "estudante = True # Boolean (True ou False)\n",
        "\n",
        "print(\"Nome:\", nome)\n",
        "print(\"Idade:\", idade)\n",
        "print(\"Altura:\", altura)\n",
        "print(\"É estudante?\", estudante)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "phaK3FrPjcR3"
      },
      "source": [
        "### O exemplo a seguir mostra de maneira mais completa diferentes tipos de dados em possíveis aplicações:\n",
        "Esse programa declara variáveis e imprime na tela o seu tipo, experimente rodar para ver na prática o que cada tipo de variável pode representar."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "roXkHc0oELrZ",
        "outputId": "3238f661-e005-472c-8fb4-b002946d1a79"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "int: 25 -> <class 'int'>\n",
            "float: 1.75 -> <class 'float'>\n",
            "str: Maria -> <class 'str'>\n",
            "bool: True -> <class 'bool'>\n",
            "list: ['maçã', 'banana'] -> <class 'list'>\n",
            "tuple: (10, 20) -> <class 'tuple'>\n",
            "dict: {'nome': 'João', 'idade': 30} -> <class 'dict'>\n",
            "set: {1, 2, 3} -> <class 'set'>\n",
            "NoneType: None -> <class 'NoneType'>\n"
          ]
        }
      ],
      "source": [
        "\n",
        "# int (inteiro)\n",
        "idade = 25\n",
        "print(f\"int: {idade} -> {type(idade)}\")\n",
        "\n",
        "# float (decimal)\n",
        "altura = 1.75\n",
        "print(f\"float: {altura} -> {type(altura)}\")\n",
        "\n",
        "# str (string/texto)\n",
        "nome = \"Maria\"\n",
        "print(f\"str: {nome} -> {type(nome)}\")\n",
        "\n",
        "# bool (booleano)\n",
        "aprovado = True\n",
        "print(f\"bool: {aprovado} -> {type(aprovado)}\")\n",
        "\n",
        "# list (lista)\n",
        "frutas = [\"maçã\", \"banana\"]\n",
        "print(f\"list: {frutas} -> {type(frutas)}\")\n",
        "\n",
        "# tuple (tupla)\n",
        "coordenadas = (10, 20)\n",
        "print(f\"tuple: {coordenadas} -> {type(coordenadas)}\")\n",
        "\n",
        "# dict (dicionário)\n",
        "pessoa = {\"nome\": \"João\", \"idade\": 30}\n",
        "print(f\"dict: {pessoa} -> {type(pessoa)}\")\n",
        "\n",
        "# set (conjunto)\n",
        "numeros = {1, 2, 3}\n",
        "print(f\"set: {numeros} -> {type(numeros)}\")\n",
        "\n",
        "# NoneType\n",
        "vazio = None\n",
        "print(f\"NoneType: {vazio} -> {type(vazio)}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GUOGzcG_kI5_"
      },
      "source": [
        "## **4. Operadores Matemáticos em Python**\n",
        "\n",
        "\n",
        "### **4.1 Introdução aos Operadores Aritméticos**\n",
        "\n",
        "Os operadores matemáticos em Python funcionam de forma similar à matemática que você já conhece! Eles permitem realizar cálculos como soma, subtração, multiplicação, divisão entre outras operações...\n",
        "\n",
        "\n",
        "\n",
        "## **Operadores Matemáticos:**\n",
        "\n",
        "<div align=\"center\">\n",
        "\n",
        "| Operador | Nome | Exemplo | Resultado | Descrição |\n",
        "|:--------:|:----:|:-------:|:---------:|-----------|\n",
        "| `+` | Adição | `10 + 3` | `13` | Soma dois valores |\n",
        "| `-` | Subtração | `10 - 3` | `7` | Subtrai o segundo do primeiro |\n",
        "| `*` | Multiplicação | `10 * 3` | `30` | Multiplica dois valores |\n",
        "| `/` | Divisão | `10 / 3` | `3.3333` | Divisão com resultado decimal |\n",
        "| `//` | Divisão Inteira | `10 // 3` | `3` | Divisão com resultado inteiro |\n",
        "| `%` | Módulo (Resto) | `10 % 3` | `1` | Resto da divisão |\n",
        "| `**` | Potência | `10 ** 3` | `1000` | Eleva à potência |\n",
        "\n",
        "</div>\n",
        "\n",
        "Abaixo está um pequeno exemplo para demonstrar os operadores:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XHL8ToacEkh3",
        "outputId": "a8f4d69a-5e45-40b4-b8ad-19812f3a111f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "a = 10, b = 3\n",
            "Soma: 10 + 3 = 13\n",
            "Subtração: 10 - 3 = 7\n",
            "Multiplicação: 10 * 3 = 30\n",
            "Divisão: 10 / 3 = 3.3333333333333335\n",
            "Divisão inteira: 10 // 3 = 3\n",
            "Resto da divisão: 10 % 3 = 1\n",
            "Potência: 10 ** 3 = 1000\n"
          ]
        }
      ],
      "source": [
        "# Operadores básicos\n",
        "a = 10\n",
        "b = 3\n",
        "\n",
        "print(f\"a = {a}, b = {b}\")\n",
        "print(f\"Soma: {a} + {b} = {a + b}\")\n",
        "print(f\"Subtração: {a} - {b} = {a - b}\")\n",
        "print(f\"Multiplicação: {a} * {b} = {a * b}\")\n",
        "print(f\"Divisão: {a} / {b} = {a / b}\")\n",
        "print(f\"Divisão inteira: {a} // {b} = {a // b}\")\n",
        "print(f\"Resto da divisão: {a} % {b} = {a % b}\")\n",
        "print(f\"Potência: {a} ** {b} = {a ** b}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "M1hWR6tBfpBa"
      },
      "source": [
        "### Importante: Números vs Textos\n",
        "\n",
        "Existe uma diferença fundamental entre **números** e **textos** (strings):\n",
        "\n",
        "- **2** é um número (pode ser usado em operações matemáticas)\n",
        "- **\"2\"** é um texto (não pode ser usado em operações matemáticas)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0RHV3IB8fwVI"
      },
      "outputs": [],
      "source": [
        "# Diferença entre número e texto\n",
        "print(f\"2 + 2 (números) = {2 + 2}\")\n",
        "print(f\"'2' + '2' (textos) = {'2' + '2'}\")  # Concatenação (junção de textos)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p-nTQ5JvkzNb"
      },
      "source": [
        "##  Conceitos Complementares\n",
        "\n",
        "- **Ordenação**: organização de listas de palavras ou números\n",
        "- **Indentação**: recuo no texto (fundamental em Python para definir blocos de código)\n",
        "- **Compilação**: tradução da linguagem de programação para linguagem de máquina"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}
