Jupyter e Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introdução à Data Science com Python - Data ICMC-USP\n",
    "\n",
    "Esse material foi desenvolvido pelo Data, grupo de extensão de aprendizado e ciência de dados compostos por alunos do Instituto de Ciências Matemáticas e de Computação da USP.\n",
    "\n",
    "Esse notebook é acompanhado de um curso em video, que pode ser encontrado em [aqui](https://www.youtube.com/playlist?list=PLFE-LjWAAP9SfEuLXf3qrpw4szKWjlYq9)\n",
    "\n",
    "Para saber mais sobre as atividades do Data entre no nosso site e nos siga e nossas redes sociais:\n",
    "- [Site](http://data.icmc.usp.br/)\n",
    "- [Twitter](https://twitter.com/data_icmc)\n",
    "- [LinkedIn](https://www.linkedin.com/school/data-icmc/)\n",
    "- [Facebook](https://www.facebook.com/dataICMC/)\n",
    "\n",
    "Aproveite o material!\n",
    "\n",
    "## Jupyter Notebook e Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Jupyter Notebook\n",
    "\n",
    "Isso daqui é um **Jupyter Notebook** é uma maneira de executar códigos Python (e de algumas outras linguagens) interativamente. Em oposição a um arquivo Python padrão (*.py*), onde o código é executado do começo ao fim, um Jupyter Notebook (*.ipynb*) permite que o programador execute o código em pequenos trechos, observando resultados intermediários.\n",
    "\n",
    "Além disso o notebooks permitem a inclusão de texto, imagens, videos e formulas matemáticas. Sendo assim ainda melhores para utilização em ciência de dados, permitindo explicar linhas de raciocínio e exibir gráficos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python\n",
    "\n",
    "Python é um linguagem de programação de propósito geral criada na década de 1990. A primeira coisa que é possível perceber ao se utilizar Python é que o código é bastante limpo e possui uma boa legibilidade. Para programadores que já possuem familiaridades com linguagens como C/C++ ou Java a adaptação ao Python é bem tranquila, e além disso a linguagem é uma excelente alternativa para começar a aprender programação.\n",
    "\n",
    "É muito importante perceber que esse não é um curso de Python, muito menos de programação. A introdução fornecida nessa aula tem como objetivo apresentar os principais pontos da linguagem, mas é muito recomendado para quem deseja entender de fato o que está acontecendo que estudo Python separadamente também. Nesse curso veremos como aplicar Python no contexto de ciência de dados, então um bom entendimento da linguagem é fundamental.\n",
    "\n",
    "Agora vamos a uma introdução prática ao Python!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Variáveis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Declarando algumas variaveis (isso é um comentário)\n",
    "nome = 'Pedro'\n",
    "idade = 28\n",
    "altura = 1.75\n",
    "solteiro = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Imprimindo o valor dessas variáveis\n",
    "print(nome)\n",
    "print(idade)\n",
    "print(altura)\n",
    "print(solteiro)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Podemos olhar o tipo das variaveis\n",
    "print(type(nome))\n",
    "print(type(idade))\n",
    "print(type(altura))\n",
    "print(type(solteiro))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Operações"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Temos todas as operações aritméticas populares\n",
    "a = idade + 10\n",
    "b = altura - 5\n",
    "c = altura * 2\n",
    "d = idade / 3\n",
    "\n",
    "print(idade)\n",
    "print('Soma 10:', a)\n",
    "print('Subtrai 5:', b)\n",
    "print('Multiplica por 2:', c)\n",
    "print('Divide por 3:', d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Também pode-se destacar operações de módulo (resto da divisão)\n",
    "# e de divisão inteira\n",
    "\n",
    "e = idade % 10 # Modulo\n",
    "f = idade // 3 # Div. inteira\n",
    "\n",
    "print('Modulo 10:', e)\n",
    "print('Divisão inteira por 3:', f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos realizar operações na própria variavel de maneira simplificada"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var = 10\n",
    "print(var)\n",
    "\n",
    "var += 5 # var = var + 5\n",
    "print(var)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Isso não existe em Python\n",
    "var++"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Um conceito diferente é o de operações aritméticas com dados que não são números"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# \"Soma\" de strings funciona como a concatenação\n",
    "'a' + 'b'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Por exemplo:\n",
    "sobrenome = 'Silva'\n",
    "nome_completo = nome + ' ' + sobrenome\n",
    "print(nome_completo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Também podemos fazer \"multiplicação\" com strings\n",
    "'a' * 10 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "É importante perceber que não temos \"subtração\" nem \"divisão\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Listas\n",
    "Muitas vezes estaremos trabalhando com listas de valores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Utilizamos [] para definir listas\n",
    "lucro_por_mes = [100, 110, 200, 140]\n",
    "\n",
    "lucro_por_mes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Com a função len() podemos ver o tamanho da lista\n",
    "len(lucro_por_mes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Podemos inserir elementos em listas com .append()\n",
    "lucro_por_mes.append(90)\n",
    "\n",
    "lucro_por_mes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Também podemos concatenar duas listas\n",
    "lucro_por_mes = lucro_por_mes + [100, 80, 250]\n",
    "\n",
    "lucro_por_mes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma coisa muito importante em listas é acessar seus elementos, o que pode ser feito um a um ou por pedaços da lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# A indexação é feita com [] e começa no indice 0\n",
    "lucro_terceiro_mes = lucro_por_mes[2]\n",
    "\n",
    "lucro_terceiro_mes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Também podemos retornar um intervalo da lista usando :\n",
    "# Só é importante perceber que o intervalo é aberto na direita\n",
    "lucro_terceiro_ao_sexto = lucro_por_mes[2:6]\n",
    "\n",
    "lucro_terceiro_ao_sexto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Indices negativos significam indexar de trás para frente\n",
    "ultimo_lucro = lucro_por_mes[-1]\n",
    "\n",
    "ultimo_lucro"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Listas podem conter qualquer tipo de dados, inclusive misturando tipos diferentes em uma mesma lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Uma lista de strings\n",
    "filmes = ['Star Wars', 'Frances Ha', 'O Rei Leão']\n",
    "print(filmes)\n",
    "\n",
    "# Uma lista misturado vários tipos de dados\n",
    "minha_lista = [3.1415, 'Vinte', 42, True]\n",
    "print(minha_lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos inclusive fazer um lista de listas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Uma lista de listas\n",
    "gastos = [[10, 22, 13], [11, 50], [32, 21, 48]]\n",
    "print(gastos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Para acessar usamos [] duas vezes\n",
    "gastos[1][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tuplas\n",
    "\n",
    "São muito semelhantes a listas, porem são imutáveis. São definidas com `()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Criando uma tupla\n",
    "minha_tupla = (70, 84, 10, 12)\n",
    "\n",
    "print(minha_tupla)\n",
    "print(minha_tupla[2])\n",
    "print(minha_tupla[1:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Não podemos alterar valores\n",
    "minha_tupla[0] = 50"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Estruturas condicionais\n",
    "As estruturas condicionais do Python tem estrutura similar a outras linguagens de programação. O detalhe mais importante é que a definição dos blocos de código é através da identação, enquanto outras linguens usam simbolos como {}."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Definindo uma variavel que vamos usar\n",
    "meu_numero = 42\n",
    "\n",
    "if meu_numero < 50:\n",
    "    print('Menor que 50')\n",
    "else:\n",
    "    print('Maior que 50')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "meu_numero = 50\n",
    "\n",
    "# Assim como em outras linguagens temos elif\n",
    "if meu_numero < 50:\n",
    "    print('Menor que 50')\n",
    "elif meu_numero > 50:\n",
    "    print('Maior que 50')\n",
    "else:\n",
    "    print('Exatamente 50')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Estruturas de repetição\n",
    "Assim com outra linguagens o Python possui as estruturas de repetição `for` e `while`. É importante perceber que o _for_ do Python é um *for each*, conceito presente em outras linguagens de programação. Lembre-se da identação"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Definindo uma lista\n",
    "minha_lista = [3, 5, 7, 4, 9]\n",
    "\n",
    "# Vamos fazer um laço que imprima cada elemento da nossa lista\n",
    "for num in minha_lista:\n",
    "    print(num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Vamos fazer algo mais interessante\n",
    "total = 0\n",
    "for lucro in lucro_por_mes:\n",
    "    total += lucro\n",
    "    \n",
    "num_meses = len(lucro_por_mes)\n",
    "media = total/num_meses\n",
    "media"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em algumas situações queremos um laço que itere por uma variável com valores 0, 1, 2, 3, ... Podemos fazer isso utilizando o método `range()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Perceba que aqui o intervalo da direita também é aberto\n",
    "for i in range(8):\n",
    "    print(i, 2*i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pode começar de um valor diferente de 0\n",
    "for i in range(2, 9):\n",
    "    print(i, 2*i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pode inclusive dar passos diferentes de 1\n",
    "for i in range(2, 9, 2):\n",
    "    print(i, 2*i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dicionários\n",
    "Dicionário é uma estrutura de dados utilizada para armazenar informações do tipo chave-valor. Ele é definido com `{}` e seus elementos são acessados com `[]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Definindo um dicionário vazio\n",
    "idades = {}\n",
    "\n",
    "# Acrescentando dados\n",
    "idades['Maria'] = 23\n",
    "idades['João'] = 34\n",
    "idades['Jose'] = 28\n",
    "\n",
    "# Acessando um elemento através da chave e imprimindo o valor armazenado\n",
    "print(idades['Maria'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Também podemos criar um dicionário já adicionando valores\n",
    "idades = {\n",
    "    'Maria': 23,\n",
    "    'João': 34,\n",
    "    'José': 28,\n",
    "}\n",
    "\n",
    "idades['João']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Algumas funções uteis para manipular dicionarios"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Assim como listas len() retorna o tamanho\n",
    "print(len(idades))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Podemos conferir se um valor com uma certa chave já existe no dicionário\n",
    "print('Maria' in idades)\n",
    "print('Joana' in idades)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Funções\n",
    "Assim como em outras linguagens podemos definir funções em Python, isso é feito através da palavra-chave `def`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Definindo uma função simples\n",
    "def imprime_dobro(num):\n",
    "    print(num * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "imprime_dobro(4)\n",
    "imprime_dobro(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Vamos definir uma função um pouco mais complexa\n",
    "def soma_lista(lista):\n",
    "    total = 0\n",
    "    for num in lista:\n",
    "        total += num\n",
    "    return total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "soma_lista([2, 4, 5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Funções podem retornar mais de um valor\n",
    "def soma_e_multiplica(a, b):\n",
    "    soma = a + b\n",
    "    multi = a * b\n",
    "    \n",
    "    return soma, multi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s, m = soma_e_multiplica(3, 2)\n",
    "print(s, m)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Bibliotecas\n",
    "Bibliotecas são conjuntos de classes e funções que já estam prontas. Existem bibliotecas nativas do Python e bibliotecas de terceiros, com as mais diversas utilidades"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Funções relacionadas a números aleatórios\n",
    "import random\n",
    "\n",
    "# Numero aleatorio no intervalo [10, 20]\n",
    "print(random.randint(10, 20))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Podemos importar apenas as funções que queremos\n",
    "from random import randint\n",
    "\n",
    "print(randint(10, 20))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O conteúdo básico de Python é esse, recomendamos fortemente que você busque outras fontes de estudo de Python para ter maior facilidade em taferas de ciência de dados. O que foi coberto aqui é bem introdutório, então no decorrer das aulas iremos introduzir alguns conceitos novos conforme surgir a necessidade."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}