19_ntb_Funcoes_dia_dia.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyMUP5qd9y2O7TxuZdybZ4IJ",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/luasampaio/data-engineering/blob/main/19_ntb_Funcoes_dia_dia.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "412t-fE2c2-q"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "s = \"Eu sou uma string\"\n",
        "print( type (s))\n",
        "print(s.__add__( \"!\" ))\n",
        "print(s.__sizeof__())  ##tamanho que está em memoria"
      ],
      "metadata": {
        "id": "ezLAbLORc4Q1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "959f05d2-3b55-4ede-9cd2-1cdc7aabb416"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'str'>\n",
            "Eu sou uma string!\n",
            "66\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class  Actor :\n",
        "    \"\"\"Definir a classe do ator\"\"\"\n",
        "    def  __init__ ( self, first_name, last_name, birthday, total_films, oscar_nominations, oscar_wins ):\n",
        "        self.first_name = first_name\n",
        "        self.last_name = last_name\n",
        "        self.birthday =  birthday\n",
        "        self.total_films = total_films\n",
        "        self.oscar_nominations = oscar_nominations\n",
        "        self.oscar_wins = oscar_wins\n",
        "\n",
        "john = Actor( \"John\" , \"Smith\" , \"20 de junho\" , 80 , 4 , 1 )\n",
        "tom = Actor( \"Tom\" , \"Hanks\" , \"9 de julho\" , 76 , 5 , 2 )\n",
        "print(john.first_name, john.last_name)\n",
        "print(tom.first_name, tom.last_name)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ygQfr3XnNOL6",
        "outputId": "b19094d8-ee2f-4895-de53-fcafc0f69b92"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "John Smith\n",
            "Tom Hanks\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Usando Zip em Python **\n"
      ],
      "metadata": {
        "id": "ZQqVMaokaUtO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "name = [ \"Alice\" , \"Bob\" , \"Charlie\" ]\n",
        "age = [ 25 , 30 , 35 ]\n",
        "\n",
        "for i in range( len(name) ):\n",
        "    print( name[i] , age[i] )"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XP6HZmr8S0_h",
        "outputId": "6fcc4471-c899-4401-864f-99c6bf6fee8d"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Alice 25\n",
            "Bob 30\n",
            "Charlie 35\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "name = [ \"Alice\" , \"Bob\" , \"Charlie\" ]\n",
        "age = [ 25 , 30 , 35 ]\n",
        "\n",
        "for name , age in zip( name , age ):\n",
        "    print( name , age )"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4CyFLhBbaJEh",
        "outputId": "8123dbf0-ac39-456a-9843-ad47f5a8a99e"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Alice 25\n",
            "Bob 30\n",
            "Charlie 35\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        ":="
      ],
      "metadata": {
        "id": "0L5NpzH5ag8Y"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "while  True :\n",
        "    user_input = input ( \"Digite um número: \" )\n",
        "    if user_input.isdigit():\n",
        "        number = int (user_input)\n",
        "        break"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kNlaZ7Htah0z",
        "outputId": "53179c9d-8a31-4b65-8b44-de279e545946"
      },
      "execution_count": 8,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Digite um número: 3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Mais elegante no código\n",
        "\n",
        "while not (user_input := input(\"Enter a number: \")).isdigit():\n",
        "    print(\"Invalid input, please enter a number.\")\n",
        "\n",
        "number = int(user_input)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "s-CdyPC7asJJ",
        "outputId": "c9bc0945-d5e1-4393-b4d7-c7b8e72b1e00"
      },
      "execution_count": 9,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a number: 5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "list1 = [1, 2, 3, 4, 5]\n",
        "list2 = [4, 5, 6, 7, 8]\n",
        "\n",
        "# elementos comuns\n",
        "common_elements = []\n",
        "for item in list1:\n",
        "    if item in list2:\n",
        "        common_elements.append(item)\n",
        "print(f\"Common elements: {common_elements}\")\n",
        "\n",
        "# Find unique elements in list1\n",
        "unique_to_list1 = []\n",
        "for item in list1:\n",
        "    if item not in list2:\n",
        "        unique_to_list1.append(item)\n",
        "print(f\"Unique to list1: {unique_to_list1}\")\n",
        "\n",
        "# Find all unique elements\n",
        "all_unique_elements = list1.copy()\n",
        "for item in list2:\n",
        "    if item not in all_unique_elements:\n",
        "        all_unique_elements.append(item)\n",
        "print(f\"All unique elements: {all_unique_elements}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HAtl3SfebORV",
        "outputId": "6890c2aa-0ef5-4ec4-f6b8-cfe4701ff8bc"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Common elements: [4, 5]\n",
            "Unique to list1: [1, 2, 3]\n",
            "All unique elements: [1, 2, 3, 4, 5, 6, 7, 8]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Novo Caminho para uma solução mais elegante\n",
        "\n",
        "list1 = [1, 2, 3, 4, 5]\n",
        "list2 = [4, 5, 6, 7, 8]\n",
        "\n",
        "# # Converte listas em conjuntos\n",
        "set1 = set(list1)\n",
        "set2 = set(list2)\n",
        "\n",
        "# Encontra interseção (elementos comuns)\n",
        "common_elements = set1 & set2\n",
        "print(f\"Common elements: {common_elements}\")\n",
        "\n",
        "# Encontre diferença (elementos únicos em set1)\n",
        "unique_to_set1 = set1 - set2\n",
        "print(f\"Unique to set1: {unique_to_set1}\")\n",
        "\n",
        "# Encontre união (todos únicos elementos)\n",
        "all_unique_elements = set1 | set2\n",
        "print(f\"All unique elements: {all_unique_elements}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FgmSIGBQf3bO",
        "outputId": "d07fd7eb-64da-4a75-bd7e-e36402485a08"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Common elements: {4, 5}\n",
            "Unique to set1: {1, 2, 3}\n",
            "All unique elements: {1, 2, 3, 4, 5, 6, 7, 8}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Define a function that takes multiple arguments\n",
        "def greet(first, second, third):\n",
        "    print(f\"Hello {first}, {second}, and {third}!\")\n",
        "\n",
        "# List of names\n",
        "names = [\"Alice\", \"Bob\", \"Charlie\"]\n",
        "\n",
        "# Unpack list into function arguments\n",
        "greet(*names)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Vu1CMWcugMgB",
        "outputId": "2f4aaa7d-d968-47b4-a0c7-83f1bf4f399b"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello Alice, Bob, and Charlie!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from dataclasses import dataclass\n",
        "\n",
        "# Define a simple data class\n",
        "@dataclass\n",
        "class Person:\n",
        "    name: str\n",
        "    age: int\n",
        "    city: str\n",
        "\n",
        "# Create an instance of the class\n",
        "person = Person(name=\"Alice\", age=30, city=\"New York\")\n",
        "\n",
        "print(person)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2J2xkU31g0b_",
        "outputId": "4ee44336-c882-4bfd-9204-57f27a9b6071"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Person(name='Alice', age=30, city='New York')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class Person:\n",
        "    def __init__(self, name, age, city):\n",
        "        self.name = name\n",
        "        self.age = age\n",
        "        self.city = city\n",
        "\n",
        "person = Person(name=\"Alice\", age=30, city=\"New York\")\n",
        "print(person.name)\n",
        "print(person.age)\n",
        "print(person.city)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YmrJVwLMg-KF",
        "outputId": "cf455716-59a0-48b5-d532-57be364d36db"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Alice\n",
            "30\n",
            "New York\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "https://python.plainenglish.io/10-python-tricks-that-will-change-the-way-you-code-forever-3267465b2d8f\n",
        "\n",
        "  "
      ],
      "metadata": {
        "id": "tGx5uMUFjNaf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from functools import lru_cache\n",
        "\n",
        "# Define a function with heavy computation\n",
        "@lru_cache(maxsize=100)\n",
        "def expensive_function(n):\n",
        "    print(f\"Computing {n}...\")\n",
        "    return n * n\n",
        "\n",
        "# Call the function multiple times\n",
        "print(expensive_function(4))\n",
        "print(expensive_function(4))  # This call is cached"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nclX5oYlq5nq",
        "outputId": "eddb5cfe-4848-4afe-fa1d-e81b329c0fa2"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Computing 4...\n",
            "16\n",
            "16\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "entender melhor os geradores em python 🅰\n"
      ],
      "metadata": {
        "id": "JWs_AT6_7YUK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def generate_squares(n):\n",
        "    for i in range(n):\n",
        "        yield i * i\n",
        "\n",
        "# Use the generator\n",
        "for square in generate_squares(5):\n",
        "    print(square)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IPIEfJVQ5SWw",
        "outputId": "8604dc0d-2ed6-4d84-b852-1d819c4d9d19"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0\n",
            "1\n",
            "4\n",
            "9\n",
            "16\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def generate_squares(n):\n",
        "    result = []\n",
        "    for i in range(n):\n",
        "        result.append(i * i)\n",
        "    return result\n",
        "\n",
        "for square in generate_squares(5):\n",
        "    print(square)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LjghGQwy6_59",
        "outputId": "4700b087-7cd1-47bf-a3dc-362a66bc799c"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0\n",
            "1\n",
            "4\n",
            "9\n",
            "16\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def trim(string):\n",
        "    return string.strip()"
      ],
      "metadata": {
        "id": "HMJbKjLmkPc7"
      },
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import itertools\n",
        "\n",
        "# Generate all possible combinations of two items\n",
        "items = ['A', 'B', 'C']\n",
        "combinations = itertools.combinations(items, 2)\n",
        "\n",
        "for combo in combinations:\n",
        "    print(combo)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "y29FmEGgpWB8",
        "outputId": "b15d7e8f-7b7e-47b6-e2da-c5fc2519e7c4"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "('A', 'B')\n",
            "('A', 'C')\n",
            "('B', 'C')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from types import MappingProxyType\n",
        "\n",
        "# Original dictionary\n",
        "config = {'host': 'localhost', 'port': 8080}\n",
        "\n",
        "# Create a read-only view\n",
        "read_only_config = MappingProxyType(config)\n",
        "\n",
        "print(read_only_config['host'])\n",
        "\n",
        "# Attempt to modify the read-only dictionary\n",
        "try:\n",
        "    read_only_config['host'] = '127.0.0.1'\n",
        "except TypeError as e:\n",
        "    print(e)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LH-OowBepqm3",
        "outputId": "01d5533b-3429-4ba8-f0cb-db45c25a0093"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "localhost\n",
            "'mappingproxy' object does not support item assignment\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# code\n",
        "print(dir(int))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_ju31uhi5ojS",
        "outputId": "6ff121a8-dad0-40fe-cce3-dc1557a72375"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_count', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for nomes in [\"Alice\", \"Bob\", \"Charlie\"]:\n",
        "    print(nomes)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EHw9-XUL-wvA",
        "outputId": "f6fa1eac-71e1-41da-fa6e-7c615626f488"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Alice\n",
            "Bob\n",
            "Charlie\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for i in range(18,111):\n",
        "    print(i)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "collapsed": true,
        "id": "vxQtlPwh-4da",
        "outputId": "d9cb0d7a-85d0-4683-ce23-77fe44a0e0ba"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "18\n",
            "19\n",
            "20\n",
            "21\n",
            "22\n",
            "23\n",
            "24\n",
            "25\n",
            "26\n",
            "27\n",
            "28\n",
            "29\n",
            "30\n",
            "31\n",
            "32\n",
            "33\n",
            "34\n",
            "35\n",
            "36\n",
            "37\n",
            "38\n",
            "39\n",
            "40\n",
            "41\n",
            "42\n",
            "43\n",
            "44\n",
            "45\n",
            "46\n",
            "47\n",
            "48\n",
            "49\n",
            "50\n",
            "51\n",
            "52\n",
            "53\n",
            "54\n",
            "55\n",
            "56\n",
            "57\n",
            "58\n",
            "59\n",
            "60\n",
            "61\n",
            "62\n",
            "63\n",
            "64\n",
            "65\n",
            "66\n",
            "67\n",
            "68\n",
            "69\n",
            "70\n",
            "71\n",
            "72\n",
            "73\n",
            "74\n",
            "75\n",
            "76\n",
            "77\n",
            "78\n",
            "79\n",
            "80\n",
            "81\n",
            "82\n",
            "83\n",
            "84\n",
            "85\n",
            "86\n",
            "87\n",
            "88\n",
            "89\n",
            "90\n",
            "91\n",
            "92\n",
            "93\n",
            "94\n",
            "95\n",
            "96\n",
            "97\n",
            "98\n",
            "99\n",
            "100\n",
            "101\n",
            "102\n",
            "103\n",
            "104\n",
            "105\n",
            "106\n",
            "107\n",
            "108\n",
            "109\n",
            "110\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for passo in range(1,11):\n",
        "    print(f' vc está executando o passo {passo}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_6GmxoCk_Udc",
        "outputId": "ef718c49-71ab-4e1e-d71c-ac489dd1e9da"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            " vc está executando o passo 1\n",
            " vc está executando o passo 2\n",
            " vc está executando o passo 3\n",
            " vc está executando o passo 4\n",
            " vc está executando o passo 5\n",
            " vc está executando o passo 6\n",
            " vc está executando o passo 7\n",
            " vc está executando o passo 8\n",
            " vc está executando o passo 9\n",
            " vc está executando o passo 10\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "paises = ['brasil','portugal','espanha','argentina']\n",
        "estacoes = ['Primavera', 'Verão', 'Outono', 'Inverno']\n",
        "for pais in paises:\n",
        "    for estacao in estacoes:\n",
        "      print(f'{pais} e {estacoes}')\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cu9AfNbS_rwG",
        "outputId": "d6ac7c00-6492-4167-a115-840e08b43f9e"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "brasil e ['Primavera', 'Verão', 'Outono', 'Inverno']\n",
            "brasil e ['Primavera', 'Verão', 'Outono', 'Inverno']\n",
            "brasil e ['Primavera', 'Verão', 'Outono', 'Inverno']\n",
            "brasil e ['Primavera', 'Verão', 'Outono', 'Inverno']\n",
            "portugal e ['Primavera', 'Verão', 'Outono', 'Inverno']\n",
            "portugal e ['Primavera', 'Verão', 'Outono', 'Inverno']\n",
            "portugal e ['Primavera', 'Verão', 'Outono', 'Inverno']\n",
            "portugal e ['Primavera', 'Verão', 'Outono', 'Inverno']\n",
            "espanha e ['Primavera', 'Verão', 'Outono', 'Inverno']\n",
            "espanha e ['Primavera', 'Verão', 'Outono', 'Inverno']\n",
            "espanha e ['Primavera', 'Verão', 'Outono', 'Inverno']\n",
            "espanha e ['Primavera', 'Verão', 'Outono', 'Inverno']\n",
            "argentina e ['Primavera', 'Verão', 'Outono', 'Inverno']\n",
            "argentina e ['Primavera', 'Verão', 'Outono', 'Inverno']\n",
            "argentina e ['Primavera', 'Verão', 'Outono', 'Inverno']\n",
            "argentina e ['Primavera', 'Verão', 'Outono', 'Inverno']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for x in range(1,11):\n",
        "    for y in range(1,6):\n",
        "        print(f'valor de {x} e o valor de {y}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "collapsed": true,
        "id": "XTmIOS4CEdgK",
        "outputId": "d45f56d8-3aa8-4ccb-9c41-13edd0c36fef"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "valor de 1 e o valor de 1\n",
            "valor de 1 e o valor de 2\n",
            "valor de 1 e o valor de 3\n",
            "valor de 1 e o valor de 4\n",
            "valor de 1 e o valor de 5\n",
            "valor de 2 e o valor de 1\n",
            "valor de 2 e o valor de 2\n",
            "valor de 2 e o valor de 3\n",
            "valor de 2 e o valor de 4\n",
            "valor de 2 e o valor de 5\n",
            "valor de 3 e o valor de 1\n",
            "valor de 3 e o valor de 2\n",
            "valor de 3 e o valor de 3\n",
            "valor de 3 e o valor de 4\n",
            "valor de 3 e o valor de 5\n",
            "valor de 4 e o valor de 1\n",
            "valor de 4 e o valor de 2\n",
            "valor de 4 e o valor de 3\n",
            "valor de 4 e o valor de 4\n",
            "valor de 4 e o valor de 5\n",
            "valor de 5 e o valor de 1\n",
            "valor de 5 e o valor de 2\n",
            "valor de 5 e o valor de 3\n",
            "valor de 5 e o valor de 4\n",
            "valor de 5 e o valor de 5\n",
            "valor de 6 e o valor de 1\n",
            "valor de 6 e o valor de 2\n",
            "valor de 6 e o valor de 3\n",
            "valor de 6 e o valor de 4\n",
            "valor de 6 e o valor de 5\n",
            "valor de 7 e o valor de 1\n",
            "valor de 7 e o valor de 2\n",
            "valor de 7 e o valor de 3\n",
            "valor de 7 e o valor de 4\n",
            "valor de 7 e o valor de 5\n",
            "valor de 8 e o valor de 1\n",
            "valor de 8 e o valor de 2\n",
            "valor de 8 e o valor de 3\n",
            "valor de 8 e o valor de 4\n",
            "valor de 8 e o valor de 5\n",
            "valor de 9 e o valor de 1\n",
            "valor de 9 e o valor de 2\n",
            "valor de 9 e o valor de 3\n",
            "valor de 9 e o valor de 4\n",
            "valor de 9 e o valor de 5\n",
            "valor de 10 e o valor de 1\n",
            "valor de 10 e o valor de 2\n",
            "valor de 10 e o valor de 3\n",
            "valor de 10 e o valor de 4\n",
            "valor de 10 e o valor de 5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "celulares = ['samsung','motorola','iphone','nokia']\n",
        "versoes = ['10','9','11','7']\n",
        "\n",
        "for celular in celulares:\n",
        "    for versao in versoes:\n",
        "        print(f'{celular} e {versao}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bI2d-C5oE6rM",
        "outputId": "de28d361-d881-4787-eba6-a0bb2e4ac8ba"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "samsung e 10\n",
            "samsung e 9\n",
            "samsung e 11\n",
            "samsung e 7\n",
            "motorola e 10\n",
            "motorola e 9\n",
            "motorola e 11\n",
            "motorola e 7\n",
            "iphone e 10\n",
            "iphone e 9\n",
            "iphone e 11\n",
            "iphone e 7\n",
            "nokia e 10\n",
            "nokia e 9\n",
            "nokia e 11\n",
            "nokia e 7\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# iteráveis é um tipo de dados que indica passar por ele\n",
        "\n",
        "for item in range(10):\n",
        "    print(item)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ge4V53yrKm99",
        "outputId": "afeae9b8-d6f4-4945-c0cd-e6da1032bf86"
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for letra in 'Python':\n",
        "    print(letra)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JBTUnpmdLUa3",
        "outputId": "4f536b69-06a0-4b43-8140-3886e68d8c64"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "P\n",
            "y\n",
            "t\n",
            "h\n",
            "o\n",
            "n\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for item in [1,2,3]:\n",
        "    print(item)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "whVV1V9YLbWo",
        "outputId": "24f136f1-3ab2-4235-bdf2-ae0fc728229e"
      },
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import random # Import the random module\n",
        "number_to_guess = random.randint(1, 100)\n",
        "attempts = 0\n",
        "print(\"I have chosen a number between 1 and 100. Try to guess it!\")"
      ],
      "metadata": {
        "id": "79MlNcfMLjzT",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "17865ae3-e0da-4175-91a8-f9e29a529668"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "I have chosen a number between 1 and 100. Try to guess it!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "\n",
        "# Nome original do arquivo\n",
        "original_filename = 'original_file.csv'\n",
        "\n",
        "# Novo nome do arquivo\n",
        "new_filename = 'renamed_file.csv'\n",
        "\n",
        "try:\n",
        "    # Verifica se o arquivo original existe\n",
        "    if not os.path.exists(original_filename):\n",
        "        raise FileNotFoundError(f\"O arquivo '{original_filename}' não foi encontrado.\")\n",
        "\n",
        "    # Renomeia o arquivo\n",
        "    os.rename(original_filename, new_filename)\n",
        "    print(f\"Arquivo renomeado com sucesso: '{original_filename}' -> '{new_filename}'\")\n",
        "\n",
        "except FileNotFoundError as e:\n",
        "    print(e)\n",
        "except PermissionError:\n",
        "    print(\"Permissão negada: verifique se você tem permissão para renomear este arquivo.\")\n",
        "except Exception as e:\n",
        "    print(f\"Ocorreu um erro inesperado: {e}\")\n",
        "\n"
      ],
      "metadata": {
        "id": "ma-oN1zaurbw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "df6eee7b-5960-4ae2-e893-2c9a198502a7"
      },
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "O arquivo 'original_file.csv' não foi encontrado.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# using regex to find all words that contain 'apple'\n",
        "\n",
        "string = 'apple orange pear pineapple snapple durian'\n",
        "\n",
        "import re\n",
        "\n",
        "regex = r'\\b\\w*apple\\b'\n",
        "print(re.findall(regex, string))\n",
        "\n",
        "# ['apple', 'pineapple', 'snapple']"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HhFnoLDun64V",
        "outputId": "6cc4cbd7-14d7-4be2-fe15-0fddd3165a2f"
      },
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'pineapple', 'snapple']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import unicodedata\n",
        "import re\n",
        "\n",
        "\"\"\"\n",
        "A remoção de acentos foi baseada em uma resposta no Stack Overflow.\n",
        "http://stackoverflow.com/a/517974/3464573\n",
        "\"\"\"\n",
        "\n",
        "def removerAcentosECaracteresEspeciais(palavra):\n",
        "\n",
        "    # Unicode normalize transforma um caracter em seu equivalente em latin.\n",
        "    nfkd = unicodedata.normalize('NFKD', palavra)\n",
        "    palavraSemAcento = u\"\".join([c for c in nfkd if not unicodedata.combining(c)])\n",
        "\n",
        "    # Usa expressão regular para retornar a palavra apenas com números, letras e espaço\n",
        "    return re.sub('[^a-zA-Z0-9 \\\\\\]', '', palavraSemAcento)"
      ],
      "metadata": {
        "id": "ZSdEFjKktE-l"
      },
      "execution_count": 35,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Remover Acentos"
      ],
      "metadata": {
        "id": "rywfjdhxqv3a"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install unidecode\n",
        "import pandas as pd\n",
        "from unidecode import unidecode\n",
        "\n",
        "# Exemplo de DataFrame\n",
        "data = {' Titulo': ['Musculo-esquelético', 'RESSONÂNCIA MAGNÉTICA MULTIPAR', 'BIÓPSIA DE PROSTÁTA GUIADA POR ULTRASSONOGRAFIA','RESSONÂNCIA MAGNÉTICA MULTIPARAMÉTRICA DA PRÓSTATA',' ULTRASSONOGRAFIA DE PÊNIS'\n",
        "                                         ,'BIÓPSIA PROSTÁTICA GUIADA POR ULTRASSOM COM FUSÃO DA RESSONÂNCIA MAGNÉTICA','BIÓPSIA PROSTATICA GUIADA POR ULTRASSONOGRAFIA  TRANSRETAL','BIOPSIA PRÓSTATICA GUIADA POR ULTRASSONOGRAFIA']}\n",
        "df = pd.DataFrame(data)\n",
        "\n",
        "# Função para remover acentos\n",
        "def remover_acentos(texto):\n",
        "    return unidecode(texto)\n",
        "\n",
        "# Aplicar a função a todo o DataFrame\n",
        "df_result = df.applymap(remover_acentos)\n",
        "\n",
        "print(df_result)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BbpjesUouQ-S",
        "outputId": "22e956ca-f104-47fa-c4e9-b9c1ad6c2200"
      },
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting unidecode\n",
            "  Downloading Unidecode-1.3.8-py3-none-any.whl.metadata (13 kB)\n",
            "Downloading Unidecode-1.3.8-py3-none-any.whl (235 kB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m235.5/235.5 kB\u001b[0m \u001b[31m3.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hInstalling collected packages: unidecode\n",
            "Successfully installed unidecode-1.3.8\n",
            "                                              Titulo\n",
            "0                                Musculo-esqueletico\n",
            "1                     RESSONANCIA MAGNETICA MULTIPAR\n",
            "2    BIOPSIA DE PROSTATA GUIADA POR ULTRASSONOGRAFIA\n",
            "3  RESSONANCIA MAGNETICA MULTIPARAMETRICA DA PROS...\n",
            "4                          ULTRASSONOGRAFIA DE PENIS\n",
            "5  BIOPSIA PROSTATICA GUIADA POR ULTRASSOM COM FU...\n",
            "6  BIOPSIA PROSTATICA GUIADA POR ULTRASSONOGRAFIA...\n",
            "7     BIOPSIA PROSTATICA GUIADA POR ULTRASSONOGRAFIA\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-36-adf530b5fce1>:15: FutureWarning: DataFrame.applymap has been deprecated. Use DataFrame.map instead.\n",
            "  df_result = df.applymap(remover_acentos)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Ultimas letras em Maiusculas"
      ],
      "metadata": {
        "id": "ihJacCMTs7Sa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def modify(s):\n",
        "    if len(s) < 2:\n",
        "       return s.upper()\n",
        "    return s[0].upper() + s[1:-1] + s[-1].upper()"
      ],
      "metadata": {
        "id": "5iXtMVPHsa23"
      },
      "execution_count": 37,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(modify('coderpython'))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eBsRBjduse3q",
        "outputId": "cfcd6ea8-a456-4195-819e-3f208dcc84c8"
      },
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "CoderpythoN\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import re\n",
        "\n",
        "# Read text\n",
        "text = \"Read the data from https://www.gfg.org/ posted by gfg@gmail.com\"\n",
        "\n",
        "# Remove all non-alphanumeric characters\n",
        "clean_text = re.sub(r'[^a-zA-Z0-9\\s]', '', text)\n",
        "\n",
        "# Find all email addresses in text\n",
        "emails = re.findall(r'\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Z|a-z]{2,}\\b', text)\n",
        "\n",
        "# Replace all phone numbers with \"PHONE NUMBER\"\n",
        "clean_text = re.sub(r'\\d{3}[-.\\s]??\\d{3}[-.\\s]??\\d{4}', 'PHONE NUMBER', clean_text)\n",
        "\n",
        "# Write cleaned text to output file\n",
        "print(clean_text)\n",
        "\n",
        "print(\"Emails found:\", emails)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rDfo5KPCzgmw",
        "outputId": "4fc34b9f-fddb-4d57-f45f-570de5f8c28e"
      },
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Read the data from httpswwwgfgorg posted by gfggmailcom\n",
            "Emails found: ['gfg@gmail.com']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "REGEX\n",
        "- LIMPA O CONTATO\n"
      ],
      "metadata": {
        "id": "5qWj53mq3x_-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import re\n",
        "\n",
        "# Texto de exemplo contendo números de telefone\n",
        "text = \"\"\"\n",
        "Luciana Sampaio  123-456-7890.\n",
        "chama pelo  987.654.3210 or 456 123 7890.\n",
        "Meu Ultimo contato  (123) 456-7890.\n",
        "\"\"\"\n",
        "\n",
        "# Substitui todos os números de telefone por \"PHONE NUMBER\"\n",
        "clean_text = re.sub(r'\\(?\\d{3}\\)?[-.\\s]??\\d{3}[-.\\s]??\\d{4}', 'PHONE NUMBER', text)\n",
        "\n",
        "print(clean_text)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eFB-3tkmztwV",
        "outputId": "18954480-3430-40d7-8972-1e52effb83b1"
      },
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Luciana Sampaio fone  PHONE NUMBER.\n",
            "chama pelo  PHONE NUMBER or PHONE NUMBER.\n",
            "Meu Ultimo contato  PHONE NUMBER.\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import re # Import the 're' module for regular expression operations\n",
        "\n",
        "def remove_special_characters(value):\n",
        "    pattern = r'[^a-zA-Z0-9\\s]'\n",
        "    value = re.sub(pattern, '', value)\n",
        "    return value\n",
        "\n",
        "remove_special_characters('^9SZ, World!')"
      ],
      "metadata": {
        "id": "NmK_CZGzw0uU",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "6d5f91e2-ad52-4fae-dd13-a1fb998d75a6"
      },
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'9SZ World'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 44
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "remove_special_characters('aSZ, World!')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "HqYrEZFXEHci",
        "outputId": "3e446768-8875-458d-f09b-79887249cc08"
      },
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'aSZ World'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 45
        }
      ]
    }
  ]
}