Mod03ex02-parte2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "fFhFteHV695k"
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YLWEzg3N695m"
   },
   "source": [
    "### 1) Alturas  \n",
    "i. No trecho de código abaixo, crie um ndarray chamado ```altura_em_centimetros``` transformando a lista ```lista_de_alturas``` em um ndarray do numpy com a função ```np.array()```  \n",
    "ii. Crie um outro objeto ```altura_em_metros```, com os valores de ```altura_em_centimetros``` convertidos para metros."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "tx6DbJk7695o"
   },
   "outputs": [],
   "source": [
    "lista_de_centimetros = list(range(170, 190, 5))\n",
    "lista_de_centimetros = np.array(lista_de_centimetros)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([170, 175, 180, 185])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array(lista_de_centimetros)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "altura_em_centimetros  = np.array(lista_de_centimetros)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "-tXC4lyT695o"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([170, 175, 180, 185])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array(altura_em_centimetros)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "altura_em_metros = np.array(altura_em_centimetros) / 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "id": "zFDQt9_K695p"
   },
   "outputs": [],
   "source": [
    "altura_em_metros = np.array(altura_em_metros)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.7 , 1.75, 1.8 , 1.85])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array(altura_em_metros)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hlsDzubv695p"
   },
   "source": [
    "### 2) IMC  \n",
    "i. Considere que pesos em Kg dessas pessoas, na mesma ortem, estão na lista pesos ```lista_pesos = [70, 75, 80, 85]```. Crie um **ndarray** chamado ```pesos``` com a função ```np.array()``` que contenha esses valores.  \n",
    "ii. Utilizando o objeto que contém as alturas em metros e esse objeto que contém os respectivos pesos em quilos, calcule o IMC desses indivíduos utilizando a aritmética de arrays e guarde os resultados em um objeto chamado ```imc```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "id": "YL87C0It695p",
    "outputId": "f147f2f0-c5e8-407c-a708-914ddc99fa6d"
   },
   "outputs": [],
   "source": [
    "lista_pesos = [70, 75, 80, 85]\n",
    "lista_pesos\n",
    "# seu código aqui\n",
    "pesos = np.array(lista_pesos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([70, 75, 80, 85])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array(pesos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "id": "WgZtY2Ox695q"
   },
   "outputs": [],
   "source": [
    "# calcule o IMC dessas pessoas\n",
    "\n",
    "imc = pesos / (altura_em_metros**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "imc = np.array(imc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([24.22145329, 24.48979592, 24.69135802, 24.83564646])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array(imc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "k1JIBxZb695r"
   },
   "source": [
    "### 3) Endividamento\n",
    "\n",
    "Cálculos de novas variáveis como endividamento total e comprometimento de renda são essenciais para a construção de modelos financeiros em ciência de dados. Áreas não financeiras terão cálculos semelhantes também. Vamos praticar:\n",
    "\n",
    "Considere que o seguinte ndarray contém os dados de 4 pessoas, total a ser pago a empréstimos mensalmente e renda familiar:\n",
    "\n",
    "| custo fixo | dívida financeira | renda familiar |\n",
    "|:----:|:----:|:---|\n",
    "| 3000  | 1000 | 6000 |\n",
    "| 2500  | 2500 | 5500 |\n",
    "| 1000  | 3000 | 7000 |\n",
    "| 10000 | 5000 | 16000 |\n",
    "\n",
    "i. Transforme a lista de listas ```dados_financeiros``` no ndarray ```nd_financeiros```.\n",
    "> ``` dados_financeiros[[3000, 2500, 1000, 10000],[1000, 2500, 3000, 5000],[6000, 5500, 7000, 16000]] ```\n",
    "\n",
    "ii. Utilize o método ```.transpose ``` e certifique-se de que esse ndarray tenha uma linha por indivíduo e uma coluna por informação. Utilizando a indexação do numpy, imprima no output a segunda linha do array, depois a segunda coluna.\n",
    "\n",
    "iii. Pratique aritmética com nearrays e calcule o endividamento total como:\n",
    "$$endividamento\\hspace{.2cm}total = \\frac{custo \\hspace{.2cm}fixo + dívida\\hspace{.2cm}financeira}{renda\\hspace{.2cm}familiar}$$\n",
    "Guarde os resultados em uma variável chamada ```endividamento_total``` e verifique os resultados imprimindo o conteúdo dessa variável no output.\n",
    "\n",
    "iv. Considere que há um erro de digitação que precisa ser corrigido: 3o indivíduo na verdade não possui renda familiar de R\\\\$7.000,00, mas sim R\\\\$ 10.000,00. Corrija esse valor e refaça os cálculos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "id": "k17jw6kT695r"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[3000, 2500, 1000, 10000],\n",
       " [1000, 2500, 3000, 5000],\n",
       " [6000, 5500, 7000, 16000]]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# lista dados_financeiros\n",
    "dados_financeiros = [[3000, 2500, 1000, 10000],[1000, 2500, 3000, 5000],[6000, 5500, 7000, 16000]]\n",
    "dados_financeiros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "#i) transforme essa lista em um ndarray\n",
    "\n",
    "nd_financeiros = np.array(dados_financeiros)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 3000,  2500,  1000, 10000],\n",
       "       [ 1000,  2500,  3000,  5000],\n",
       "       [ 6000,  5500,  7000, 16000]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nd_financeiros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "id": "ecRsPjml695r"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 3000,  1000,  6000],\n",
       "       [ 2500,  2500,  5500],\n",
       "       [ 1000,  3000,  7000],\n",
       "       [10000,  5000, 16000]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ii) \n",
    "\n",
    "nd_financeiros.transpose()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Segunda Coluna do Array:\n",
      "[1000 2500 3000 5000]\n",
      "Segunda Linha do Array:\n",
      "[2500 2500 5500]\n"
     ]
    }
   ],
   "source": [
    "segunda_coluna = nd_financeiros[1]\n",
    "segunda_linha = nd_financeiros[:, 1]\n",
    "\n",
    "print(\"Segunda Coluna do Array:\")\n",
    "print(segunda_coluna)\n",
    "\n",
    "print(\"Segunda Linha do Array:\")\n",
    "print(segunda_linha)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "id": "RgMG-t9-695s"
   },
   "outputs": [],
   "source": [
    "# iii) Calcule o endividamento total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3000,  2500,  1000, 10000])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "custo_fixo = nd_financeiros[0]\n",
    "custo_fixo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1000, 2500, 3000, 5000])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "divida_financeira = nd_financeiros[1]\n",
    "divida_financeira"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 6000,  5500,  7000, 16000])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "renda_familiar = nd_financeiros[2]\n",
    "renda_familiar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([66.66666667, 90.90909091, 57.14285714, 93.75      ])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "endividamento_total = ((custo_fixo + divida_financeira) / renda_familiar) * 100\n",
    "endividamento_total "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Família 1 possui endividamento total de 66.67% da renda familiar.\n",
      "Família 2 possui endividamento total de 90.91% da renda familiar.\n",
      "Família 3 possui endividamento total de 57.14% da renda familiar.\n",
      "Família 4 possui endividamento total de 93.75% da renda familiar.\n"
     ]
    }
   ],
   "source": [
    "for i, endividamento in enumerate(endividamento_total):\n",
    "    print(f\"Pessoa {i+1} possui endividamento total de {endividamento:.2f}% da renda familiar.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# iv) corrigindo um valor específico"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "id": "FxaSHRgy695t"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 6000,  5500, 10000, 16000])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "renda_familiar[2] = 10000\n",
    "renda_familiar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "id": "OYxfd00O695t"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1000"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "divida_financeira[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([66.66666667, 90.90909091, 40.        , 93.75      ])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "endividamento_total = ((custo_fixo + divida_financeira) / renda_familiar) * 100\n",
    "endividamento_total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pessoa 1 possui endividamento total de 66.67% da renda familiar.\n",
      "Pessoa 2 possui endividamento total de 90.91% da renda familiar.\n",
      "Pessoa 3 possui endividamento total de 40.00% da renda familiar.\n",
      "Pessoa 4 possui endividamento total de 93.75% da renda familiar.\n"
     ]
    }
   ],
   "source": [
    "for i, endividamento in enumerate(endividamento_total):\n",
    "    print(f\"Pessoa {i+1} possui endividamento total de {endividamento:.2f}% da renda familiar.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "RghMgSOX695t"
   },
   "source": [
    "### 4) É muito comum precisarmos identificar valores especiais e darmos tratamento a eles quer seja alterando-os quer seja descartando-os. \n",
    "\n",
    "O trecho de código abaixo gera um ndarray com números pseudo aleatórios. Considere que para efeitos do estudo que virá, devemos desconsiderar valores iguais a zero. Sendo assim:\n",
    "\n",
    "i) crie um objeto ```bool_zero``` que traga uma sequencia de booleanos do mesmo tamanho que o objeto poi, e que vale ```True``` quando o valor de ```poi``` é zero, e ```False``` caso contrário.\n",
    "\n",
    "ii) Conte quantos valores zero existem. Lembre-se de que no final das contas, ```True``` vale 1 para o Python, e ```False``` vale zero, então uma boa dica seria usar a função ```sum()```.\n",
    "\n",
    "iii) Utilize a indexação booleana que você aprendeu para criar uma variável ```poi_nao_zero``` que aponta para os elementos de ```poi``` diferentes de zero. Dica: você vai pode inverter os elementos do objeto que criou em *ii)* ou escrever a comparação adequada."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "id": "Y6JUhNiT695t",
    "outputId": "06ceb3b7-5eb0-45d0-f3b3-ea6ff6f0df2a"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 3, 6, 2, 4, 5, 4, 4, 2, 0, 3, 3, 2, 8, 2, 3, 3, 3, 0, 4, 4, 2,\n",
       "       6, 6, 0, 3, 4, 3, 5, 2, 1, 3, 2, 2, 3, 2, 4, 4, 5, 7, 3, 5, 3, 3,\n",
       "       2, 2, 3, 6, 2, 2, 4, 3, 5, 2, 5, 3, 0, 2, 1, 1, 4, 4, 4, 6, 2, 4,\n",
       "       1, 2, 5, 5, 3, 4, 1, 4, 1, 1, 7, 1, 2, 1, 3, 7, 0, 4, 4, 0, 6, 1,\n",
       "       3, 4, 2, 5, 4, 5, 5, 3, 4, 6, 8, 2])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# objeto poi - obs: o comando np.random.seed(1234) garante que o mesmo resultado será gerado sempre\n",
    "np.random.seed(1234)\n",
    "poi = np.random.poisson(3, 100)\n",
    "poi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "# i) crie o objeto bool_zero através do operador ==\n",
    "\n",
    "bool_zero = []\n",
    "for i in range(len(poi)):\n",
    "    bool_zero = poi == 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False, False, False, False, False, False, False,\n",
       "        True, False, False, False, False, False, False, False, False,\n",
       "        True, False, False, False, False, False,  True, False, False,\n",
       "       False, False, False, False, False, False, False, False, False,\n",
       "       False, False, False, False, False, False, False, False, False,\n",
       "       False, False, False, False, False, False, False, False, False,\n",
       "       False, False,  True, False, False, False, False, False, False,\n",
       "       False, False, False, False, False, False, False, False, False,\n",
       "       False, False, False, False, False, False, False, False, False,\n",
       "       False,  True, False, False,  True, False, False, False, False,\n",
       "       False, False, False, False, False, False, False, False, False,\n",
       "       False])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool_zero"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ii) Conte a quantidade de zeros (ou some os elementos de bool_zero)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "id": "dWElD2MJ695u"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quantidade de zeros no array poi --> 6\n",
      "Quantidade de zeros no array bool_zero --> 6\n"
     ]
    }
   ],
   "source": [
    "#print(poi)\n",
    "#print(bool_zero)\n",
    "\n",
    "print(f\"Quantidade de zeros no array poi --> {np.count_nonzero(poi == 0)}\")\n",
    "print(f\"Quantidade de zeros no array bool_zero --> {np.count_nonzero(bool_zero == 1)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# iii) utilize a indexação booleana para criar uma seleção de não-zeros\n",
    "# dica: inverta o objeto bool_zero"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "id": "hr-knXzs695u"
   },
   "outputs": [],
   "source": [
    "bool_one = []\n",
    "for i in range(len(poi)):\n",
    "    bool_one = poi != 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "id": "5s3DqCup695u"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "       False,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "       False,  True,  True,  True,  True,  True, False,  True,  True,\n",
       "        True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "        True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "        True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "        True,  True, False,  True,  True,  True,  True,  True,  True,\n",
       "        True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "        True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "        True, False,  True,  True, False,  True,  True,  True,  True,\n",
       "        True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "        True])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool_one "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quantidade de zeros no array bool_zero --> 94\n"
     ]
    }
   ],
   "source": [
    "print(f\"Quantidade de zeros no array bool_zero --> {np.count_nonzero(bool_one == 1)}\")"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}