PythonCheatSheet.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Folha de dicas do Python "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conteúdo  \n",
    "1. <a href='#section1'>Sintaxe e espaço em branco</a>\n",
    "2. <a href='#section2'>Comentários</a>\n",
    "3. <a href='#section3'>Números e operações</a>\n",
    "4. <a href='#section4'>Manipulação de strings</a>\n",
    "5. <a href='#section5'>Listas, tuplas e dicionários</a>\n",
    "6. <a href='#section6'>JSON</a>\n",
    "7. <a href='#section7'>Loops</a>\n",
    "8. <a href='#section8'>Tratamento de arquivos</a>\n",
    "9. <a href='#section9'>Funções</a>\n",
    "10. <a href='#section10'>Trabalhar com data/hora</a>\n",
    "11. <a href='#section11'>NumPy</a>\n",
    "12. <a href='#section12'>Pandas</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para executar uma célula, pressione **Shift+Enter** ou clique em **Run** (Executar) na parte superior da página."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"section_1\"></a>\n",
    "\n",
    "## 1. Sintaxe e espaço em branco\n",
    "O Python usa espaço recuado para indicar o nível de instruções. A célula a seguir é um exemplo em que '**if'** (se) e '**else**' (senão) estão no mesmo nível, enquanto '**print**' (imprimir) é separado por espaço para um nível diferente. O espaçamento deve ser o mesmo para itens que estão no mesmo nível."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "student_number = input(\"Enter your student number:\")\n",
    "if int(student_number) != 0:\n",
    "    print(\"Welcome student {}\".format(student_number))\n",
    "else:\n",
    "    print(\"Try again!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='section2'></a>\n",
    "\n",
    "## 2. Comentários\n",
    "No Python, os comentários começam com cerquilha '#' e se estendem até o final da linha. O sinal '#' pode estar no início da linha ou após o código. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is code to print hello world!\n",
    "\n",
    "print(\"Hello world!\") # Print statement for hello world\n",
    "print(\"# is not a comment in this case\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='section3'></a>\n",
    "\n",
    "## 3. Números e operações\n",
    "\n",
    "Assim como ocorre com outras linguagens de programação, há quatro tipos de números: \n",
    "- Números inteiros (por exemplo, 1, 20, 45, 1000) indicados por *int* (inteiro)\n",
    "- Números de ponto flutuante (por exemplo, 1, 25, 20, 35, 1000,00) indicados por *float* (flutuante)\n",
    "- Números inteiros longos \n",
    "- Números complexos (por exemplo, x+2y em que x é conhecido)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Operação | Resultado\n",
    "----------------|-------------------------------------               \n",
    "x+y | Soma de x e y\t\n",
    "x - y | Diferença de x e y\t\n",
    "x* y | Produto de x e y\t\n",
    "x/y | Quociente de x e y\n",
    "x// y | Quociente de x e y (piso)\n",
    "x % y | Resto de x/y\n",
    "abs (x) | Valor absoluto de x\t\n",
    "int (x) | x convertido em inteiro\n",
    "long (x) | x convertido em inteiro longo\n",
    "float (x) | x convertido em ponto flutuante\t\n",
    "pow (x, y) | x para a potência y\t\n",
    "x** y | x para a potência y\t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Number examples\n",
    "a = 5 + 8\n",
    "print(\"Sum of int numbers: {} and number format is {}\".format(a, type(a)))\n",
    "\n",
    "b = 5 + 2.3\n",
    "print (\"Sum of int and {} and number format is {}\".format(b, type(b)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='section4'></a>\n",
    "\n",
    "## 4. Manipulação de strings\n",
    "\n",
    "O Python tem recursos avançados, como outras linguagens de programação para manipulação de strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Store strings in a variable\n",
    "test_word = \"hello world to everyone\"\n",
    "\n",
    "# Print the test_word value\n",
    "print(test_word)\n",
    "\n",
    "# Use [] to access the character of the string. The first character is indicated by '0'.\n",
    "print(test_word[0])\n",
    "\n",
    "# Use the len() function to find the length of the string\n",
    "print(len(test_word))\n",
    "\n",
    "# Some examples of finding in strings\n",
    "print(test_word.count('l')) # Count number of times l repeats in the string\n",
    "print(test_word.find(\"o\")) # Find letter 'o' in the string. Returns the position of first match.\n",
    "print(test_word.count(' ')) # Count number of spaces in the string\n",
    "print(test_word.upper()) # Change the string to uppercase\n",
    "print(test_word.lower()) # Change the string to lowercase\n",
    "print(test_word.replace(\"everyone\",\"you\")) # Replace word \"everyone\" with \"you\"\n",
    "print(test_word.title()) # Change string to title format\n",
    "print(test_word + \"!!!\") # Concatenate strings\n",
    "print(\":\".join(test_word)) # Add \":\" between each character\n",
    "print(\"\".join(reversed(test_word))) # Reverse the string "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='section5'></a>\n",
    "\n",
    "## 5. Listas, tuplas e dicionários\n",
    "\n",
    "O Python oferece suporte a listas de tipos de dados, tuplas, dicionários e matrizes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Listas\n",
    "\n",
    "Uma lista é criada colocando todos os itens (elementos) dentro de colchetes\\[ ] separados por vírgulas. Uma lista pode ter qualquer número de itens, e eles podem ser de tipos diferentes (número inteiro, flutuante, strings etc.)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A Python list is similar to an array. You can create an empty list too.\n",
    "\n",
    "my_list = []\n",
    "\n",
    "first_list = [3, 5, 7, 10]\n",
    "second_list = [1, 'python', 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Nest multiple lists\n",
    "nested_list = [first_list, second_list]\n",
    "nested_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Combine multiple lists\n",
    "combined_list = first_list + second_list\n",
    "combined_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can slice a list, just like strings\n",
    "combined_list[0:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Append a new entry to the list\n",
    "combined_list.append(600)\n",
    "combined_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Remove the last entry from the list\n",
    "combined_list.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Iterate the list\n",
    "for item in combined_list:\n",
    "    print(item)    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuplas\n",
    "\n",
    "Uma tupla é semelhante a uma lista, mas você as usa com parênteses ( ) em vez de colchetes. A principal diferença é que uma tupla é imutável, enquanto uma lista é mutável."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_tuple = (1, 2, 3, 4, 5)\n",
    "my_tuple[1:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dicionários\n",
    "\n",
    "Um dicionário também é conhecido como uma matriz associativa. Um dicionário consiste em uma coleção de pares de chave/valor. Cada par de chave/valor mapeia a chave para seu valor associado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "desk_location = {'jack': 123, 'joe': 234, 'hary': 543}\n",
    "desk_location['jack']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='section6'></a>\n",
    "\n",
    "## 6. JSON \n",
    "\n",
    "JSON é texto gravado em JavaScript Object Notation. O Python tem um pacote integrado chamado `json` que pode ser usado para trabalhar com dados JSON."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "\n",
    "# Sample JSON data\n",
    "x = '{\"first_name\":\"Jane\", \"last_name\":\"Doe\", \"age\":25, \"city\":\"Chicago\"}'\n",
    "\n",
    "# Read JSON data\n",
    "y = json.loads(x)\n",
    "\n",
    "# Print the output, which is similar to a dictonary\n",
    "print(\"Employee name is \"+ y[\"first_name\"] + \" \" + y[\"last_name\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='section7'></a>\n",
    "\n",
    "##7. Loops\n",
    "**If, Else, Else, ElIf loop**: o Python é compatível com instruções condicionais, como qualquer outra linguagem de programação. O Python depende do recuo (espaço em branco no início da linha) para definir o escopo do código. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 22\n",
    "b = 33\n",
    "c = 100\n",
    "\n",
    "# if ... else example\n",
    "if a > b:\n",
    "    print(\"a is greater than b\")\n",
    "else:\n",
    "    print(\"b is greater than a\")\n",
    "    \n",
    "    \n",
    "# if .. else .. elif example\n",
    "\n",
    "if a > b:\n",
    "    print(\"a is greater than b\")\n",
    "elif b > c:\n",
    "    print(\"b is greater than c\")\n",
    "else:\n",
    "    print(\"b is greater than a and c is greater than b\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Loop While:** (loop Enquanto) executa um conjunto de instruções, desde que a condição seja verdadeira"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sample while example\n",
    "i = 1\n",
    "while i < 10:\n",
    "    print(\"count is \" + str(i))\n",
    "    i += 1\n",
    "\n",
    "print(\"=\"*10)\n",
    "\n",
    "# Continue to next iteration if x is 2. Finally, print message once the condition is false.\n",
    "\n",
    "x = 0\n",
    "while x < 5:\n",
    "    x += 1\n",
    "    if x == 2:\n",
    "        continue\n",
    "    print(x)\n",
    "else:\n",
    "    print(\"x is no longer less than 5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Loop For:** (loop Para) `For` um loop é mais parecido com um iterador em Python. Um loop `For` é usado para iterar sobre uma sequência (lista, tupla, dicionário, conjunto, string ou intervalo)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sample for loop examples\n",
    "fruits = [\"orange\", \"banana\", \"apple\", \"grape\", \"cherry\"]\n",
    "for fruit in fruits:\n",
    "    print(fruit)\n",
    "\n",
    "print(\"\\n\")\n",
    "print(\"=\"*10)\n",
    "print(\"\\n\")\n",
    "\n",
    "# Iterating range\n",
    "for x in range(1, 10, 2):\n",
    "    print(x)\n",
    "else:\n",
    "    print(\"task complete\")\n",
    "\n",
    "print(\"\\n\")\n",
    "print(\"=\"*10)\n",
    "print(\"\\n\")\n",
    "\n",
    "# Iterating multiple lists\n",
    "traffic_lights = [\"red\", \"yellow\", \"green\"]\n",
    "action = [\"stop\", \"slow down\", \"go\"]\n",
    "\n",
    "for light in traffic_lights:\n",
    "    for task in action:\n",
    "        print(light, task)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='section8'></a>\n",
    "\n",
    "## 8. Tratamento de arquivos\n",
    "A principal função para trabalhar com arquivos em Python é a função `open()`. A função `open()` usa dois parâmetros: nome do arquivo e modo.\n",
    "\n",
    "Existem quatro métodos diferentes (modos) para abrir um arquivo:\n",
    "\n",
    "- \"r\" - Ler\n",
    "- \"a\" - Anexar\n",
    "- \"w\" - Gravar\n",
    "- \"x\" - Criar\n",
    "\n",
    "Além disso, você pode especificar se o arquivo deve ser processado no modo binário ou de texto.\n",
    "\n",
    "- \"t\" - Texto\n",
    "- \"b\" - Binário"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's create a test text file\n",
    "!echo \"This is a test file with text in it. This is the first line.\" > test.txt\n",
    "!echo \"This is the second line.\" >> test.txt\n",
    "!echo \"This is the third line.\" >> test.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read file\n",
    "file = open('test.txt', 'r')\n",
    "print(file.read())\n",
    "file.close()\n",
    "\n",
    "print(\"\\n\")\n",
    "print(\"=\"*10)\n",
    "print(\"\\n\")\n",
    "\n",
    "# Read first 10 characters of the file\n",
    "file = open('test.txt', 'r')\n",
    "print(file.read(10))\n",
    "file.close()\n",
    "\n",
    "print(\"\\n\")\n",
    "print(\"=\"*10)\n",
    "print(\"\\n\")\n",
    "\n",
    "# Read line from the file\n",
    "\n",
    "file = open('test.txt', 'r')\n",
    "print(file.readline())\n",
    "file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create new file\n",
    "\n",
    "file = open('test2.txt', 'w')\n",
    "file.write(\"This is content in the new test2 file.\")\n",
    "file.close()\n",
    "\n",
    "# Read the content of the new file\n",
    "file = open('test2.txt', 'r')\n",
    "print(file.read())\n",
    "file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Update file\n",
    "file = open('test2.txt', 'a')\n",
    "file.write(\"\\nThis is additional content in the new file.\")\n",
    "file.close()\n",
    "\n",
    "# Read the content of the new file\n",
    "file = open('test2.txt', 'r')\n",
    "print(file.read())\n",
    "file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Delete file\n",
    "import os\n",
    "file_names = [\"test.txt\", \"test2.txt\"]\n",
    "for item in file_names:\n",
    "    if os.path.exists(item):\n",
    "        os.remove(item)\n",
    "        print(f\"File {item} removed successfully!\")\n",
    "    else:\n",
    "        print(f\"{item} file does not exist.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='section9'></a>\n",
    "\n",
    "## 9. Funções\n",
    "\n",
    "Uma função é um bloco de código que é executado quando é chamado. Você pode informar dados, ou *parâmetros*, para a função. No Python, uma função é definida pelo `def`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Defining a function\n",
    "def new_funct():\n",
    "    print(\"A simple function\")\n",
    "\n",
    "# Calling the function\n",
    "new_funct()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sample fuction with parameters\n",
    "\n",
    "def param_funct(first_name):\n",
    "    print(f\"Employee name is {first_name}.\")\n",
    "\n",
    "param_funct(\"Harry\")\n",
    "param_funct(\"Larry\")\n",
    "param_funct(\"Shally\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Funções anônimas (lambda):** Lambda é uma pequena função anônima. Uma função Lambda pode usar qualquer número de argumentos, mas apenas uma expressão."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sample lambda example\n",
    "x = lambda y: y + 100\n",
    "print(x(15))\n",
    "\n",
    "print(\"\\n\")\n",
    "print(\"=\"*10)\n",
    "print(\"\\n\")\n",
    "\n",
    "x = lambda a, b: a*b/100\n",
    "print(x(2,4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='section10'></a>\n",
    "\n",
    "## 10. Trabalhar com data/hora \n",
    "\n",
    "Um módulo `datetime` em Python pode ser usado para trabalhar com objetos de data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime\n",
    "\n",
    "x = datetime.datetime.now()\n",
    "\n",
    "print(x)\n",
    "print(x.year)\n",
    "print(x.strftime(\"%A\"))\n",
    "print(x.strftime(\"%B\"))\n",
    "print(x.strftime(\"%d\"))\n",
    "print(x.strftime(\"%H:%M:%S %p\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='section11'></a>\n",
    "\n",
    "## 11. NumPy\n",
    "\n",
    "O NumPy é o pacote fundamental para computação científica com Python. Entre outras coisas, ele contém:\n",
    "\n",
    "- Objeto poderoso de matriz N-dimensional\n",
    "- Funções sofisticadas (transmissão)\n",
    "- Ferramentas para integrar código C/C++ e Fortran\n",
    "- Recursos úteis de álgebra linear, transformação de Fourier e número aleatório"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Install NumPy using pip\n",
    "!pip install --upgrade pip\n",
    "!pip install numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import NumPy module\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Inspecionando sua matriz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create array\n",
    "a = np.arange(15).reshape(3, 5) # Create array with range 0-14 in 3 by 5 dimension\n",
    "b = np.zeros((3,5)) # Create array with zeroes\n",
    "c = np.ones( (2,3,4), dtype=np.int16 ) # Createarray with ones and defining data types\n",
    "d = np.ones((3,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.shape # Array dimension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(b)# Length of array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c.ndim # Number of array dimensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.size # Number of array elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b.dtype # Data type of array elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c.dtype.name # Name of data type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c.astype(float) # Convert an array type to a different type"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operações matemáticas básicas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create array\n",
    "a = np.arange(15).reshape(3, 5) # Create array with range 0-14 in 3 by 5 dimension\n",
    "b = np.zeros((3,5)) # Create array with zeroes\n",
    "c = np.ones( (2,3,4), dtype=np.int16 ) # Createarray with ones and defining data types\n",
    "d = np.ones((3,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.add(a,b) # Addition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.subtract(a,b) # Substraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.divide(a,d) # Division"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.multiply(a,d) # Multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.array_equal(a,b) # Comparison - arraywise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Aggregate functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create array\n",
    "a = np.arange(15).reshape(3, 5) # Create array with range 0-14 in 3 by 5 dimension\n",
    "b = np.zeros((3,5)) # Create array with zeroes\n",
    "c = np.ones( (2,3,4), dtype=np.int16 ) # Createarray with ones and defining data types\n",
    "d = np.ones((3,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.sum() # Array-wise sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.min() # Array-wise min value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.mean() # Array-wise mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.max(axis=0) # Max value of array row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.std(a) # Standard deviation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Subconjunto, divisão e indexação"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create array\n",
    "a = np.arange(15).reshape(3, 5) # Create array with range 0-14 in 3 by 5 dimension\n",
    "b = np.zeros((3,5)) # Create array with zeroes\n",
    "c = np.ones( (2,3,4), dtype=np.int16 ) # Createarray with ones and defining data types\n",
    "d = np.ones((3,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[1,2] # Select element of row 1 and column 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[0:2] # Select items on index 0 and 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[:1] # Select all items at row 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[-1:] # Select all items from last row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[a<2] # Select elements from 'a' that are less than 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Manipulação de matriz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create array\n",
    "a = np.arange(15).reshape(3, 5) # Create array with range 0-14 in 3 by 5 dimension\n",
    "b = np.zeros((3,5)) # Create array with zeroes\n",
    "c = np.ones( (2,3,4), dtype=np.int16 ) # Createarray with ones and defining data types\n",
    "d = np.ones((3,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.transpose(a) # Transpose array 'a'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.ravel() # Flatten the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.reshape(5,-2) # Reshape but don't change the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.append(a,b) # Append items to the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.concatenate((a,d), axis=0) # Concatenate arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.vsplit(a,3) # Split array vertically at 3rd index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.hsplit(a,5) # Split array horizontally at 5th index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='section12'></a>\n",
    "\n",
    "## pandas\n",
    "\n",
    "O pandas é uma biblioteca de código aberto licenciada por BSD que fornece estruturas de dados de alto desempenho e fáceis de usar e ferramentas de análise de dados para a linguagem de programação Python.\n",
    "\n",
    "O Pandas DataFrames são a representação na memória mais amplamente usada de coleções de dados complexas dentro do Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Install pandas, xlrd, and openpyxl using pip\n",
    "!pip install pandas\n",
    "!pip install xlrd openpyxl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import NumPy and Pandas modules\n",
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sample dataframe df\n",
    "df = pd.DataFrame({'num_legs': [2, 4, np.nan, 0],\n",
    "                   'num_wings': [2, 0, 0, 0],\n",
    "                   'num_specimen_seen': [10, np.nan, 1, 8]},\n",
    "                   index=['falcon', 'dog', 'spider', 'fish'])\n",
    "df # Display dataframe df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Another sample dataframe df1 - using NumPy array with datetime index and labeled column\n",
    "df1 = pd.date_range('20130101', periods=6)\n",
    "df1 = pd.DataFrame(np.random.randn(6, 4), index=df1, columns=list('ABCD'))\n",
    "df1 # Display dataframe df1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualização de dados"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1 = pd.date_range('20130101', periods=6)\n",
    "df1 = pd.DataFrame(np.random.randn(6, 4), index=df1, columns=list('ABCD'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.head(2) # View top data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.tail(2) # View bottom data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.index # Display index column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.dtypes # Inspect datatypes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.describe() # Display quick statistics summary of data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Subconjunto, divisão e indexação"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1 = pd.date_range('20130101', periods=6)\n",
    "df1 = pd.DataFrame(np.random.randn(6, 4), index=df1, columns=list('ABCD'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.T # Transpose data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.sort_index(axis=1, ascending=False) # Sort by an axis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.sort_values(by='B') # Sort by values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1['A'] # Select column A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1[0:3] # Select index 0 to 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1['20130102':'20130104'] # Select from index matching the values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.loc[:, ['A', 'B']] # Select on a multi-axis by label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.iloc[3] # Select via the position of the passed integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1[df1 > 0] # Select values from a DataFrame where a boolean condition is met"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df2 = df1.copy() # Copy the df1 dataset to df2\n",
    "df2['E'] = ['one', 'one', 'two', 'three', 'four', 'three'] # Add column E with value\n",
    "df2[df2['E'].isin(['two', 'four'])] # Use isin method for filtering"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dados ausentes\n",
    "\n",
    "O pandas usa principalmente o valor `np.nan` para representar dados ausentes. Ele não é incluído em computações por padrão."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame({'num_legs': [2, 4, np.nan, 0],\n",
    "                   'num_wings': [2, 0, 0, 0],\n",
    "                   'num_specimen_seen': [10, np.nan, 1, 8]},\n",
    "                   index=['falcon', 'dog', 'spider', 'fish'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.dropna(how='any') # Drop any rows that have missing data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.dropna(how='any', axis=1) # Drop any columns that have missing data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.fillna(value=5) # Fill missing data with value 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.isna(df) # To get boolean mask where data is missing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tratamento de arquivos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame({'num_legs': [2, 4, np.nan, 0],\n",
    "                   'num_wings': [2, 0, 0, 0],\n",
    "                   'num_specimen_seen': [10, np.nan, 1, 8]},\n",
    "                   index=['falcon', 'dog', 'spider', 'fish'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.to_csv('foo.csv') # Write to CSV file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.read_csv('foo.csv') # Read from CSV file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.to_excel('foo.xlsx', sheet_name='Sheet1') # Write to Microsoft Excel file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.read_excel('foo.xlsx', 'Sheet1', index_col=None, na_values=['NA']) # Read from Microsoft Excel file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotagem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Install Matplotlib using pip\n",
    "!pip install matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import pyplot as plt # Import Matplotlib module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate random time-series data\n",
    "ts = pd.Series(np.random.randn(1000),index=pd.date_range('1/1/2000', periods=1000)) \n",
    "ts.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ts = ts.cumsum()\n",
    "ts.plot() # Plot graph\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# On a DataFrame, the plot() method is convenient to plot all of the columns with labels\n",
    "df4 = pd.DataFrame(np.random.randn(1000, 4), index=ts.index,columns=['A', 'B', 'C', 'D'])\n",
    "df4 = df4.cumsum()\n",
    "df4.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df4.plot()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "conda_python3",
   "language": "python",
   "name": "conda_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.8.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}