Aula_1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Aula 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# -*- coding: latin1 -*-\n",
    "# Uma linha quebrada por contra-barra\n",
    "a = 7 * 3 + \\\n",
    "5 / 2\n",
    "# Uma lista (quebrada por vírgula)\n",
    "b = ['a', 'b', 'c',\n",
    "'d', 'e']\n",
    "# Uma chamada de função (quebrada por vírgula)\n",
    "c = range(1,\n",
    "11)\n",
    "# imprime todos na tela\n",
    "print a, b, c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### O erro ocorreu devido à diferença de versões do python. Criamos um código na versão 2 e executamos na versão 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Uma linha quebrada por contra-barra\n",
    "a = 7 * 3 + \\\n",
    "5 / 2\n",
    "# Uma lista (quebrada por vírgula)\n",
    "b = ['a', 'b', 'c',\n",
    "'d', 'e']\n",
    "d = [1,2,3,4,\n",
    "    5,6,7]\n",
    "# Uma chamada de função (quebrada por vírgula)\n",
    "c = range(1,\n",
    "11)\n",
    "# imprime todos na tela\n",
    "print (a, b, c, d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comentários"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# comentário em apenas uma linha\n",
    "# para cada linha preciso adicionar o identificador de comentário\n",
    "\n",
    "\"\"\"\n",
    "Este é um exemplo de bloco de comentário\n",
    "Comentário em mais de uma linha\n",
    "É mais usado para Docstrings: documentação e teste do código em python\n",
    "\n",
    "Para saber mais, acesse: https://www.python.org/dev/peps/pep-0257/\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Endentação"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Para i na lista 234, 654, 378, 798:\n",
    "for i in [234, 654, 378, 798]:\n",
    "# Se o resto da divisão por 3 for igual a zero:\n",
    "    if i % 3 == 0:\n",
    "    # Imprime...\n",
    "        print (i, '/ 3 =', i / 3)\n",
    "    if i % 2 == 0:\n",
    "        print('algma coisa')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Atributos e Métodos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "x = np.arange(10) \n",
    "y = x.sum() #método\n",
    "\n",
    "x.argmax() # atributo - retorna o índice do maior valor no vetor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Controle de Fluxo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "temp = int(input('Entre com a temperatura: '))\n",
    "if temp < 0:\n",
    "    print ('Congelando...')\n",
    "elif (0 <= temp <= 20):\n",
    "    print ('Frio')\n",
    "elif (21 <= temp <= 25):\n",
    "    print ('Normal')\n",
    "elif (26 <= temp <= 35):\n",
    "    print ('Quente')\n",
    "else:\n",
    "    print ('Muito quente!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 'verdadeiro' if 1>0 else 'falso'\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Laços"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# usando for\n",
    "s = 0\n",
    "for x in range(1, 100):\n",
    "    s = s + x\n",
    "print (s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1,2,3,4\n",
    "s = 0,1,3,6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# usando while\n",
    "s = 0\n",
    "x = 1\n",
    "while x < 100:\n",
    "    s = s + x\n",
    "    x = x + 1\n",
    "print (s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Break, Continue e Pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "parada = 10\n",
    "inicio = 0\n",
    "\n",
    "while parada > 0:\n",
    "    print(parada)\n",
    "    parada -= 1\n",
    "    if parada == 3:\n",
    "        break\n",
    "    elif parada ==4:\n",
    "        print('Volta pro inicio')\n",
    "        continue\n",
    "    else:\n",
    "        print('passou')\n",
    "        pass\n",
    "else:\n",
    "    print(\"final\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TODO Section"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "some_list = [1.2345, 2.1234, 4.9876, 5.0912, 3.5687]\n",
    "\n",
    "# TODO: utilizando a mesma variável, ajuste cada número para que este contenha apenas 2 números após a casa decimal\n",
    "# Dica: https://docs.python.org/3/library/functions.html#round"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: O laço a seguir percorre uma lista do número 2 até o número 15. \n",
    "# Toda vez que um número par for encontrado, faça: print (\"Número par encontrado: \", num) e vá para o início do laço\n",
    "# Ao encontrar o número 12, faça: print (\"Número 12 encontrado\"), e encerre o programa\n",
    "\n",
    "for i in range(2,15):"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tipos de Dados"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print ('int(3.14) =', int(3.14)) # real para inteiro\n",
    "print ('float(5) =', float(5)) # inteiro para real\n",
    "print ('5.0 / 2 + 3 = ', 5.0 / 2 + 3) #Divisão que resulta em real\n",
    "print ('5/4 ou 5.0/4.0 = ',5//4) #divisão sem resto\n",
    "c = 4 + 3j #número complexo\n",
    "print ('c =', c)\n",
    "print ('Parte real:', c.real)\n",
    "print ('Parte imaginária:', c.imag)\n",
    "print ('Conjugado:', c.conjugate())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"Camel\"\n",
    "print ('The ' + s + ' run away!')\n",
    "print ('tamanho de %s => %d' % (s, len(s))) # interpolação\n",
    "for ch in s: print (ch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print ('Agora são %02d:%02d.' % (8, 30))\n",
    "print ('Percentagem: %.1f%%, Exponencial:%.2e' % (5.333, 0.00314)) #casa decimal e formatação\n",
    "print ('Decimal: %d, Octal: %o, Hexadecimal: %x' % (10, 10, 10)) #bases numéricas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "musicos = [('Page', 'guitarrista', 'Led Zeppelin'),\n",
    "('Fripp', 'guitarrista', 'King Crimson'),\n",
    "('x','y','z')]\n",
    "\n",
    "msg = '{0} é {1} do {2}'\n",
    "\n",
    "for nome, funcao, banda in musicos:\n",
    "    x = msg.format(nome, funcao, banda)\n",
    "    print(msg.format(nome, funcao, banda))\n",
    "    print(type(x))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Caracteres antecipados por \\ são interpretados como caracteres especiais; \n",
    "# se você quer evitar isso, use raw strings, adicionando um r antes da primeira aspas\n",
    "\n",
    "print ('C:\\some\\name')\n",
    "print (r'C:\\some\\name')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Listas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# listas são objetos heterogêneos, ou seja, \n",
    "# podem contem elementos de qualquer tipo,\n",
    "# inclusive outras listas\n",
    "\n",
    "integer_list = [1, 2, 3]\n",
    "heterogeneous_list = [\"string\", 0.1, True]\n",
    "list_of_lists = [ integer_list, heterogeneous_list, [] ]\n",
    "\n",
    "print(integer_list)\n",
    "print(heterogeneous_list)\n",
    "print(list_of_lists)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bandas = ['Queen','Led Zeppelin','Kansas','Europe','Guns N Roses']\n",
    "\n",
    "for banda in bandas:\n",
    "    print (banda)\n",
    "    \n",
    "bandas.append('Bon Jovi') #adiciona ao fim da lista - inplace\n",
    "bandas.remove('Europe') #remove\n",
    "bandas.sort() #ordena\n",
    "\n",
    "print (bandas)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i, banda in enumerate(bandas): \n",
    "    print (i + 1, '=>', banda)\n",
    "    \n",
    "#filas e pilhas\n",
    "while bandas:\n",
    "    print ('Saiu', bandas.pop(0), ', faltam', len(bandas))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuplas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def soma_e_produto(x, y):\n",
    "    return (x + y),(x * y)\n",
    "sp = soma_e_produto(2, 3) # igual (5, 6)\n",
    "s, p = soma_e_produto(5, 10) # s é 15, p é 50\n",
    "print(sp)\n",
    "print(s)\n",
    "print(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dicionários"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "carros = {'marca':'Ford','modelo':'Mustang','Ano':1964} #cria um dicionário\n",
    "print(carros['modelo']) #imprime o valor da chave 'modelo'\n",
    "print(carros.get('Ano')) #imprime usando método get\n",
    "carros['Ano'] = 2018"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for x,y in carros.items():#imprimindo keys e values\n",
    "    print(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "carros['cor'] = 'preto' #inserindo nova key e value\n",
    "\n",
    "for x,y in carros.items():#repetindo após inserção\n",
    "    print(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del carros['Ano'] #apagando key e value  - \n",
    "#pode ser usado os métodos pop e popitem - testar\n",
    "print (carros) #imprime dicionário"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Apagar dicionário\n",
    "#del carros\n",
    "#print(carros)\n",
    "#esvaziar dicionário\n",
    "carros.clear()\n",
    "print(carros)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#criando a partir de um construtor\n",
    "carros = dict(marca=['Ford','FIAT','Wolksvagem'],modelo=['Mustang','Palio','Gol'],Ano=[1964,2009,1990])\n",
    "print(carros)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DefaultDict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "document = 'A Wikipédia é um projeto de enciclopédia colaborativa, universal e multilíngue estabelecido na internet sob o princípio wiki. \\\n",
    "Tem como propósito fornecer um conteúdo livre, objetivo e verificável, que todos possam editar e melhorar. O projeto é definido pelos \\\n",
    "princípios fundadores. O conteúdo é disponibilizado sob a licença Creative Commons BY-SA e pode ser copiado e reutilizado sob a mesma \\\n",
    "licença — mesmo para fins comerciais — desde que respeitando os termos e condições de uso.'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word_counts = {}\n",
    "for word in document.split(' '):\n",
    "    if word in word_counts:\n",
    "        word_counts[word] += 1\n",
    "    else:\n",
    "        word_counts[word] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word_counts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import defaultdict\n",
    "\n",
    "word_counts = defaultdict(int) # int() produces 0\n",
    "for word in document.split(' '):\n",
    "    word_counts[word] += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word_counts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Counter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter\n",
    "c = Counter([0, 1, 2, 0]) \n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word_counts_counter = Counter(document.split(' '))\n",
    "word_counts_counter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TODO Section"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1)\n",
    "Escreva um programa que vá de 0 até 100. Toda vez que encontrar um número divisível por 5, \n",
    "adicione esse número numa lista. Ao final, ordene a lista de forma descendente"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Resposta 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2)\n",
    "Conte a quantidade de cada caracter presente no texto abaixo:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Texto\n",
    "\n",
    "Brasil, oficialmente República Federativa do Brasil é o maior país da América do Sul e da região da América Latina, sendo o quinto maior do mundo em área territorial (equivalente a 47 porcento do território sul-americano) e sexto em população (com mais de 200 milhões de habitantes). É o único país na América onde se fala majoritariamente a língua portuguesa e o maior país lusófono do planeta, além de ser uma das nações mais multiculturais e etnicamente diversas, em decorrência da forte imigração oriunda de variados locais do mundo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Resposta 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3)\n",
    "Solicite ao usuário uma string e um número inteiro. Armaze ambos em variáveis. Remova da string os caracteres de 0 até n e imprima a string resultante"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Resposta 3"
   ]
  }
 ],
 "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.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}