├── .gitignore
├── JupyterNotebooks
    ├── Capítulo01
    │   ├── DSA-Python-Capítulo1-Como utilizar o Jupyter Notebook.ipynb
    │   ├── Instalando Anaconda Python no Linux Ubuntu 16.04 LTS.pdf
    │   ├── Instalando Anaconda Python no Mac.pdf
    │   ├── Instalando Anaconda Python no Windows.pdf
    │   └── Jupyter Notebook-Manual de Usuário.ipynb
    ├── Capítulo02
    │   ├── DSA-Python-Capítulo2-Arquivos.ipynb
    │   ├── DSA-Python-Capítulo2-Dicionários.ipynb
    │   ├── DSA-Python-Capítulo2-Exercícios-Solução.ipynb
    │   ├── DSA-Python-Capítulo2-Exercícios.ipynb
    │   ├── DSA-Python-Capítulo2-Listas.ipynb
    │   ├── DSA-Python-Capítulo2-Números.ipynb
    │   ├── DSA-Python-Capítulo2-Strings.ipynb
    │   ├── DSA-Python-Capítulo2-Tuplas.ipynb
    │   ├── DSA-Python-Capítulo2-Variáveis.ipynb
    │   ├── arquivo-dsc.txt
    │   ├── nomes.txt
    │   └── salarios.csv
    ├── Capítulo03
    │   ├── DSA-Python-Capítulo3-Exercícios-Solução.ipynb
    │   ├── DSA-Python-Capítulo3-Exercícios.ipynb
    │   ├── DSA-Python-Capítulo3-For.ipynb
    │   ├── DSA-Python-Capítulo3-If-Elif-Else.ipynb
    │   ├── DSA-Python-Capítulo3-Range.ipynb
    │   └── DSA-Python-Capítulo3-While.ipynb
    ├── Capítulo04
    │   ├── DSA-Python-Capítulo4-Exercícios-Solução.ipynb
    │   ├── DSA-Python-Capítulo4-Exercícios.ipynb
    │   ├── DSA-Python-Capítulo4-Funções.ipynb
    │   ├── DSA-Python-Capítulo4-Lambda.ipynb
    │   └── DSA-Python-Capítulo4-Métodos.ipynb
    ├── Capítulo05
    │   ├── DSA-Python-Capítulo5-Classes.ipynb
    │   ├── DSA-Python-Capítulo5-Exercícios-Solução.ipynb
    │   ├── DSA-Python-Capítulo5-Exercícios.ipynb
    │   ├── DSA-Python-Capítulo5-Herança.ipynb
    │   ├── DSA-Python-Capítulo5-MetodosEspeciais.ipynb
    │   ├── DSA-Python-Capítulo5-Métodos.ipynb
    │   └── DSA-Python-Capítulo5-Objetos.ipynb
    ├── Capítulo06
    │   ├── Jupyter Notebook Parte1 - Criando um Banco de Dados SQLite.ipynb
    │   ├── Jupyter Notebook Parte2 - Instrução Insert no SQLite.ipynb
    │   ├── Jupyter Notebook Parte3 - Instrução Insert no SQLite usando Variáveis.ipynb
    │   ├── Jupyter Notebook Parte4 - Instrução Select no SQLite.ipynb
    │   ├── Jupyter Notebook Parte5 - Instruções Update e Delete no SQLite.ipynb
    │   ├── Jupyter Notebook Parte6 - Criando Gráficos com Matplotlib e SQLite.ipynb
    │   ├── Jupyter Notebook Parte7 - Criando um Banco de Dados no MongoDB.ipynb
    │   ├── Jupyter Notebook Parte8 - Retornando Dados do MongoDB.ipynb
    │   ├── Jupyter Notebook Parte9 - Stream de Dados do Twitter com MongoDB, Pandas e Scikit Learn.ipynb
    │   ├── dsa.db
    │   └── escola.db
    ├── Capítulo07
    │   ├── DSA-Python-Capítulo7-Datetime.ipynb
    │   ├── DSA-Python-Capítulo7-Enumerate.ipynb
    │   ├── DSA-Python-Capítulo7-Erros-e-Exceções.ipynb
    │   ├── DSA-Python-Capítulo7-Filter.ipynb
    │   ├── DSA-Python-Capítulo7-List Comprehensions.ipynb
    │   ├── DSA-Python-Capítulo7-Manipulação de Arquivos.ipynb
    │   ├── DSA-Python-Capítulo7-Map.ipynb
    │   ├── DSA-Python-Capítulo7-Módulos e Pacotes.ipynb
    │   ├── DSA-Python-Capítulo7-Python-Debugger.ipynb
    │   ├── DSA-Python-Capítulo7-Python-Expressões-Regulares.ipynb
    │   ├── DSA-Python-Capítulo7-Reduce.ipynb
    │   ├── DSA-Python-Capítulo7-Zip.ipynb
    │   ├── cientista.txt
    │   ├── dados.json
    │   ├── json_data.txt
    │   ├── logfile.txt
    │   ├── numeros.csv
    │   ├── reduce.png
    │   ├── testandoerros.txt
    │   └── testfile.txt
    ├── Capítulo08
    │   ├── Bokeh-Chart-Interativo.html
    │   ├── Bokeh-Datetime.html
    │   ├── Bokeh-GeoJSON.html
    │   ├── Bokeh-Grafico-Interativo.html
    │   ├── Bokeh-Grafico-Linha.html
    │   ├── Bokeh-ViolinPlot.html
    │   ├── DSA-Python-Capítulo8-Bokeh.ipynb
    │   ├── DSA-Python-Capítulo8-Matplotlib-Mapas.ipynb
    │   ├── DSA-Python-Capítulo8-Matplotlib-Plots-e-Graficos.ipynb
    │   ├── DSA-Python-Capítulo8-NumPy.ipynb
    │   ├── DSA-Python-Capítulo8-Pandas.ipynb
    │   ├── DSA-Python-Capítulo8-SciPy.ipynb
    │   ├── DSA-Python-Capítulo8-Scikit-Learn.ipynb
    │   ├── DSA-Python-Capítulo8-Seaborn.ipynb
    │   ├── DSA-Python-Capítulo8-StatsModels.ipynb
    │   ├── Matplotlib-Continentes.png
    │   ├── Matplotlib-Dia-Noite.png
    │   ├── Matplotlib-Globo-expandido.png
    │   ├── Matplotlib-Globo.png
    │   ├── Matplotlib-Mapa.png
    │   ├── ScrapyProject
    │   │   ├── Scrapy
    │   │   │   ├── Scraping.png
    │   │   │   └── Scrapy.png
    │   │   ├── items.json
    │   │   ├── scrapy.cfg
    │   │   └── stack
    │   │   │   ├── __init__.py
    │   │   │   ├── __pycache__
    │   │   │       ├── __init__.cpython-35.pyc
    │   │   │       ├── items.cpython-35.pyc
    │   │   │       ├── pipelines.cpython-35.pyc
    │   │   │       └── settings.cpython-35.pyc
    │   │   │   ├── items.py
    │   │   │   ├── pipelines.py
    │   │   │   ├── settings.py
    │   │   │   └── spiders
    │   │   │       ├── __init__.py
    │   │   │       ├── __pycache__
    │   │   │           ├── __init__.cpython-35.pyc
    │   │   │           └── stack_spider.cpython-35.pyc
    │   │   │       └── stack_spider.py
    │   ├── gmap_plot.html
    │   ├── iris.csv
    │   ├── linear.png
    │   ├── ml_map.png
    │   ├── salarios.csv
    │   └── texas.html
    ├── Capítulo09
    │   ├── DSA-Python-Capitulo9-Reconhecimento-de-Imagens.ipynb
    │   ├── DSA-Python-Capitulo9-Reconhecimento-de-Imagens.pdf
    │   ├── DSA-Python-Capítulo9-Análise-Exploratória-de-Dados.ipynb
    │   ├── DSA-Python-Capítulo9-Python-e-R.ipynb
    │   ├── Dados-Pesquisa-2016.csv.zip
    │   ├── previsoes.csv
    │   ├── test.zip
    │   └── train.zip
    └── Capítulo10
    │   ├── ConfusionMatrix.jpg
    │   ├── DSA-Python-Capítulo10-Machine-Learning.ipynb
    │   ├── Treinamento.png
    │   ├── Workflow.png
    │   └── pima-data.csv
├── LICENSE
└── README.md


/.gitignore:
--------------------------------------------------------------------------------
1 | # Google App Engine generated folder
2 | appengine-generated/
3 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo01/DSA-Python-Capítulo1-Como utilizar o Jupyter Notebook.ipynb:
--------------------------------------------------------------------------------
 1 | {
 2 |  "cells": [
 3 |   {
 4 |    "cell_type": "markdown",
 5 |    "metadata": {},
 6 |    "source": [
 7 |     "# <font color='blue'>Data Science Academy - Python Fundamentos</font>\n",
 8 |     "# <font color='blue'>Capítulo 1</font>\n"
 9 |    ]
10 |   },
11 |   {
12 |    "cell_type": "markdown",
13 |    "metadata": {},
14 |    "source": [
15 |     "## Como utilizar o Jupyer Notebook"
16 |    ]
17 |   },
18 |   {
19 |    "cell_type": "code",
20 |    "execution_count": 2,
21 |    "metadata": {
22 |     "collapsed": false
23 |    },
24 |    "outputs": [
25 |     {
26 |      "data": {
27 |       "text/html": [
28 |        "<iframe id=\"ytplayer\" type=\"text/html\" width=\"1000\" height=\"500\" src=\"https://www.youtube.com/embed/JF5hQ9M2YEY\" frameborder=\"2\"/>"
29 |       ],
30 |       "text/plain": [
31 |        "<IPython.core.display.HTML object>"
32 |       ]
33 |      },
34 |      "execution_count": 2,
35 |      "metadata": {},
36 |      "output_type": "execute_result"
37 |     }
38 |    ],
39 |    "source": [
40 |     "# Pressione as teclas shift e enter para executar esse código e assista o vídeo com as instruções.\n",
41 |     "\n",
42 |     "from IPython.core.display import HTML\n",
43 |     "HTML('<iframe id=\"ytplayer\" type=\"text/html\" width=\"1000\" height=\"500\" src=\"https://www.youtube.com/embed/JF5hQ9M2YEY\" frameborder=\"2\"/>')"
44 |    ]
45 |   },
46 |   {
47 |    "cell_type": "markdown",
48 |    "metadata": {},
49 |    "source": [
50 |     "# Fim"
51 |    ]
52 |   },
53 |   {
54 |    "cell_type": "markdown",
55 |    "metadata": {},
56 |    "source": [
57 |     "### Obrigado - Data Science Academy - <a href=http://facebook.com/dsacademy>facebook.com/dsacademybr</a>"
58 |    ]
59 |   }
60 |  ],
61 |  "metadata": {
62 |   "anaconda-cloud": {},
63 |   "kernelspec": {
64 |    "display_name": "Python [Root]",
65 |    "language": "python",
66 |    "name": "Python [Root]"
67 |   },
68 |   "language_info": {
69 |    "codemirror_mode": {
70 |     "name": "ipython",
71 |     "version": 3
72 |    },
73 |    "file_extension": ".py",
74 |    "mimetype": "text/x-python",
75 |    "name": "python",
76 |    "nbconvert_exporter": "python",
77 |    "pygments_lexer": "ipython3",
78 |    "version": "3.5.2"
79 |   }
80 |  },
81 |  "nbformat": 4,
82 |  "nbformat_minor": 0
83 | }
84 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo01/Instalando Anaconda Python no Linux Ubuntu 16.04 LTS.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mlhoffmann/PythonFundamentos/780daf19c7063edfef1fb4f045f0b104c91cfd9a/JupyterNotebooks/Capítulo01/Instalando Anaconda Python no Linux Ubuntu 16.04 LTS.pdf


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo01/Instalando Anaconda Python no Mac.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mlhoffmann/PythonFundamentos/780daf19c7063edfef1fb4f045f0b104c91cfd9a/JupyterNotebooks/Capítulo01/Instalando Anaconda Python no Mac.pdf


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo01/Instalando Anaconda Python no Windows.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mlhoffmann/PythonFundamentos/780daf19c7063edfef1fb4f045f0b104c91cfd9a/JupyterNotebooks/Capítulo01/Instalando Anaconda Python no Windows.pdf


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo02/DSA-Python-Capítulo2-Exercícios-Solução.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# <font color='blue'>Data Science Academy - Python Fundamentos - Capítulo 2</font>\n",
  8 |     "\n",
  9 |     "## Download: http://github.com/dsacademybr"
 10 |    ]
 11 |   },
 12 |   {
 13 |    "cell_type": "markdown",
 14 |    "metadata": {},
 15 |    "source": [
 16 |     "## Exercícios"
 17 |    ]
 18 |   },
 19 |   {
 20 |    "cell_type": "code",
 21 |    "execution_count": 1,
 22 |    "metadata": {
 23 |     "collapsed": false
 24 |    },
 25 |    "outputs": [
 26 |     {
 27 |      "name": "stdout",
 28 |      "output_type": "stream",
 29 |      "text": [
 30 |       "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n"
 31 |      ]
 32 |     }
 33 |    ],
 34 |    "source": [
 35 |     "# Exercício 1 - Imprima na tela os números de 1 a 10\n",
 36 |     "lista = [1,2,3,4,5,6,7,8,9,10]\n",
 37 |     "print(lista)"
 38 |    ]
 39 |   },
 40 |   {
 41 |    "cell_type": "code",
 42 |    "execution_count": 2,
 43 |    "metadata": {
 44 |     "collapsed": false
 45 |    },
 46 |    "outputs": [
 47 |     {
 48 |      "name": "stdout",
 49 |      "output_type": "stream",
 50 |      "text": [
 51 |       "['chocolate', 'maça', 'abacaxi', 'uva', 'morango']\n"
 52 |      ]
 53 |     }
 54 |    ],
 55 |    "source": [
 56 |     "# Exercício 2 - Crie uma lista de 5 objetos e imprima na tela\n",
 57 |     "lista = ['chocolate', 'maça', 'abacaxi', 'uva', 'morango']\n",
 58 |     "print(lista)"
 59 |    ]
 60 |   },
 61 |   {
 62 |    "cell_type": "code",
 63 |    "execution_count": 3,
 64 |    "metadata": {
 65 |     "collapsed": false
 66 |    },
 67 |    "outputs": [
 68 |     {
 69 |      "name": "stdout",
 70 |      "output_type": "stream",
 71 |      "text": [
 72 |       "Se beber não dirija!\n"
 73 |      ]
 74 |     }
 75 |    ],
 76 |    "source": [
 77 |     "# Exercício 3 - Crie duas strings e concatene as duas em uma terceira string\n",
 78 |     "frase1 = 'Se beber '\n",
 79 |     "frase2 = 'não dirija!'\n",
 80 |     "frase_final = frase1 + frase2\n",
 81 |     "print(frase_final)"
 82 |    ]
 83 |   },
 84 |   {
 85 |    "cell_type": "code",
 86 |    "execution_count": 4,
 87 |    "metadata": {
 88 |     "collapsed": false
 89 |    },
 90 |    "outputs": [
 91 |     {
 92 |      "data": {
 93 |       "text/plain": [
 94 |        "3"
 95 |       ]
 96 |      },
 97 |      "execution_count": 4,
 98 |      "metadata": {},
 99 |      "output_type": "execute_result"
100 |     }
101 |    ],
102 |    "source": [
103 |     "# Exercício 4 - Crie uma tupla com os seguintes elementos: 1, 2, 2, 3, 4, 4, 4, 5 e depois utilize a função count do \n",
104 |     "# objeto tupla para verificar quantas vezes o número 4 aparece na tupla\n",
105 |     "tup1 = (1, 2, 2, 3, 4, 4, 4, 5)\n",
106 |     "tup1.count(4)"
107 |    ]
108 |   },
109 |   {
110 |    "cell_type": "code",
111 |    "execution_count": 5,
112 |    "metadata": {
113 |     "collapsed": false
114 |    },
115 |    "outputs": [
116 |     {
117 |      "name": "stdout",
118 |      "output_type": "stream",
119 |      "text": [
120 |       "{'k2': 'serrote', 'k1': 'martelo', 'k3': 'machado'}\n"
121 |      ]
122 |     }
123 |    ],
124 |    "source": [
125 |     "# Exercício 5 - Crie um dicionário com 3 chaves e 3 valores e imprima na tela\n",
126 |     "dict = {'k1':'martelo', 'k2':'serrote', 'k3':'machado'}\n",
127 |     "print(dict)"
128 |    ]
129 |   },
130 |   {
131 |    "cell_type": "code",
132 |    "execution_count": 6,
133 |    "metadata": {
134 |     "collapsed": false
135 |    },
136 |    "outputs": [
137 |     {
138 |      "name": "stdout",
139 |      "output_type": "stream",
140 |      "text": [
141 |       "{'k2': 'serrote', 'k1': 'martelo', 'k4': 'parafuso', 'k3': 'machado'}\n"
142 |      ]
143 |     }
144 |    ],
145 |    "source": [
146 |     "# Exercício 6 - Adicione mais uma ferramenta ao dicionário criado no exercício anterior e imprima na tela\n",
147 |     "dict['k4'] = 'parafuso'\n",
148 |     "print(dict)"
149 |    ]
150 |   },
151 |   {
152 |    "cell_type": "code",
153 |    "execution_count": 7,
154 |    "metadata": {
155 |     "collapsed": false
156 |    },
157 |    "outputs": [],
158 |    "source": [
159 |     "# Exercício 7 - Crie um arquivo chamado nomes.txt no diretório onde está este notebook, grave 5 nomes no arquivo e \n",
160 |     "# feche-o.\n",
161 |     "arq1 = open(\"nomes.txt\", \"w\")\n",
162 |     "arq1.write('Brian, Peter, John, Eric, Bernard')\n",
163 |     "arq1.close()"
164 |    ]
165 |   },
166 |   {
167 |    "cell_type": "code",
168 |    "execution_count": 8,
169 |    "metadata": {
170 |     "collapsed": false
171 |    },
172 |    "outputs": [
173 |     {
174 |      "data": {
175 |       "text/plain": [
176 |        "'Brian, Peter, John, Eric, Bernard'"
177 |       ]
178 |      },
179 |      "execution_count": 8,
180 |      "metadata": {},
181 |      "output_type": "execute_result"
182 |     }
183 |    ],
184 |    "source": [
185 |     "# Exercício 8 - Abra o arquivo criado no item anterior e leia o arquivo na tela.\n",
186 |     "arq1 = open(\"nomes.txt\", \"r\")\n",
187 |     "arq1.read()"
188 |    ]
189 |   },
190 |   {
191 |    "cell_type": "code",
192 |    "execution_count": 9,
193 |    "metadata": {
194 |     "collapsed": false
195 |    },
196 |    "outputs": [
197 |     {
198 |      "name": "stdout",
199 |      "output_type": "stream",
200 |      "text": [
201 |       "{}\n"
202 |      ]
203 |     }
204 |    ],
205 |    "source": [
206 |     "# Exercício 9 - Crie um dicionário vazio e imrpima na tela\n",
207 |     "dict2 = {}\n",
208 |     "print(dict2)"
209 |    ]
210 |   },
211 |   {
212 |    "cell_type": "code",
213 |    "execution_count": 10,
214 |    "metadata": {
215 |     "collapsed": false
216 |    },
217 |    "outputs": [
218 |     {
219 |      "data": {
220 |       "text/html": [
221 |        "<div>\n",
222 |        "<table border=\"1\" class=\"dataframe\">\n",
223 |        "  <thead>\n",
224 |        "    <tr style=\"text-align: right;\">\n",
225 |        "      <th></th>\n",
226 |        "      <th>admit</th>\n",
227 |        "      <th>gre</th>\n",
228 |        "      <th>gpa</th>\n",
229 |        "      <th>rank</th>\n",
230 |        "    </tr>\n",
231 |        "  </thead>\n",
232 |        "  <tbody>\n",
233 |        "    <tr>\n",
234 |        "      <th>395</th>\n",
235 |        "      <td>0</td>\n",
236 |        "      <td>620</td>\n",
237 |        "      <td>4.00</td>\n",
238 |        "      <td>2</td>\n",
239 |        "    </tr>\n",
240 |        "    <tr>\n",
241 |        "      <th>396</th>\n",
242 |        "      <td>0</td>\n",
243 |        "      <td>560</td>\n",
244 |        "      <td>3.04</td>\n",
245 |        "      <td>3</td>\n",
246 |        "    </tr>\n",
247 |        "    <tr>\n",
248 |        "      <th>397</th>\n",
249 |        "      <td>0</td>\n",
250 |        "      <td>460</td>\n",
251 |        "      <td>2.63</td>\n",
252 |        "      <td>2</td>\n",
253 |        "    </tr>\n",
254 |        "    <tr>\n",
255 |        "      <th>398</th>\n",
256 |        "      <td>0</td>\n",
257 |        "      <td>700</td>\n",
258 |        "      <td>3.65</td>\n",
259 |        "      <td>2</td>\n",
260 |        "    </tr>\n",
261 |        "    <tr>\n",
262 |        "      <th>399</th>\n",
263 |        "      <td>0</td>\n",
264 |        "      <td>600</td>\n",
265 |        "      <td>3.89</td>\n",
266 |        "      <td>3</td>\n",
267 |        "    </tr>\n",
268 |        "  </tbody>\n",
269 |        "</table>\n",
270 |        "</div>"
271 |       ],
272 |       "text/plain": [
273 |        "     admit  gre   gpa  rank\n",
274 |        "395      0  620  4.00     2\n",
275 |        "396      0  560  3.04     3\n",
276 |        "397      0  460  2.63     2\n",
277 |        "398      0  700  3.65     2\n",
278 |        "399      0  600  3.89     3"
279 |       ]
280 |      },
281 |      "execution_count": 10,
282 |      "metadata": {},
283 |      "output_type": "execute_result"
284 |     }
285 |    ],
286 |    "source": [
287 |     "# Exercício 10 - Complelete o trecho de código abaixo criado com Pandas e use a função tail() para ler os últimos \n",
288 |     "# elementos do dataset.\n",
289 |     "import pandas as pd\n",
290 |     "file_name = \"http://www.ats.ucla.edu/stat/data/binary.csv\"\n",
291 |     "df = pd.read_csv(file_name)\n",
292 |     "df.tail()"
293 |    ]
294 |   },
295 |   {
296 |    "cell_type": "markdown",
297 |    "metadata": {},
298 |    "source": [
299 |     "# Fim"
300 |    ]
301 |   },
302 |   {
303 |    "cell_type": "markdown",
304 |    "metadata": {},
305 |    "source": [
306 |     "### Obrigado - Data Science Academy - <a href=http://facebook.com/dsacademy>facebook.com/dsacademybr</a>"
307 |    ]
308 |   }
309 |  ],
310 |  "metadata": {
311 |   "kernelspec": {
312 |    "display_name": "Python 3",
313 |    "language": "python",
314 |    "name": "python3"
315 |   },
316 |   "language_info": {
317 |    "codemirror_mode": {
318 |     "name": "ipython",
319 |     "version": 3
320 |    },
321 |    "file_extension": ".py",
322 |    "mimetype": "text/x-python",
323 |    "name": "python",
324 |    "nbconvert_exporter": "python",
325 |    "pygments_lexer": "ipython3",
326 |    "version": "3.5.1"
327 |   }
328 |  },
329 |  "nbformat": 4,
330 |  "nbformat_minor": 0
331 | }
332 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo02/DSA-Python-Capítulo2-Exercícios.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# <font color='blue'>Data Science Academy - Python Fundamentos - Capítulo 2</font>\n",
  8 |     "\n",
  9 |     "## Download: http://github.com/dsacademybr"
 10 |    ]
 11 |   },
 12 |   {
 13 |    "cell_type": "markdown",
 14 |    "metadata": {},
 15 |    "source": [
 16 |     "## Exercícios"
 17 |    ]
 18 |   },
 19 |   {
 20 |    "cell_type": "code",
 21 |    "execution_count": null,
 22 |    "metadata": {
 23 |     "collapsed": false
 24 |    },
 25 |    "outputs": [],
 26 |    "source": [
 27 |     "# Exercício 1 - Imprima na tela os números de 1 a 10\n"
 28 |    ]
 29 |   },
 30 |   {
 31 |    "cell_type": "code",
 32 |    "execution_count": null,
 33 |    "metadata": {
 34 |     "collapsed": false
 35 |    },
 36 |    "outputs": [],
 37 |    "source": [
 38 |     "# Exercício 2 - Crie uma lista de 5 objetos e imprima na tela\n"
 39 |    ]
 40 |   },
 41 |   {
 42 |    "cell_type": "code",
 43 |    "execution_count": null,
 44 |    "metadata": {
 45 |     "collapsed": false
 46 |    },
 47 |    "outputs": [],
 48 |    "source": [
 49 |     "# Exercício 3 - Crie duas strings e concatene as duas em uma terceira string\n"
 50 |    ]
 51 |   },
 52 |   {
 53 |    "cell_type": "code",
 54 |    "execution_count": null,
 55 |    "metadata": {
 56 |     "collapsed": false
 57 |    },
 58 |    "outputs": [],
 59 |    "source": [
 60 |     "# Exercício 4 - Crie uma tupla com os seguintes elementos: 1, 2, 2, 3, 4, 4, 4, 5 e depois utilize a função count do \n",
 61 |     "# objeto tupla para verificar quantas vezes o número 4 aparece na tupla\n"
 62 |    ]
 63 |   },
 64 |   {
 65 |    "cell_type": "code",
 66 |    "execution_count": null,
 67 |    "metadata": {
 68 |     "collapsed": false
 69 |    },
 70 |    "outputs": [],
 71 |    "source": [
 72 |     "# Exercício 5 - Crie um dicionário com 3 chaves e 3 valores e imprima na tela\n"
 73 |    ]
 74 |   },
 75 |   {
 76 |    "cell_type": "code",
 77 |    "execution_count": null,
 78 |    "metadata": {
 79 |     "collapsed": false
 80 |    },
 81 |    "outputs": [],
 82 |    "source": [
 83 |     "# Exercício 6 - Adicione mais uma ferramenta ao dicionário criado no exercício anterior e imprima na tela\n"
 84 |    ]
 85 |   },
 86 |   {
 87 |    "cell_type": "code",
 88 |    "execution_count": null,
 89 |    "metadata": {
 90 |     "collapsed": false
 91 |    },
 92 |    "outputs": [],
 93 |    "source": [
 94 |     "# Exercício 7 - Crie um arquivo chamado nomes.txt no diretório onde está este notebook, grave 5 nomes no arquivo e \n",
 95 |     "# feche-o.\n"
 96 |    ]
 97 |   },
 98 |   {
 99 |    "cell_type": "code",
100 |    "execution_count": null,
101 |    "metadata": {
102 |     "collapsed": false
103 |    },
104 |    "outputs": [],
105 |    "source": [
106 |     "# Exercício 8 - Abra o arquivo criado no item anterior e leia o arquivo na tela.\n"
107 |    ]
108 |   },
109 |   {
110 |    "cell_type": "code",
111 |    "execution_count": null,
112 |    "metadata": {
113 |     "collapsed": false
114 |    },
115 |    "outputs": [],
116 |    "source": [
117 |     "# Exercício 9 - Crie um dicionário vazio e imrpima na tela\n"
118 |    ]
119 |   },
120 |   {
121 |    "cell_type": "code",
122 |    "execution_count": null,
123 |    "metadata": {
124 |     "collapsed": false
125 |    },
126 |    "outputs": [],
127 |    "source": [
128 |     "# Exercício 10 - Complelete o trecho de código abaixo criado com Pandas e use a função tail() para ler os últimos \n",
129 |     "# elementos do dataset.\n",
130 |     "import pandas as pd\n",
131 |     "file_name = \"http://www.ats.ucla.edu/stat/data/binary.csv\"\n",
132 |     "df = pd.read_csv(file_name)"
133 |    ]
134 |   },
135 |   {
136 |    "cell_type": "markdown",
137 |    "metadata": {},
138 |    "source": [
139 |     "# Fim"
140 |    ]
141 |   },
142 |   {
143 |    "cell_type": "markdown",
144 |    "metadata": {},
145 |    "source": [
146 |     "### Obrigado - Data Science Academy - <a href=http://facebook.com/dsacademy>facebook.com/dsacademybr</a>"
147 |    ]
148 |   }
149 |  ],
150 |  "metadata": {
151 |   "kernelspec": {
152 |    "display_name": "Python 3",
153 |    "language": "python",
154 |    "name": "python3"
155 |   },
156 |   "language_info": {
157 |    "codemirror_mode": {
158 |     "name": "ipython",
159 |     "version": 3
160 |    },
161 |    "file_extension": ".py",
162 |    "mimetype": "text/x-python",
163 |    "name": "python",
164 |    "nbconvert_exporter": "python",
165 |    "pygments_lexer": "ipython3",
166 |    "version": "3.5.1"
167 |   }
168 |  },
169 |  "nbformat": 4,
170 |  "nbformat_minor": 0
171 | }
172 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo02/arquivo-dsc.txt:
--------------------------------------------------------------------------------
1 | Testando gravação de arquivos em Python Acrescentando conteúdo


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo02/nomes.txt:
--------------------------------------------------------------------------------
1 | Brian, Peter, John, Eric, Bernard


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo03/DSA-Python-Capítulo3-Exercícios-Solução.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# <font color='blue'>Data Science Academy - Python Fundamentos - Capítulo 3</font>\n",
  8 |     "\n",
  9 |     "## Download: http://github.com/dsacademybr"
 10 |    ]
 11 |   },
 12 |   {
 13 |    "cell_type": "markdown",
 14 |    "metadata": {},
 15 |    "source": [
 16 |     "## Exercícios"
 17 |    ]
 18 |   },
 19 |   {
 20 |    "cell_type": "code",
 21 |    "execution_count": 1,
 22 |    "metadata": {
 23 |     "collapsed": false
 24 |    },
 25 |    "outputs": [
 26 |     {
 27 |      "name": "stdout",
 28 |      "output_type": "stream",
 29 |      "text": [
 30 |       "Digite o dia da semana: Sábado\n",
 31 |       "Hoje é dia de descanso\n"
 32 |      ]
 33 |     }
 34 |    ],
 35 |    "source": [
 36 |     "# Exercício 1 - Crie uma estrutura que pergunte ao usuário qual o dia da semana. Se o dia for igual a Domingo ou \n",
 37 |     "# igual a sábado, imprima na tela \"Hoje é dia de descanso\", caso contrário imprima na tela \"Você precisa trabalhar!\"\n",
 38 |     "dia = input('Digite o dia da semana: ')\n",
 39 |     "if dia == 'Domingo' or dia == 'Sábado':\n",
 40 |     "    print(\"Hoje é dia de descanso\")\n",
 41 |     "else:\n",
 42 |     "    print(\"Você precisa trabalhar!\")"
 43 |    ]
 44 |   },
 45 |   {
 46 |    "cell_type": "code",
 47 |    "execution_count": 2,
 48 |    "metadata": {
 49 |     "collapsed": false
 50 |    },
 51 |    "outputs": [
 52 |     {
 53 |      "name": "stdout",
 54 |      "output_type": "stream",
 55 |      "text": [
 56 |       "Morango faz parte da lista de frutas\n"
 57 |      ]
 58 |     }
 59 |    ],
 60 |    "source": [
 61 |     "# Exercício 2 - Crie uma lista de 5 frutas e verifique se a fruta 'Morango' faz parte da lista\n",
 62 |     "lista = ['Laranja', 'Maça', 'Abacaxi', 'Uva', 'Morango']\n",
 63 |     "for fruta in lista:\n",
 64 |     "    if fruta == 'Morango':\n",
 65 |     "        print(\"Morango faz parte da lista de frutas\")"
 66 |    ]
 67 |   },
 68 |   {
 69 |    "cell_type": "code",
 70 |    "execution_count": 3,
 71 |    "metadata": {
 72 |     "collapsed": false
 73 |    },
 74 |    "outputs": [
 75 |     {
 76 |      "name": "stdout",
 77 |      "output_type": "stream",
 78 |      "text": [
 79 |       "[2, 4, 6, 8]\n"
 80 |      ]
 81 |     }
 82 |    ],
 83 |    "source": [
 84 |     "# Exercício 3 - Crie uma tupla de 4 elementos, multiplique cada elemento da tupla por 2 e guarde os resultados em uma \n",
 85 |     "# lista\n",
 86 |     "tup1 = (1, 2, 3, 4)\n",
 87 |     "lst1 = []\n",
 88 |     "for i in tup1:\n",
 89 |     "    novo_valor = i * 2\n",
 90 |     "    lst1.append(novo_valor)\n",
 91 |     "print(lst1)"
 92 |    ]
 93 |   },
 94 |   {
 95 |    "cell_type": "code",
 96 |    "execution_count": 4,
 97 |    "metadata": {
 98 |     "collapsed": false
 99 |    },
100 |    "outputs": [
101 |     {
102 |      "name": "stdout",
103 |      "output_type": "stream",
104 |      "text": [
105 |       "100\n",
106 |       "102\n",
107 |       "104\n",
108 |       "106\n",
109 |       "108\n",
110 |       "110\n",
111 |       "112\n",
112 |       "114\n",
113 |       "116\n",
114 |       "118\n",
115 |       "120\n",
116 |       "122\n",
117 |       "124\n",
118 |       "126\n",
119 |       "128\n",
120 |       "130\n",
121 |       "132\n",
122 |       "134\n",
123 |       "136\n",
124 |       "138\n",
125 |       "140\n",
126 |       "142\n",
127 |       "144\n",
128 |       "146\n",
129 |       "148\n",
130 |       "150\n"
131 |      ]
132 |     }
133 |    ],
134 |    "source": [
135 |     "# Exercício 4 - Crie uma sequência de números pares entre 100 e 150 e imprima na tela\n",
136 |     "for i in range(100, 151, 2):\n",
137 |     "    print(i)"
138 |    ]
139 |   },
140 |   {
141 |    "cell_type": "code",
142 |    "execution_count": 5,
143 |    "metadata": {
144 |     "collapsed": false
145 |    },
146 |    "outputs": [
147 |     {
148 |      "name": "stdout",
149 |      "output_type": "stream",
150 |      "text": [
151 |       "40\n",
152 |       "39\n",
153 |       "38\n",
154 |       "37\n",
155 |       "36\n"
156 |      ]
157 |     }
158 |    ],
159 |    "source": [
160 |     "# Exercício 5 - Crie uma variável chamada temperatura e atribua o valor 40. Enquanto temperatura for maior que 35, \n",
161 |     "# imprima as temperaturas na tela\n",
162 |     "temperatura = 40  \n",
163 |     "while temperatura > 35: \n",
164 |     "    print(temperatura)\n",
165 |     "    temperatura = temperatura - 1"
166 |    ]
167 |   },
168 |   {
169 |    "cell_type": "code",
170 |    "execution_count": 6,
171 |    "metadata": {
172 |     "collapsed": false
173 |    },
174 |    "outputs": [
175 |     {
176 |      "name": "stdout",
177 |      "output_type": "stream",
178 |      "text": [
179 |       "0\n",
180 |       "1\n",
181 |       "2\n",
182 |       "3\n",
183 |       "4\n",
184 |       "5\n",
185 |       "6\n",
186 |       "7\n",
187 |       "8\n",
188 |       "9\n",
189 |       "10\n",
190 |       "11\n",
191 |       "12\n",
192 |       "13\n",
193 |       "14\n",
194 |       "15\n",
195 |       "16\n",
196 |       "17\n",
197 |       "18\n",
198 |       "19\n",
199 |       "20\n",
200 |       "21\n",
201 |       "22\n"
202 |      ]
203 |     }
204 |    ],
205 |    "source": [
206 |     "# Exercício 6 - Crie uma variável chamada contador = 0. Enquanto counter for menor que 100, imprima os valores na tela,\n",
207 |     "# mas quando for encontrado o valor 23, interrompa a execução do programa\n",
208 |     "counter = 0\n",
209 |     "while counter < 100:\n",
210 |     "    if counter == 23:\n",
211 |     "        break\n",
212 |     "    print(counter)\n",
213 |     "    counter += 1"
214 |    ]
215 |   },
216 |   {
217 |    "cell_type": "code",
218 |    "execution_count": 7,
219 |    "metadata": {
220 |     "collapsed": false
221 |    },
222 |    "outputs": [
223 |     {
224 |      "name": "stdout",
225 |      "output_type": "stream",
226 |      "text": [
227 |       "[4, 6, 8, 10, 12, 14, 16, 18, 20]\n"
228 |      ]
229 |     }
230 |    ],
231 |    "source": [
232 |     "# Exercício 7 - Crie uma lista vazia e uma variável com valor 4. Enquanto o valor da variável for menor ou igual a 20, \n",
233 |     "# adicione à lista, apenas os valores pares e imprima a lista\n",
234 |     "numeros = list()\n",
235 |     "i = 4\n",
236 |     "while (i <= 20):\n",
237 |     "    numeros.append(i)\n",
238 |     "    i = i+2\n",
239 |     "print(numeros)"
240 |    ]
241 |   },
242 |   {
243 |    "cell_type": "code",
244 |    "execution_count": 8,
245 |    "metadata": {
246 |     "collapsed": false
247 |    },
248 |    "outputs": [
249 |     {
250 |      "name": "stdout",
251 |      "output_type": "stream",
252 |      "text": [
253 |       "[5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43]\n"
254 |      ]
255 |     }
256 |    ],
257 |    "source": [
258 |     "# Exercício 8 - Transforme o resultado desta função range em uma lista: range(5, 45, 2)\n",
259 |     "nums = range(5, 45, 2)\n",
260 |     "print(list(nums))"
261 |    ]
262 |   },
263 |   {
264 |    "cell_type": "code",
265 |    "execution_count": 9,
266 |    "metadata": {
267 |     "collapsed": false
268 |    },
269 |    "outputs": [
270 |     {
271 |      "name": "stdout",
272 |      "output_type": "stream",
273 |      "text": [
274 |       "Qual a temperatura? 35\n",
275 |       "Vista roupas leves.\n"
276 |      ]
277 |     }
278 |    ],
279 |    "source": [
280 |     "# Exercício 9 - Faça a correção dos erros no código abaixo e execute o programa. Dica: são 3 erros.\n",
281 |     "temperatura = float(input('Qual a temperatura? '))\n",
282 |     "if temperatura > 30:\n",
283 |     "    print('Vista roupas leves.')\n",
284 |     "else:\n",
285 |     "    print('Busque seus casacos.')"
286 |    ]
287 |   },
288 |   {
289 |    "cell_type": "code",
290 |    "execution_count": 10,
291 |    "metadata": {
292 |     "collapsed": false
293 |    },
294 |    "outputs": [
295 |     {
296 |      "name": "stdout",
297 |      "output_type": "stream",
298 |      "text": [
299 |       "O caracter a aparece 9 vezes na frase.\n"
300 |      ]
301 |     }
302 |    ],
303 |    "source": [
304 |     "# Exercício 10 - Faça um programa que conte quantas vezes a letra \"a\" aparece na frase abaixo. Use um placeholder na \n",
305 |     "# sua instrução de impressão\n",
306 |     "\n",
307 |     "# “É melhor, muito melhor, contentar-se com a realidade; se ela não é tão brilhante como os sonhos, tem pelo menos a \n",
308 |     "# vantagem de existir.” (Machado de Assis)\n",
309 |     "\n",
310 |     "frase = \"É melhor, muito melhor, contentar-se com a realidade; se ela não é tão brilhante como os sonhos, tem pelo menos a vantagem de existir.\" \n",
311 |     "count = 0\n",
312 |     "for caracter in frase:\n",
313 |     "    if caracter == 'a':\n",
314 |     "        count += 1\n",
315 |     "print(\"O caracter a aparece %s vezes na frase.\" %(count))"
316 |    ]
317 |   },
318 |   {
319 |    "cell_type": "markdown",
320 |    "metadata": {},
321 |    "source": [
322 |     "# Fim"
323 |    ]
324 |   },
325 |   {
326 |    "cell_type": "markdown",
327 |    "metadata": {},
328 |    "source": [
329 |     "### Obrigado - Data Science Academy - <a href=http://facebook.com/dsacademy>facebook.com/dsacademybr</a>"
330 |    ]
331 |   }
332 |  ],
333 |  "metadata": {
334 |   "kernelspec": {
335 |    "display_name": "Python 3",
336 |    "language": "python",
337 |    "name": "python3"
338 |   },
339 |   "language_info": {
340 |    "codemirror_mode": {
341 |     "name": "ipython",
342 |     "version": 3
343 |    },
344 |    "file_extension": ".py",
345 |    "mimetype": "text/x-python",
346 |    "name": "python",
347 |    "nbconvert_exporter": "python",
348 |    "pygments_lexer": "ipython3",
349 |    "version": "3.5.1"
350 |   }
351 |  },
352 |  "nbformat": 4,
353 |  "nbformat_minor": 0
354 | }
355 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo03/DSA-Python-Capítulo3-Exercícios.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# <font color='blue'>Data Science Academy - Python Fundamentos - Capítulo 3</font>\n",
  8 |     "\n",
  9 |     "## Download: http://github.com/dsacademybr"
 10 |    ]
 11 |   },
 12 |   {
 13 |    "cell_type": "markdown",
 14 |    "metadata": {},
 15 |    "source": [
 16 |     "## Exercícios"
 17 |    ]
 18 |   },
 19 |   {
 20 |    "cell_type": "code",
 21 |    "execution_count": null,
 22 |    "metadata": {
 23 |     "collapsed": false
 24 |    },
 25 |    "outputs": [],
 26 |    "source": [
 27 |     "# Exercício 1 - Crie uma estrutura que pergunte ao usuário qual o dia da semana. Se o dia for igual a Domingo ou \n",
 28 |     "# igual a sábado, imprima na tela \"Hoje é dia de descanso\", caso contrário imprima na tela \"Você precisa trabalhar!\"\n"
 29 |    ]
 30 |   },
 31 |   {
 32 |    "cell_type": "code",
 33 |    "execution_count": null,
 34 |    "metadata": {
 35 |     "collapsed": false
 36 |    },
 37 |    "outputs": [],
 38 |    "source": [
 39 |     "# Exercício 2 - Crie uma lista de 5 frutas e verifique se a fruta 'Morango' faz parte da lista\n"
 40 |    ]
 41 |   },
 42 |   {
 43 |    "cell_type": "code",
 44 |    "execution_count": null,
 45 |    "metadata": {
 46 |     "collapsed": false
 47 |    },
 48 |    "outputs": [],
 49 |    "source": [
 50 |     "# Exercício 3 - Crie uma tupla de 4 elementos, multiplique cada elemento da tupla por 2 e guarde os resultados em uma \n",
 51 |     "# lista\n"
 52 |    ]
 53 |   },
 54 |   {
 55 |    "cell_type": "code",
 56 |    "execution_count": null,
 57 |    "metadata": {
 58 |     "collapsed": false
 59 |    },
 60 |    "outputs": [],
 61 |    "source": [
 62 |     "# Exercício 4 - Crie uma sequência de números pares entre 100 e 150 e imprima na tela\n"
 63 |    ]
 64 |   },
 65 |   {
 66 |    "cell_type": "code",
 67 |    "execution_count": null,
 68 |    "metadata": {
 69 |     "collapsed": false
 70 |    },
 71 |    "outputs": [],
 72 |    "source": [
 73 |     "# Exercício 5 - Crie uma variável chamada temperatura e atribua o valor 40. Enquanto temperatura for maior que 35, \n",
 74 |     "# imprima as temperaturas na tela\n"
 75 |    ]
 76 |   },
 77 |   {
 78 |    "cell_type": "code",
 79 |    "execution_count": null,
 80 |    "metadata": {
 81 |     "collapsed": false
 82 |    },
 83 |    "outputs": [],
 84 |    "source": [
 85 |     "# Exercício 6 - Crie uma variável chamada contador = 0. Enquanto counter for menor que 100, imprima os valores na tela,\n",
 86 |     "# mas quando for encontrado o valor 23, interrompa a execução do programa\n"
 87 |    ]
 88 |   },
 89 |   {
 90 |    "cell_type": "code",
 91 |    "execution_count": null,
 92 |    "metadata": {
 93 |     "collapsed": false
 94 |    },
 95 |    "outputs": [],
 96 |    "source": [
 97 |     "# Exercício 7 - Crie uma lista vazia e uma variável com valor 4. Enquanto o valor da variável for menor ou igual a 20, \n",
 98 |     "# adicione à lista, apenas os valores pares e imprima a lista\n"
 99 |    ]
100 |   },
101 |   {
102 |    "cell_type": "code",
103 |    "execution_count": null,
104 |    "metadata": {
105 |     "collapsed": false
106 |    },
107 |    "outputs": [],
108 |    "source": [
109 |     "# Exercício 8 - Transforme o resultado desta função range em uma lista: range(5, 45, 2)\n"
110 |    ]
111 |   },
112 |   {
113 |    "cell_type": "code",
114 |    "execution_count": null,
115 |    "metadata": {
116 |     "collapsed": false
117 |    },
118 |    "outputs": [],
119 |    "source": [
120 |     "# Exercício 9 - Faça a correção dos erros no código abaixo e execute o programa. Dica: são 3 erros.\n",
121 |     "temperatura = float(input('Qual a temperatura? ')\n",
122 |     "    if temperatura > 30\n",
123 |     "        print('Vista roupas leves.')\n",
124 |     "    else:\n",
125 |     "        print('Busque seus casacos.')\n"
126 |    ]
127 |   },
128 |   {
129 |    "cell_type": "code",
130 |    "execution_count": null,
131 |    "metadata": {
132 |     "collapsed": false
133 |    },
134 |    "outputs": [],
135 |    "source": [
136 |     "# Exercício 10 - Faça um programa que conte quantas vezes a letra \"a\" aparece na frase abaixo. Use um placeholder na \n",
137 |     "# sua instrução de impressão\n",
138 |     "\n",
139 |     "# “É melhor, muito melhor, contentar-se com a realidade; se ela não é tão brilhante como os sonhos, tem pelo menos a \n",
140 |     "# vantagem de existir.” (Machado de Assis)\n",
141 |     "\n"
142 |    ]
143 |   },
144 |   {
145 |    "cell_type": "markdown",
146 |    "metadata": {},
147 |    "source": [
148 |     "# Fim"
149 |    ]
150 |   },
151 |   {
152 |    "cell_type": "markdown",
153 |    "metadata": {},
154 |    "source": [
155 |     "### Obrigado - Data Science Academy - <a href=http://facebook.com/dsacademy>facebook.com/dsacademybr</a>"
156 |    ]
157 |   }
158 |  ],
159 |  "metadata": {
160 |   "kernelspec": {
161 |    "display_name": "Python 3",
162 |    "language": "python",
163 |    "name": "python3"
164 |   },
165 |   "language_info": {
166 |    "codemirror_mode": {
167 |     "name": "ipython",
168 |     "version": 3
169 |    },
170 |    "file_extension": ".py",
171 |    "mimetype": "text/x-python",
172 |    "name": "python",
173 |    "nbconvert_exporter": "python",
174 |    "pygments_lexer": "ipython3",
175 |    "version": "3.5.1"
176 |   }
177 |  },
178 |  "nbformat": 4,
179 |  "nbformat_minor": 0
180 | }
181 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo03/DSA-Python-Capítulo3-Range.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# <font color='blue'>Data Science Academy - Python Fundamentos - Capítulo 3</font>\n",
  8 |     "\n",
  9 |     "## Download: http://github.com/dsacademybr"
 10 |    ]
 11 |   },
 12 |   {
 13 |    "cell_type": "markdown",
 14 |    "metadata": {},
 15 |    "source": [
 16 |     "### Range"
 17 |    ]
 18 |   },
 19 |   {
 20 |    "cell_type": "code",
 21 |    "execution_count": 1,
 22 |    "metadata": {
 23 |     "collapsed": false
 24 |    },
 25 |    "outputs": [
 26 |     {
 27 |      "name": "stdout",
 28 |      "output_type": "stream",
 29 |      "text": [
 30 |       "50\n",
 31 |       "52\n",
 32 |       "54\n",
 33 |       "56\n",
 34 |       "58\n",
 35 |       "60\n",
 36 |       "62\n",
 37 |       "64\n",
 38 |       "66\n",
 39 |       "68\n",
 40 |       "70\n",
 41 |       "72\n",
 42 |       "74\n",
 43 |       "76\n",
 44 |       "78\n",
 45 |       "80\n",
 46 |       "82\n",
 47 |       "84\n",
 48 |       "86\n",
 49 |       "88\n",
 50 |       "90\n",
 51 |       "92\n",
 52 |       "94\n",
 53 |       "96\n",
 54 |       "98\n",
 55 |       "100\n"
 56 |      ]
 57 |     }
 58 |    ],
 59 |    "source": [
 60 |     "# Imprimindo números pares entre 50 e 101\n",
 61 |     "for i in range(50, 101, 2):\n",
 62 |     "    print(i)"
 63 |    ]
 64 |   },
 65 |   {
 66 |    "cell_type": "code",
 67 |    "execution_count": 2,
 68 |    "metadata": {
 69 |     "collapsed": false
 70 |    },
 71 |    "outputs": [
 72 |     {
 73 |      "name": "stdout",
 74 |      "output_type": "stream",
 75 |      "text": [
 76 |       "3\n",
 77 |       "4\n",
 78 |       "5\n"
 79 |      ]
 80 |     }
 81 |    ],
 82 |    "source": [
 83 |     "for i in range(3, 6):\n",
 84 |     "    print (i)"
 85 |    ]
 86 |   },
 87 |   {
 88 |    "cell_type": "code",
 89 |    "execution_count": 3,
 90 |    "metadata": {
 91 |     "collapsed": false
 92 |    },
 93 |    "outputs": [
 94 |     {
 95 |      "name": "stdout",
 96 |      "output_type": "stream",
 97 |      "text": [
 98 |       "0\n",
 99 |       "-2\n",
100 |       "-4\n",
101 |       "-6\n",
102 |       "-8\n",
103 |       "-10\n",
104 |       "-12\n",
105 |       "-14\n",
106 |       "-16\n",
107 |       "-18\n"
108 |      ]
109 |     }
110 |    ],
111 |    "source": [
112 |     "for i in range(0, -20, -2):\n",
113 |     "    print(i)"
114 |    ]
115 |   },
116 |   {
117 |    "cell_type": "code",
118 |    "execution_count": 4,
119 |    "metadata": {
120 |     "collapsed": false
121 |    },
122 |    "outputs": [
123 |     {
124 |      "name": "stdout",
125 |      "output_type": "stream",
126 |      "text": [
127 |       "Morango\n",
128 |       "Banana\n",
129 |       "Maça\n",
130 |       "Uva\n"
131 |      ]
132 |     }
133 |    ],
134 |    "source": [
135 |     "lista = ['Morango', 'Banana', 'Maça', 'Uva']\n",
136 |     "lista_tamanho = len(lista)\n",
137 |     "for i in range(0, lista_tamanho):\n",
138 |     "    print(lista[i])"
139 |    ]
140 |   },
141 |   {
142 |    "cell_type": "code",
143 |    "execution_count": 5,
144 |    "metadata": {
145 |     "collapsed": false
146 |    },
147 |    "outputs": [
148 |     {
149 |      "data": {
150 |       "text/plain": [
151 |        "range"
152 |       ]
153 |      },
154 |      "execution_count": 5,
155 |      "metadata": {},
156 |      "output_type": "execute_result"
157 |     }
158 |    ],
159 |    "source": [
160 |     "# Tudo em Python é um objeto\n",
161 |     "type(range(0,3))"
162 |    ]
163 |   },
164 |   {
165 |    "cell_type": "markdown",
166 |    "metadata": {},
167 |    "source": [
168 |     "# Fim"
169 |    ]
170 |   },
171 |   {
172 |    "cell_type": "markdown",
173 |    "metadata": {},
174 |    "source": [
175 |     "### Obrigado - Data Science Academy - <a href=http://facebook.com/dsacademy>facebook.com/dsacademybr</a>"
176 |    ]
177 |   }
178 |  ],
179 |  "metadata": {
180 |   "kernelspec": {
181 |    "display_name": "Python 3",
182 |    "language": "python",
183 |    "name": "python3"
184 |   },
185 |   "language_info": {
186 |    "codemirror_mode": {
187 |     "name": "ipython",
188 |     "version": 3
189 |    },
190 |    "file_extension": ".py",
191 |    "mimetype": "text/x-python",
192 |    "name": "python",
193 |    "nbconvert_exporter": "python",
194 |    "pygments_lexer": "ipython3",
195 |    "version": "3.5.1"
196 |   }
197 |  },
198 |  "nbformat": 4,
199 |  "nbformat_minor": 0
200 | }
201 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo03/DSA-Python-Capítulo3-While.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# <font color='blue'>Data Science Academy - Python Fundamentos - Capítulo 3</font>\n",
  8 |     "\n",
  9 |     "## Download: http://github.com/dsacademybr"
 10 |    ]
 11 |   },
 12 |   {
 13 |    "cell_type": "markdown",
 14 |    "metadata": {},
 15 |    "source": [
 16 |     "### While"
 17 |    ]
 18 |   },
 19 |   {
 20 |    "cell_type": "code",
 21 |    "execution_count": 1,
 22 |    "metadata": {
 23 |     "collapsed": false
 24 |    },
 25 |    "outputs": [
 26 |     {
 27 |      "name": "stdout",
 28 |      "output_type": "stream",
 29 |      "text": [
 30 |       "0\n",
 31 |       "1\n",
 32 |       "2\n",
 33 |       "3\n",
 34 |       "4\n",
 35 |       "5\n",
 36 |       "6\n",
 37 |       "7\n",
 38 |       "8\n",
 39 |       "9\n"
 40 |      ]
 41 |     }
 42 |    ],
 43 |    "source": [
 44 |     "# Usando o loop while para imprimir os valores de 0 a 9\n",
 45 |     "counter = 0\n",
 46 |     "while counter < 10:\n",
 47 |     "    print(counter)\n",
 48 |     "    counter = counter + 1"
 49 |    ]
 50 |   },
 51 |   {
 52 |    "cell_type": "code",
 53 |    "execution_count": 2,
 54 |    "metadata": {
 55 |     "collapsed": false
 56 |    },
 57 |    "outputs": [
 58 |     {
 59 |      "name": "stdout",
 60 |      "output_type": "stream",
 61 |      "text": [
 62 |       "O valor de x nesta iteração é:  0\n",
 63 |       " x ainda é menor que 10, somando 1 a x\n",
 64 |       "O valor de x nesta iteração é:  1\n",
 65 |       " x ainda é menor que 10, somando 1 a x\n",
 66 |       "O valor de x nesta iteração é:  2\n",
 67 |       " x ainda é menor que 10, somando 1 a x\n",
 68 |       "O valor de x nesta iteração é:  3\n",
 69 |       " x ainda é menor que 10, somando 1 a x\n",
 70 |       "O valor de x nesta iteração é:  4\n",
 71 |       " x ainda é menor que 10, somando 1 a x\n",
 72 |       "O valor de x nesta iteração é:  5\n",
 73 |       " x ainda é menor que 10, somando 1 a x\n",
 74 |       "O valor de x nesta iteração é:  6\n",
 75 |       " x ainda é menor que 10, somando 1 a x\n",
 76 |       "O valor de x nesta iteração é:  7\n",
 77 |       " x ainda é menor que 10, somando 1 a x\n",
 78 |       "O valor de x nesta iteração é:  8\n",
 79 |       " x ainda é menor que 10, somando 1 a x\n",
 80 |       "O valor de x nesta iteração é:  9\n",
 81 |       " x ainda é menor que 10, somando 1 a x\n",
 82 |       "Loop concluído!\n"
 83 |      ]
 84 |     }
 85 |    ],
 86 |    "source": [
 87 |     "# Também é possível usar a claúsula else para encerrar o loop while\n",
 88 |     "x = 0\n",
 89 |     "\n",
 90 |     "while x < 10:\n",
 91 |     "    print ('O valor de x nesta iteração é: ', x)\n",
 92 |     "    print (' x ainda é menor que 10, somando 1 a x')\n",
 93 |     "    x += 1\n",
 94 |     "    \n",
 95 |     "else:\n",
 96 |     "    print ('Loop concluído!')"
 97 |    ]
 98 |   },
 99 |   {
100 |    "cell_type": "markdown",
101 |    "metadata": {},
102 |    "source": [
103 |     "### Pass, Break, Continue"
104 |    ]
105 |   },
106 |   {
107 |    "cell_type": "code",
108 |    "execution_count": 3,
109 |    "metadata": {
110 |     "collapsed": false
111 |    },
112 |    "outputs": [
113 |     {
114 |      "name": "stdout",
115 |      "output_type": "stream",
116 |      "text": [
117 |       "0\n",
118 |       "1\n",
119 |       "2\n",
120 |       "3\n"
121 |      ]
122 |     }
123 |    ],
124 |    "source": [
125 |     "counter = 0\n",
126 |     "while counter < 100:\n",
127 |     "    if counter == 4:\n",
128 |     "        break\n",
129 |     "    else:\n",
130 |     "        pass\n",
131 |     "    print(counter)\n",
132 |     "    counter = counter + 1"
133 |    ]
134 |   },
135 |   {
136 |    "cell_type": "code",
137 |    "execution_count": 4,
138 |    "metadata": {
139 |     "collapsed": false
140 |    },
141 |    "outputs": [
142 |     {
143 |      "name": "stdout",
144 |      "output_type": "stream",
145 |      "text": [
146 |       "P\n",
147 |       "y\n",
148 |       "t\n",
149 |       "o\n",
150 |       "n\n"
151 |      ]
152 |     }
153 |    ],
154 |    "source": [
155 |     "for verificador in \"Python\":\n",
156 |     "    if verificador == \"h\":\n",
157 |     "        continue\n",
158 |     "    print(verificador)"
159 |    ]
160 |   },
161 |   {
162 |    "cell_type": "markdown",
163 |    "metadata": {},
164 |    "source": [
165 |     "### While e For juntos"
166 |    ]
167 |   },
168 |   {
169 |    "cell_type": "code",
170 |    "execution_count": 5,
171 |    "metadata": {
172 |     "collapsed": false
173 |    },
174 |    "outputs": [
175 |     {
176 |      "name": "stdout",
177 |      "output_type": "stream",
178 |      "text": [
179 |       "2 é um número primo\n",
180 |       "3 é um número primo\n",
181 |       "5 é um número primo\n",
182 |       "7 é um número primo\n",
183 |       "11 é um número primo\n",
184 |       "13 é um número primo\n",
185 |       "17 é um número primo\n",
186 |       "19 é um número primo\n",
187 |       "23 é um número primo\n",
188 |       "29 é um número primo\n"
189 |      ]
190 |     }
191 |    ],
192 |    "source": [
193 |     "for i in range(2,30):\n",
194 |     "    j = 2\n",
195 |     "    counter = 0\n",
196 |     "    while j < i:\n",
197 |     "        if i % j == 0:\n",
198 |     "            counter = 1\n",
199 |     "            j = j + 1\n",
200 |     "        else:\n",
201 |     "            j = j + 1\n",
202 |     "    if counter == 0:\n",
203 |     "        print(str(i) + \" é um número primo\")\n",
204 |     "        counter = 0\n",
205 |     "    else:\n",
206 |     "        counter = 0"
207 |    ]
208 |   },
209 |   {
210 |    "cell_type": "markdown",
211 |    "metadata": {},
212 |    "source": [
213 |     "# Fim"
214 |    ]
215 |   },
216 |   {
217 |    "cell_type": "markdown",
218 |    "metadata": {},
219 |    "source": [
220 |     "### Obrigado - Data Science Academy - <a href=http://facebook.com/dsacademy>facebook.com/dsacademybr</a>"
221 |    ]
222 |   }
223 |  ],
224 |  "metadata": {
225 |   "kernelspec": {
226 |    "display_name": "Python 3",
227 |    "language": "python",
228 |    "name": "python3"
229 |   },
230 |   "language_info": {
231 |    "codemirror_mode": {
232 |     "name": "ipython",
233 |     "version": 3
234 |    },
235 |    "file_extension": ".py",
236 |    "mimetype": "text/x-python",
237 |    "name": "python",
238 |    "nbconvert_exporter": "python",
239 |    "pygments_lexer": "ipython3",
240 |    "version": "3.5.1"
241 |   }
242 |  },
243 |  "nbformat": 4,
244 |  "nbformat_minor": 0
245 | }
246 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo04/DSA-Python-Capítulo4-Exercícios-Solução.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# <font color='blue'>Data Science Academy - Python Fundamentos - Capítulo 4</font>\n",
  8 |     "\n",
  9 |     "## Download: http://github.com/dsacademybr"
 10 |    ]
 11 |   },
 12 |   {
 13 |    "cell_type": "markdown",
 14 |    "metadata": {},
 15 |    "source": [
 16 |     "## Exercícios"
 17 |    ]
 18 |   },
 19 |   {
 20 |    "cell_type": "code",
 21 |    "execution_count": 1,
 22 |    "metadata": {
 23 |     "collapsed": false
 24 |    },
 25 |    "outputs": [
 26 |     {
 27 |      "name": "stdout",
 28 |      "output_type": "stream",
 29 |      "text": [
 30 |       "2\n",
 31 |       "4\n",
 32 |       "6\n",
 33 |       "8\n",
 34 |       "10\n",
 35 |       "12\n",
 36 |       "14\n",
 37 |       "16\n",
 38 |       "18\n",
 39 |       "20\n"
 40 |      ]
 41 |     }
 42 |    ],
 43 |    "source": [
 44 |     "# Exercício 1 - Crie uma função que imprima a sequência de números pares entre 1 e 20 (a função não recebe parâmetro) e \n",
 45 |     "# depois faça uma chamada à função para listar os números\n",
 46 |     "def listaPar():\n",
 47 |     "    for i in range(2, 21, 2): \n",
 48 |     "        print(i)\n",
 49 |     "        \n",
 50 |     "listaPar()        "
 51 |    ]
 52 |   },
 53 |   {
 54 |    "cell_type": "code",
 55 |    "execution_count": 2,
 56 |    "metadata": {
 57 |     "collapsed": false
 58 |    },
 59 |    "outputs": [
 60 |     {
 61 |      "name": "stdout",
 62 |      "output_type": "stream",
 63 |      "text": [
 64 |       "RUMO À ANÁLISE DE DADOS\n"
 65 |      ]
 66 |     }
 67 |    ],
 68 |    "source": [
 69 |     "# Exercício 2 - Crie uam função que receba uma string como argumento e retorne a mesma string em letras maiúsculas.\n",
 70 |     "# Faça uma chamada à função, passando como parâmetro uma string\n",
 71 |     "def listaString(texto):\n",
 72 |     "    print(texto.upper())\n",
 73 |     "    return\n",
 74 |     "\n",
 75 |     "listaString('Rumo à Análise de Dados')"
 76 |    ]
 77 |   },
 78 |   {
 79 |    "cell_type": "code",
 80 |    "execution_count": 3,
 81 |    "metadata": {
 82 |     "collapsed": false
 83 |    },
 84 |    "outputs": [
 85 |     {
 86 |      "name": "stdout",
 87 |      "output_type": "stream",
 88 |      "text": [
 89 |       "None\n",
 90 |       "None\n",
 91 |       "[1, 2, 3, 4, 5, 6]\n"
 92 |      ]
 93 |     }
 94 |    ],
 95 |    "source": [
 96 |     "# Exercício 3 - Crie uma função que receba como parâmetro uma lista de 4 elementos, adicione 2 elementos a lista e \n",
 97 |     "# imprima a lista\n",
 98 |     "def novaLista(lista):\n",
 99 |     "    print(lista.append(5))\n",
100 |     "    print(lista.append(6))\n",
101 |     "   \n",
102 |     "lista1 = [1, 2, 3, 4]   \n",
103 |     "novaLista(lista1)\n",
104 |     "print(lista1)"
105 |    ]
106 |   },
107 |   {
108 |    "cell_type": "code",
109 |    "execution_count": 4,
110 |    "metadata": {
111 |     "collapsed": false
112 |    },
113 |    "outputs": [
114 |     {
115 |      "name": "stdout",
116 |      "output_type": "stream",
117 |      "text": [
118 |       "100\n",
119 |       "A\n",
120 |       "B\n",
121 |       "C\n"
122 |      ]
123 |     }
124 |    ],
125 |    "source": [
126 |     "# Exercício 4 - Crie uma função que receba um argumento formal e uma possível lista de elementos. Faça duas chamadas \n",
127 |     "# à função, com apenas 1 elemento e na segunda chamada com 4 elementos\n",
128 |     "def printNum( arg1, *lista ):\n",
129 |     "    print (arg1)\n",
130 |     "    for i in lista:\n",
131 |     "        print (i)\n",
132 |     "    return;\n",
133 |     "\n",
134 |     "# Chamada à função\n",
135 |     "printNum( 100 )\n",
136 |     "printNum( 'A', 'B', 'C' )"
137 |    ]
138 |   },
139 |   {
140 |    "cell_type": "code",
141 |    "execution_count": 5,
142 |    "metadata": {
143 |     "collapsed": false
144 |    },
145 |    "outputs": [
146 |     {
147 |      "name": "stdout",
148 |      "output_type": "stream",
149 |      "text": [
150 |       "A soma é :  750\n"
151 |      ]
152 |     }
153 |    ],
154 |    "source": [
155 |     "# Exercício 5 - Crie uma função anônima e atribua seu retorno a uma variável chamada soma. A expressão vai receber 2 \n",
156 |     "# números como parâmetro e retornar a soma deles\n",
157 |     "soma = lambda arg1, arg2: arg1 + arg2;\n",
158 |     "print (\"A soma é : \", soma( 452, 298 ))"
159 |    ]
160 |   },
161 |   {
162 |    "cell_type": "code",
163 |    "execution_count": 6,
164 |    "metadata": {
165 |     "collapsed": false
166 |    },
167 |    "outputs": [
168 |     {
169 |      "name": "stdout",
170 |      "output_type": "stream",
171 |      "text": [
172 |       "Dentro da função o total é :  30\n",
173 |       "Fora da função o total é :  0\n"
174 |      ]
175 |     }
176 |    ],
177 |    "source": [
178 |     "# Exercício 6 - Execute o código abaixo e certifique-se que compreende a diferença entre variável global e local\n",
179 |     "\n",
180 |     "total = 0; \n",
181 |     "def soma( arg1, arg2 ):\n",
182 |     "    total = arg1 + arg2; \n",
183 |     "    print (\"Dentro da função o total é : \", total)\n",
184 |     "    return total;\n",
185 |     "\n",
186 |     "\n",
187 |     "soma( 10, 20 );\n",
188 |     "print (\"Fora da função o total é : \", total)"
189 |    ]
190 |   },
191 |   {
192 |    "cell_type": "code",
193 |    "execution_count": 7,
194 |    "metadata": {
195 |     "collapsed": false
196 |    },
197 |    "outputs": [
198 |     {
199 |      "data": {
200 |       "text/html": [
201 |        "<div>\n",
202 |        "<table border=\"1\" class=\"dataframe\">\n",
203 |        "  <thead>\n",
204 |        "    <tr style=\"text-align: right;\">\n",
205 |        "      <th></th>\n",
206 |        "      <th>admit</th>\n",
207 |        "      <th>gre</th>\n",
208 |        "      <th>gpa</th>\n",
209 |        "      <th>rank</th>\n",
210 |        "    </tr>\n",
211 |        "  </thead>\n",
212 |        "  <tbody>\n",
213 |        "    <tr>\n",
214 |        "      <th>count</th>\n",
215 |        "      <td>400.000000</td>\n",
216 |        "      <td>400.000000</td>\n",
217 |        "      <td>400.000000</td>\n",
218 |        "      <td>400.00000</td>\n",
219 |        "    </tr>\n",
220 |        "    <tr>\n",
221 |        "      <th>mean</th>\n",
222 |        "      <td>0.317500</td>\n",
223 |        "      <td>587.700000</td>\n",
224 |        "      <td>3.389900</td>\n",
225 |        "      <td>2.48500</td>\n",
226 |        "    </tr>\n",
227 |        "    <tr>\n",
228 |        "      <th>std</th>\n",
229 |        "      <td>0.466087</td>\n",
230 |        "      <td>115.516536</td>\n",
231 |        "      <td>0.380567</td>\n",
232 |        "      <td>0.94446</td>\n",
233 |        "    </tr>\n",
234 |        "    <tr>\n",
235 |        "      <th>min</th>\n",
236 |        "      <td>0.000000</td>\n",
237 |        "      <td>220.000000</td>\n",
238 |        "      <td>2.260000</td>\n",
239 |        "      <td>1.00000</td>\n",
240 |        "    </tr>\n",
241 |        "    <tr>\n",
242 |        "      <th>25%</th>\n",
243 |        "      <td>0.000000</td>\n",
244 |        "      <td>520.000000</td>\n",
245 |        "      <td>3.130000</td>\n",
246 |        "      <td>2.00000</td>\n",
247 |        "    </tr>\n",
248 |        "    <tr>\n",
249 |        "      <th>50%</th>\n",
250 |        "      <td>0.000000</td>\n",
251 |        "      <td>580.000000</td>\n",
252 |        "      <td>3.395000</td>\n",
253 |        "      <td>2.00000</td>\n",
254 |        "    </tr>\n",
255 |        "    <tr>\n",
256 |        "      <th>75%</th>\n",
257 |        "      <td>1.000000</td>\n",
258 |        "      <td>660.000000</td>\n",
259 |        "      <td>3.670000</td>\n",
260 |        "      <td>3.00000</td>\n",
261 |        "    </tr>\n",
262 |        "    <tr>\n",
263 |        "      <th>max</th>\n",
264 |        "      <td>1.000000</td>\n",
265 |        "      <td>800.000000</td>\n",
266 |        "      <td>4.000000</td>\n",
267 |        "      <td>4.00000</td>\n",
268 |        "    </tr>\n",
269 |        "  </tbody>\n",
270 |        "</table>\n",
271 |        "</div>"
272 |       ],
273 |       "text/plain": [
274 |        "            admit         gre         gpa       rank\n",
275 |        "count  400.000000  400.000000  400.000000  400.00000\n",
276 |        "mean     0.317500  587.700000    3.389900    2.48500\n",
277 |        "std      0.466087  115.516536    0.380567    0.94446\n",
278 |        "min      0.000000  220.000000    2.260000    1.00000\n",
279 |        "25%      0.000000  520.000000    3.130000    2.00000\n",
280 |        "50%      0.000000  580.000000    3.395000    2.00000\n",
281 |        "75%      1.000000  660.000000    3.670000    3.00000\n",
282 |        "max      1.000000  800.000000    4.000000    4.00000"
283 |       ]
284 |      },
285 |      "execution_count": 7,
286 |      "metadata": {},
287 |      "output_type": "execute_result"
288 |     }
289 |    ],
290 |    "source": [
291 |     "# Exercício 7 - Crie uma função que receba o arquivo abaixo como argumento e retorne um resumo estatístico descritivo \n",
292 |     "# do arquivo. Dica, use Pandas e um de seus métodos, describe()\n",
293 |     "# Arquivo: \"http://www.ats.ucla.edu/stat/data/binary.csv\"\n",
294 |     "import pandas as pd\n",
295 |     "file_name = \"http://www.ats.ucla.edu/stat/data/binary.csv\"\n",
296 |     "\n",
297 |     "def retornaArq(file_name):\n",
298 |     "    df = pd.read_csv(file_name)\n",
299 |     "    return df.describe()\n",
300 |     "    \n",
301 |     "retornaArq(file_name)  "
302 |    ]
303 |   },
304 |   {
305 |    "cell_type": "markdown",
306 |    "metadata": {},
307 |    "source": [
308 |     "# Fim"
309 |    ]
310 |   },
311 |   {
312 |    "cell_type": "markdown",
313 |    "metadata": {},
314 |    "source": [
315 |     "### Obrigado - Data Science Academy - <a href=http://facebook.com/dsacademy>facebook.com/dsacademybr</a>"
316 |    ]
317 |   }
318 |  ],
319 |  "metadata": {
320 |   "kernelspec": {
321 |    "display_name": "Python 3",
322 |    "language": "python",
323 |    "name": "python3"
324 |   },
325 |   "language_info": {
326 |    "codemirror_mode": {
327 |     "name": "ipython",
328 |     "version": 3
329 |    },
330 |    "file_extension": ".py",
331 |    "mimetype": "text/x-python",
332 |    "name": "python",
333 |    "nbconvert_exporter": "python",
334 |    "pygments_lexer": "ipython3",
335 |    "version": "3.5.1"
336 |   }
337 |  },
338 |  "nbformat": 4,
339 |  "nbformat_minor": 0
340 | }
341 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo04/DSA-Python-Capítulo4-Exercícios.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# <font color='blue'>Data Science Academy - Python Fundamentos - Capítulo 4</font>\n",
  8 |     "\n",
  9 |     "## Download: http://github.com/dsacademybr"
 10 |    ]
 11 |   },
 12 |   {
 13 |    "cell_type": "markdown",
 14 |    "metadata": {},
 15 |    "source": [
 16 |     "## Exercícios"
 17 |    ]
 18 |   },
 19 |   {
 20 |    "cell_type": "code",
 21 |    "execution_count": null,
 22 |    "metadata": {
 23 |     "collapsed": false
 24 |    },
 25 |    "outputs": [],
 26 |    "source": [
 27 |     "# Exercício 1 - Crie uma função que imprima a sequência de números pares entre 1 e 20 (a função não recebe parâmetro) e \n",
 28 |     "# depois faça uma chamada à função para listar os números\n",
 29 |     "  "
 30 |    ]
 31 |   },
 32 |   {
 33 |    "cell_type": "code",
 34 |    "execution_count": null,
 35 |    "metadata": {
 36 |     "collapsed": false
 37 |    },
 38 |    "outputs": [],
 39 |    "source": [
 40 |     "# Exercício 2 - Crie uam função que receba uma string como argumento e retorne a mesma string em letras maiúsculas.\n",
 41 |     "# Faça uma chamada à função, passando como parâmetro uma string\n"
 42 |    ]
 43 |   },
 44 |   {
 45 |    "cell_type": "code",
 46 |    "execution_count": null,
 47 |    "metadata": {
 48 |     "collapsed": false
 49 |    },
 50 |    "outputs": [],
 51 |    "source": [
 52 |     "# Exercício 3 - Crie uma função que receba como parâmetro uma lista de 4 elementos, adicione 2 elementos a lista e \n",
 53 |     "# imprima a lista\n"
 54 |    ]
 55 |   },
 56 |   {
 57 |    "cell_type": "code",
 58 |    "execution_count": null,
 59 |    "metadata": {
 60 |     "collapsed": false
 61 |    },
 62 |    "outputs": [],
 63 |    "source": [
 64 |     "# Exercício 4 - Crie uma função que receba um argumento formal e uma possível lista de elementos. Faça duas chamadas \n",
 65 |     "# à função, com apenas 1 elemento e na segunda chamada com 4 elementos\n"
 66 |    ]
 67 |   },
 68 |   {
 69 |    "cell_type": "code",
 70 |    "execution_count": null,
 71 |    "metadata": {
 72 |     "collapsed": false
 73 |    },
 74 |    "outputs": [],
 75 |    "source": [
 76 |     "# Exercício 5 - Crie uma função anônima e atribua seu retorno a uma variável chamada soma. A expressão vai receber 2 \n",
 77 |     "# números como parâmetro e retornar a soma deles\n"
 78 |    ]
 79 |   },
 80 |   {
 81 |    "cell_type": "code",
 82 |    "execution_count": null,
 83 |    "metadata": {
 84 |     "collapsed": false
 85 |    },
 86 |    "outputs": [],
 87 |    "source": [
 88 |     "# Exercício 6 - Execute o código abaixo e certifique-se que compreende a diferença entre variável global e local\n"
 89 |    ]
 90 |   },
 91 |   {
 92 |    "cell_type": "code",
 93 |    "execution_count": null,
 94 |    "metadata": {
 95 |     "collapsed": false
 96 |    },
 97 |    "outputs": [],
 98 |    "source": [
 99 |     "# Exercício 7 - Crie uma função que receba o arquivo abaixo como argumento e retorne um resumo estatístico descritivo \n",
100 |     "# do arquivo. Dica, use Pandas e um de seus métodos, describe()\n",
101 |     "# Arquivo: \"http://www.ats.ucla.edu/stat/data/binary.csv\"\n",
102 |     " "
103 |    ]
104 |   },
105 |   {
106 |    "cell_type": "markdown",
107 |    "metadata": {},
108 |    "source": [
109 |     "# Fim"
110 |    ]
111 |   },
112 |   {
113 |    "cell_type": "markdown",
114 |    "metadata": {},
115 |    "source": [
116 |     "### Obrigado - Data Science Academy - <a href=http://facebook.com/dsacademy>facebook.com/dsacademybr</a>"
117 |    ]
118 |   }
119 |  ],
120 |  "metadata": {
121 |   "kernelspec": {
122 |    "display_name": "Python 3",
123 |    "language": "python",
124 |    "name": "python3"
125 |   },
126 |   "language_info": {
127 |    "codemirror_mode": {
128 |     "name": "ipython",
129 |     "version": 3
130 |    },
131 |    "file_extension": ".py",
132 |    "mimetype": "text/x-python",
133 |    "name": "python",
134 |    "nbconvert_exporter": "python",
135 |    "pygments_lexer": "ipython3",
136 |    "version": "3.5.1"
137 |   }
138 |  },
139 |  "nbformat": 4,
140 |  "nbformat_minor": 0
141 | }
142 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo04/DSA-Python-Capítulo4-Lambda.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# <font color='blue'>Data Science Academy - Python Fundamentos - Capítulo 4</font>\n",
  8 |     "\n",
  9 |     "## Download: http://github.com/dsacademybr"
 10 |    ]
 11 |   },
 12 |   {
 13 |    "cell_type": "markdown",
 14 |    "metadata": {},
 15 |    "source": [
 16 |     "# Expressões Lambda"
 17 |    ]
 18 |   },
 19 |   {
 20 |    "cell_type": "code",
 21 |    "execution_count": 1,
 22 |    "metadata": {
 23 |     "collapsed": true
 24 |    },
 25 |    "outputs": [],
 26 |    "source": [
 27 |     "# Definindo uma função - 3 linhas de código\n",
 28 |     "def potencia(num):\n",
 29 |     "    result = num**2\n",
 30 |     "    return result"
 31 |    ]
 32 |   },
 33 |   {
 34 |    "cell_type": "code",
 35 |    "execution_count": 2,
 36 |    "metadata": {
 37 |     "collapsed": false
 38 |    },
 39 |    "outputs": [
 40 |     {
 41 |      "data": {
 42 |       "text/plain": [
 43 |        "25"
 44 |       ]
 45 |      },
 46 |      "execution_count": 2,
 47 |      "metadata": {},
 48 |      "output_type": "execute_result"
 49 |     }
 50 |    ],
 51 |    "source": [
 52 |     "potencia(5)"
 53 |    ]
 54 |   },
 55 |   {
 56 |    "cell_type": "code",
 57 |    "execution_count": 3,
 58 |    "metadata": {
 59 |     "collapsed": true
 60 |    },
 61 |    "outputs": [],
 62 |    "source": [
 63 |     "# Definindo uma função - 2 linhas de código\n",
 64 |     "def potencia(num):\n",
 65 |     "    return num**2"
 66 |    ]
 67 |   },
 68 |   {
 69 |    "cell_type": "code",
 70 |    "execution_count": 4,
 71 |    "metadata": {
 72 |     "collapsed": false
 73 |    },
 74 |    "outputs": [
 75 |     {
 76 |      "data": {
 77 |       "text/plain": [
 78 |        "25"
 79 |       ]
 80 |      },
 81 |      "execution_count": 4,
 82 |      "metadata": {},
 83 |      "output_type": "execute_result"
 84 |     }
 85 |    ],
 86 |    "source": [
 87 |     "potencia(5)"
 88 |    ]
 89 |   },
 90 |   {
 91 |    "cell_type": "code",
 92 |    "execution_count": 5,
 93 |    "metadata": {
 94 |     "collapsed": false
 95 |    },
 96 |    "outputs": [],
 97 |    "source": [
 98 |     "# Definindo uma função - 1 linha de código\n",
 99 |     "def potencia(num): return num**2"
100 |    ]
101 |   },
102 |   {
103 |    "cell_type": "code",
104 |    "execution_count": 6,
105 |    "metadata": {
106 |     "collapsed": false
107 |    },
108 |    "outputs": [
109 |     {
110 |      "data": {
111 |       "text/plain": [
112 |        "25"
113 |       ]
114 |      },
115 |      "execution_count": 6,
116 |      "metadata": {},
117 |      "output_type": "execute_result"
118 |     }
119 |    ],
120 |    "source": [
121 |     "potencia(5)"
122 |    ]
123 |   },
124 |   {
125 |    "cell_type": "code",
126 |    "execution_count": 7,
127 |    "metadata": {
128 |     "collapsed": false
129 |    },
130 |    "outputs": [
131 |     {
132 |      "data": {
133 |       "text/plain": [
134 |        "<function __main__.<lambda>>"
135 |       ]
136 |      },
137 |      "execution_count": 7,
138 |      "metadata": {},
139 |      "output_type": "execute_result"
140 |     }
141 |    ],
142 |    "source": [
143 |     "# Definindo uma expressão lambda\n",
144 |     "lambda num: num**2"
145 |    ]
146 |   },
147 |   {
148 |    "cell_type": "code",
149 |    "execution_count": 8,
150 |    "metadata": {
151 |     "collapsed": true
152 |    },
153 |    "outputs": [],
154 |    "source": [
155 |     "# Lembre: operadores de comparação retornam boolean, true or false\n",
156 |     "Par = lambda x: x%2==0"
157 |    ]
158 |   },
159 |   {
160 |    "cell_type": "code",
161 |    "execution_count": 9,
162 |    "metadata": {
163 |     "collapsed": false
164 |    },
165 |    "outputs": [
166 |     {
167 |      "data": {
168 |       "text/plain": [
169 |        "False"
170 |       ]
171 |      },
172 |      "execution_count": 9,
173 |      "metadata": {},
174 |      "output_type": "execute_result"
175 |     }
176 |    ],
177 |    "source": [
178 |     "Par(3)"
179 |    ]
180 |   },
181 |   {
182 |    "cell_type": "code",
183 |    "execution_count": 10,
184 |    "metadata": {
185 |     "collapsed": false
186 |    },
187 |    "outputs": [
188 |     {
189 |      "data": {
190 |       "text/plain": [
191 |        "True"
192 |       ]
193 |      },
194 |      "execution_count": 10,
195 |      "metadata": {},
196 |      "output_type": "execute_result"
197 |     }
198 |    ],
199 |    "source": [
200 |     "Par(4)"
201 |    ]
202 |   },
203 |   {
204 |    "cell_type": "code",
205 |    "execution_count": 11,
206 |    "metadata": {
207 |     "collapsed": true
208 |    },
209 |    "outputs": [],
210 |    "source": [
211 |     "first = lambda s: s[0]"
212 |    ]
213 |   },
214 |   {
215 |    "cell_type": "code",
216 |    "execution_count": 12,
217 |    "metadata": {
218 |     "collapsed": false
219 |    },
220 |    "outputs": [
221 |     {
222 |      "data": {
223 |       "text/plain": [
224 |        "'P'"
225 |       ]
226 |      },
227 |      "execution_count": 12,
228 |      "metadata": {},
229 |      "output_type": "execute_result"
230 |     }
231 |    ],
232 |    "source": [
233 |     "first('Python')"
234 |    ]
235 |   },
236 |   {
237 |    "cell_type": "code",
238 |    "execution_count": 13,
239 |    "metadata": {
240 |     "collapsed": true
241 |    },
242 |    "outputs": [],
243 |    "source": [
244 |     "reverso = lambda s: s[::-1]"
245 |    ]
246 |   },
247 |   {
248 |    "cell_type": "code",
249 |    "execution_count": 14,
250 |    "metadata": {
251 |     "collapsed": false
252 |    },
253 |    "outputs": [
254 |     {
255 |      "data": {
256 |       "text/plain": [
257 |        "'nohtyP'"
258 |       ]
259 |      },
260 |      "execution_count": 14,
261 |      "metadata": {},
262 |      "output_type": "execute_result"
263 |     }
264 |    ],
265 |    "source": [
266 |     "reverso('Python')"
267 |    ]
268 |   },
269 |   {
270 |    "cell_type": "code",
271 |    "execution_count": 15,
272 |    "metadata": {
273 |     "collapsed": true
274 |    },
275 |    "outputs": [],
276 |    "source": [
277 |     "addNum = lambda x,y : x+y"
278 |    ]
279 |   },
280 |   {
281 |    "cell_type": "code",
282 |    "execution_count": 16,
283 |    "metadata": {
284 |     "collapsed": false
285 |    },
286 |    "outputs": [
287 |     {
288 |      "data": {
289 |       "text/plain": [
290 |        "5"
291 |       ]
292 |      },
293 |      "execution_count": 16,
294 |      "metadata": {},
295 |      "output_type": "execute_result"
296 |     }
297 |    ],
298 |    "source": [
299 |     "addNum(2,3)"
300 |    ]
301 |   },
302 |   {
303 |    "cell_type": "markdown",
304 |    "metadata": {},
305 |    "source": [
306 |     "# Fim"
307 |    ]
308 |   },
309 |   {
310 |    "cell_type": "markdown",
311 |    "metadata": {},
312 |    "source": [
313 |     "### Obrigado - Data Science Academy - <a href=http://facebook.com/dsacademy>facebook.com/dsacademybr</a>"
314 |    ]
315 |   }
316 |  ],
317 |  "metadata": {
318 |   "kernelspec": {
319 |    "display_name": "Python 3",
320 |    "language": "python",
321 |    "name": "python3"
322 |   },
323 |   "language_info": {
324 |    "codemirror_mode": {
325 |     "name": "ipython",
326 |     "version": 3
327 |    },
328 |    "file_extension": ".py",
329 |    "mimetype": "text/x-python",
330 |    "name": "python",
331 |    "nbconvert_exporter": "python",
332 |    "pygments_lexer": "ipython3",
333 |    "version": "3.5.1"
334 |   }
335 |  },
336 |  "nbformat": 4,
337 |  "nbformat_minor": 0
338 | }
339 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo04/DSA-Python-Capítulo4-Métodos.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# <font color='blue'>Data Science Academy - Python Fundamentos - Capítulo 4</font>\n",
  8 |     "\n",
  9 |     "## Download: http://github.com/dsacademybr"
 10 |    ]
 11 |   },
 12 |   {
 13 |    "cell_type": "markdown",
 14 |    "metadata": {},
 15 |    "source": [
 16 |     "# Métodos"
 17 |    ]
 18 |   },
 19 |   {
 20 |    "cell_type": "code",
 21 |    "execution_count": 1,
 22 |    "metadata": {
 23 |     "collapsed": true
 24 |    },
 25 |    "outputs": [],
 26 |    "source": [
 27 |     "# Criando uma lista\n",
 28 |     "lst = [100, -2, 12, 65, 0]"
 29 |    ]
 30 |   },
 31 |   {
 32 |    "cell_type": "code",
 33 |    "execution_count": 2,
 34 |    "metadata": {
 35 |     "collapsed": true
 36 |    },
 37 |    "outputs": [],
 38 |    "source": [
 39 |     "# Usando um método do objeto lista\n",
 40 |     "lst.append(10)"
 41 |    ]
 42 |   },
 43 |   {
 44 |    "cell_type": "code",
 45 |    "execution_count": 3,
 46 |    "metadata": {
 47 |     "collapsed": false
 48 |    },
 49 |    "outputs": [
 50 |     {
 51 |      "data": {
 52 |       "text/plain": [
 53 |        "[100, -2, 12, 65, 0, 10]"
 54 |       ]
 55 |      },
 56 |      "execution_count": 3,
 57 |      "metadata": {},
 58 |      "output_type": "execute_result"
 59 |     }
 60 |    ],
 61 |    "source": [
 62 |     "# Imprimindo a lista\n",
 63 |     "lst"
 64 |    ]
 65 |   },
 66 |   {
 67 |    "cell_type": "code",
 68 |    "execution_count": 4,
 69 |    "metadata": {
 70 |     "collapsed": false
 71 |    },
 72 |    "outputs": [
 73 |     {
 74 |      "data": {
 75 |       "text/plain": [
 76 |        "1"
 77 |       ]
 78 |      },
 79 |      "execution_count": 4,
 80 |      "metadata": {},
 81 |      "output_type": "execute_result"
 82 |     }
 83 |    ],
 84 |    "source": [
 85 |     "# Usando um método do objeto lista\n",
 86 |     "lst.count(10)"
 87 |    ]
 88 |   },
 89 |   {
 90 |    "cell_type": "code",
 91 |    "execution_count": 5,
 92 |    "metadata": {
 93 |     "collapsed": false
 94 |    },
 95 |    "outputs": [
 96 |     {
 97 |      "name": "stdout",
 98 |      "output_type": "stream",
 99 |      "text": [
100 |       "Help on built-in function count:\n",
101 |       "\n",
102 |       "count(...) method of builtins.list instance\n",
103 |       "    L.count(value) -> integer -- return number of occurrences of value\n",
104 |       "\n"
105 |      ]
106 |     }
107 |    ],
108 |    "source": [
109 |     "# A função help() explica como utilizar cada método de um objeto\n",
110 |     "help(lst.count)"
111 |    ]
112 |   },
113 |   {
114 |    "cell_type": "code",
115 |    "execution_count": 6,
116 |    "metadata": {
117 |     "collapsed": false
118 |    },
119 |    "outputs": [
120 |     {
121 |      "data": {
122 |       "text/plain": [
123 |        "['__add__',\n",
124 |        " '__class__',\n",
125 |        " '__contains__',\n",
126 |        " '__delattr__',\n",
127 |        " '__delitem__',\n",
128 |        " '__dir__',\n",
129 |        " '__doc__',\n",
130 |        " '__eq__',\n",
131 |        " '__format__',\n",
132 |        " '__ge__',\n",
133 |        " '__getattribute__',\n",
134 |        " '__getitem__',\n",
135 |        " '__gt__',\n",
136 |        " '__hash__',\n",
137 |        " '__iadd__',\n",
138 |        " '__imul__',\n",
139 |        " '__init__',\n",
140 |        " '__iter__',\n",
141 |        " '__le__',\n",
142 |        " '__len__',\n",
143 |        " '__lt__',\n",
144 |        " '__mul__',\n",
145 |        " '__ne__',\n",
146 |        " '__new__',\n",
147 |        " '__reduce__',\n",
148 |        " '__reduce_ex__',\n",
149 |        " '__repr__',\n",
150 |        " '__reversed__',\n",
151 |        " '__rmul__',\n",
152 |        " '__setattr__',\n",
153 |        " '__setitem__',\n",
154 |        " '__sizeof__',\n",
155 |        " '__str__',\n",
156 |        " '__subclasshook__',\n",
157 |        " 'append',\n",
158 |        " 'clear',\n",
159 |        " 'copy',\n",
160 |        " 'count',\n",
161 |        " 'extend',\n",
162 |        " 'index',\n",
163 |        " 'insert',\n",
164 |        " 'pop',\n",
165 |        " 'remove',\n",
166 |        " 'reverse',\n",
167 |        " 'sort']"
168 |       ]
169 |      },
170 |      "execution_count": 6,
171 |      "metadata": {},
172 |      "output_type": "execute_result"
173 |     }
174 |    ],
175 |    "source": [
176 |     "# A função dir() mostra todos os métodos e atributos de um objeto\n",
177 |     "dir(lst)"
178 |    ]
179 |   },
180 |   {
181 |    "cell_type": "code",
182 |    "execution_count": 7,
183 |    "metadata": {
184 |     "collapsed": true
185 |    },
186 |    "outputs": [],
187 |    "source": [
188 |     "a = 'Isso é uma string'"
189 |    ]
190 |   },
191 |   {
192 |    "cell_type": "code",
193 |    "execution_count": 8,
194 |    "metadata": {
195 |     "collapsed": false
196 |    },
197 |    "outputs": [
198 |     {
199 |      "name": "stdout",
200 |      "output_type": "stream",
201 |      "text": [
202 |       "['Isso', 'é', 'uma', 'string']\n"
203 |      ]
204 |     }
205 |    ],
206 |    "source": [
207 |     "# O método de um objeto pode ser chamado dentro de uma função, como print()\n",
208 |     "print (a.split())"
209 |    ]
210 |   },
211 |   {
212 |    "cell_type": "markdown",
213 |    "metadata": {},
214 |    "source": [
215 |     "# Fim"
216 |    ]
217 |   },
218 |   {
219 |    "cell_type": "markdown",
220 |    "metadata": {},
221 |    "source": [
222 |     "### Obrigado - Data Science Academy - <a href=http://facebook.com/dsacademy>facebook.com/dsacademybr</a>"
223 |    ]
224 |   }
225 |  ],
226 |  "metadata": {
227 |   "kernelspec": {
228 |    "display_name": "Python 3",
229 |    "language": "python",
230 |    "name": "python3"
231 |   },
232 |   "language_info": {
233 |    "codemirror_mode": {
234 |     "name": "ipython",
235 |     "version": 3
236 |    },
237 |    "file_extension": ".py",
238 |    "mimetype": "text/x-python",
239 |    "name": "python",
240 |    "nbconvert_exporter": "python",
241 |    "pygments_lexer": "ipython3",
242 |    "version": "3.5.1"
243 |   }
244 |  },
245 |  "nbformat": 4,
246 |  "nbformat_minor": 0
247 | }
248 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo05/DSA-Python-Capítulo5-Classes.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# <font color='blue'>Data Science Academy - Python Fundamentos - Capítulo 5</font>\n",
  8 |     "\n",
  9 |     "## Download: http://github.com/dsacademybr"
 10 |    ]
 11 |   },
 12 |   {
 13 |    "cell_type": "markdown",
 14 |    "metadata": {},
 15 |    "source": [
 16 |     "## Classes"
 17 |    ]
 18 |   },
 19 |   {
 20 |    "cell_type": "markdown",
 21 |    "metadata": {},
 22 |    "source": [
 23 |     "Para criar uma classe, utiliza-se a palavra reservada class. O nome da sua classe segue a mesma convenção de nomes\n",
 24 |     "para criação de funções e variáveis, mas normalmente se usa a primeira letra maiúscula em cada palavra no nome da \n",
 25 |     "classe."
 26 |    ]
 27 |   },
 28 |   {
 29 |    "cell_type": "code",
 30 |    "execution_count": 1,
 31 |    "metadata": {
 32 |     "collapsed": true
 33 |    },
 34 |    "outputs": [],
 35 |    "source": [
 36 |     "# Criando uma classe chamada Livro\n",
 37 |     "class Livro():\n",
 38 |     "    \n",
 39 |     "    # Este método vai inicializar cada objeto criado a partir desta classe\n",
 40 |     "    # O nome deste método é __init__\n",
 41 |     "    # (self) é uma referência a cada atributo de um objeto criado a partir \n",
 42 |     "    # desta classe\n",
 43 |     "    def __init__(self):\n",
 44 |     "        \n",
 45 |     "        # Atributos de cada objeto criado a partir desta classe. O self \n",
 46 |     "        # indica que estes são atributos dos objetos\n",
 47 |     "        self.titulo = 'O Monge e o Executivo'\n",
 48 |     "        self.isbn = 9988888\n",
 49 |     "        print(\"Construtor chamado para criar um objeto desta classe\")\n",
 50 |     "        \n",
 51 |     "    # Métodos são funções, que recebem como parâmetro atributos do \n",
 52 |     "    # objeto criado    \n",
 53 |     "    def imprime(self):\n",
 54 |     "        print(\"Foi criado o livro %s e ISBN %d\" %(self.titulo, self.isbn))"
 55 |    ]
 56 |   },
 57 |   {
 58 |    "cell_type": "code",
 59 |    "execution_count": 2,
 60 |    "metadata": {
 61 |     "collapsed": false
 62 |    },
 63 |    "outputs": [
 64 |     {
 65 |      "name": "stdout",
 66 |      "output_type": "stream",
 67 |      "text": [
 68 |       "Construtor chamado para criar um objeto desta classe\n"
 69 |      ]
 70 |     }
 71 |    ],
 72 |    "source": [
 73 |     "# Criando uma instância da classe Livro\n",
 74 |     "Livro1 = Livro()"
 75 |    ]
 76 |   },
 77 |   {
 78 |    "cell_type": "code",
 79 |    "execution_count": 3,
 80 |    "metadata": {
 81 |     "collapsed": false
 82 |    },
 83 |    "outputs": [
 84 |     {
 85 |      "data": {
 86 |       "text/plain": [
 87 |        "__main__.Livro"
 88 |       ]
 89 |      },
 90 |      "execution_count": 3,
 91 |      "metadata": {},
 92 |      "output_type": "execute_result"
 93 |     }
 94 |    ],
 95 |    "source": [
 96 |     "# Tipo do Objeto Livro1\n",
 97 |     "type(Livro1)"
 98 |    ]
 99 |   },
100 |   {
101 |    "cell_type": "code",
102 |    "execution_count": 4,
103 |    "metadata": {
104 |     "collapsed": false
105 |    },
106 |    "outputs": [
107 |     {
108 |      "data": {
109 |       "text/plain": [
110 |        "'O Monge e o Executivo'"
111 |       ]
112 |      },
113 |      "execution_count": 4,
114 |      "metadata": {},
115 |      "output_type": "execute_result"
116 |     }
117 |    ],
118 |    "source": [
119 |     "# Atributo do objeto Livro1\n",
120 |     "Livro1.titulo"
121 |    ]
122 |   },
123 |   {
124 |    "cell_type": "code",
125 |    "execution_count": 5,
126 |    "metadata": {
127 |     "collapsed": false
128 |    },
129 |    "outputs": [
130 |     {
131 |      "name": "stdout",
132 |      "output_type": "stream",
133 |      "text": [
134 |       "Foi criado o livro O Monge e o Executivo e ISBN 9988888\n"
135 |      ]
136 |     }
137 |    ],
138 |    "source": [
139 |     "# Método do objeto Livro1\n",
140 |     "Livro1.imprime()"
141 |    ]
142 |   },
143 |   {
144 |    "cell_type": "code",
145 |    "execution_count": 6,
146 |    "metadata": {
147 |     "collapsed": false
148 |    },
149 |    "outputs": [],
150 |    "source": [
151 |     "# Criando a classe Livro com parâmetros no método construtor\n",
152 |     "class Livro():\n",
153 |     "    def __init__(self, titulo, isbn):\n",
154 |     "        self.titulo = titulo\n",
155 |     "        self.isbn = isbn\n",
156 |     "        print(\"Construtor chamado para criar um objeto desta classe\")\n",
157 |     "        \n",
158 |     "    def imprime(self, titulo, isbn):\n",
159 |     "        print(\"Este é o livro %s e ISBN %d\" %(titulo, isbn))"
160 |    ]
161 |   },
162 |   {
163 |    "cell_type": "code",
164 |    "execution_count": 7,
165 |    "metadata": {
166 |     "collapsed": false
167 |    },
168 |    "outputs": [
169 |     {
170 |      "name": "stdout",
171 |      "output_type": "stream",
172 |      "text": [
173 |       "Construtor chamado para criar um objeto desta classe\n"
174 |      ]
175 |     }
176 |    ],
177 |    "source": [
178 |     "# Criando o objeto Livro2 que é uma instância da classe Livro\n",
179 |     "Livro2 = Livro(\"A Menina que Roubava Livros\", 77886611)"
180 |    ]
181 |   },
182 |   {
183 |    "cell_type": "code",
184 |    "execution_count": 8,
185 |    "metadata": {
186 |     "collapsed": false
187 |    },
188 |    "outputs": [
189 |     {
190 |      "data": {
191 |       "text/plain": [
192 |        "'A Menina que Roubava Livros'"
193 |       ]
194 |      },
195 |      "execution_count": 8,
196 |      "metadata": {},
197 |      "output_type": "execute_result"
198 |     }
199 |    ],
200 |    "source": [
201 |     "Livro2.titulo"
202 |    ]
203 |   },
204 |   {
205 |    "cell_type": "code",
206 |    "execution_count": 9,
207 |    "metadata": {
208 |     "collapsed": false
209 |    },
210 |    "outputs": [
211 |     {
212 |      "name": "stdout",
213 |      "output_type": "stream",
214 |      "text": [
215 |       "Este é o livro A Menina que Roubava Livros e ISBN 77886611\n"
216 |      ]
217 |     }
218 |    ],
219 |    "source": [
220 |     "# Método do objeto Livro2\n",
221 |     "Livro2.imprime(\"A Menina que Roubava Livros\", 77886611)"
222 |    ]
223 |   },
224 |   {
225 |    "cell_type": "code",
226 |    "execution_count": 10,
227 |    "metadata": {
228 |     "collapsed": true
229 |    },
230 |    "outputs": [],
231 |    "source": [
232 |     "# Criando a classe cachorro\n",
233 |     "class Cachorro():\n",
234 |     "    def __init__(self, raça):\n",
235 |     "        self.raça = raça\n",
236 |     "        print(\"Construtor chamado para criar um objeto desta classe\")"
237 |    ]
238 |   },
239 |   {
240 |    "cell_type": "code",
241 |    "execution_count": 11,
242 |    "metadata": {
243 |     "collapsed": false
244 |    },
245 |    "outputs": [
246 |     {
247 |      "name": "stdout",
248 |      "output_type": "stream",
249 |      "text": [
250 |       "Construtor chamado para criar um objeto desta classe\n"
251 |      ]
252 |     }
253 |    ],
254 |    "source": [
255 |     "# Criando um objeto a partir da classe cachorro\n",
256 |     "Rex = Cachorro(raça='Labrador')"
257 |    ]
258 |   },
259 |   {
260 |    "cell_type": "code",
261 |    "execution_count": 12,
262 |    "metadata": {
263 |     "collapsed": false
264 |    },
265 |    "outputs": [
266 |     {
267 |      "name": "stdout",
268 |      "output_type": "stream",
269 |      "text": [
270 |       "Construtor chamado para criar um objeto desta classe\n"
271 |      ]
272 |     }
273 |    ],
274 |    "source": [
275 |     "# Criando um objeto a partir da classe cachorro\n",
276 |     "Golias = Cachorro(raça='Huskie')"
277 |    ]
278 |   },
279 |   {
280 |    "cell_type": "code",
281 |    "execution_count": 13,
282 |    "metadata": {
283 |     "collapsed": false
284 |    },
285 |    "outputs": [
286 |     {
287 |      "data": {
288 |       "text/plain": [
289 |        "'Labrador'"
290 |       ]
291 |      },
292 |      "execution_count": 13,
293 |      "metadata": {},
294 |      "output_type": "execute_result"
295 |     }
296 |    ],
297 |    "source": [
298 |     "# Atributo da classe cachorro, utilizado pelo objeto criado\n",
299 |     "Rex.raça"
300 |    ]
301 |   },
302 |   {
303 |    "cell_type": "code",
304 |    "execution_count": 14,
305 |    "metadata": {
306 |     "collapsed": false
307 |    },
308 |    "outputs": [
309 |     {
310 |      "data": {
311 |       "text/plain": [
312 |        "'Huskie'"
313 |       ]
314 |      },
315 |      "execution_count": 14,
316 |      "metadata": {},
317 |      "output_type": "execute_result"
318 |     }
319 |    ],
320 |    "source": [
321 |     "# Atributo da classe cachorro, utilizado pelo objeto criado\n",
322 |     "Golias.raça"
323 |    ]
324 |   },
325 |   {
326 |    "cell_type": "markdown",
327 |    "metadata": {},
328 |    "source": [
329 |     "# Fim"
330 |    ]
331 |   },
332 |   {
333 |    "cell_type": "markdown",
334 |    "metadata": {},
335 |    "source": [
336 |     "### Obrigado - Data Science Academy - <a href=http://facebook.com/dsacademy>facebook.com/dsacademybr</a>"
337 |    ]
338 |   }
339 |  ],
340 |  "metadata": {
341 |   "kernelspec": {
342 |    "display_name": "Python 3",
343 |    "language": "python",
344 |    "name": "python3"
345 |   },
346 |   "language_info": {
347 |    "codemirror_mode": {
348 |     "name": "ipython",
349 |     "version": 3
350 |    },
351 |    "file_extension": ".py",
352 |    "mimetype": "text/x-python",
353 |    "name": "python",
354 |    "nbconvert_exporter": "python",
355 |    "pygments_lexer": "ipython3",
356 |    "version": "3.5.1"
357 |   }
358 |  },
359 |  "nbformat": 4,
360 |  "nbformat_minor": 0
361 | }
362 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo05/DSA-Python-Capítulo5-Exercícios-Solução.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# <font color='blue'>Data Science Academy - Python Fundamentos - Capítulo 5</font>\n",
  8 |     "\n",
  9 |     "## Download: http://github.com/dsacademybr"
 10 |    ]
 11 |   },
 12 |   {
 13 |    "cell_type": "markdown",
 14 |    "metadata": {},
 15 |    "source": [
 16 |     "## Exercícios"
 17 |    ]
 18 |   },
 19 |   {
 20 |    "cell_type": "code",
 21 |    "execution_count": 1,
 22 |    "metadata": {
 23 |     "collapsed": false
 24 |    },
 25 |    "outputs": [
 26 |     {
 27 |      "name": "stdout",
 28 |      "output_type": "stream",
 29 |      "text": [
 30 |       "10 34\n",
 31 |       "22 78\n"
 32 |      ]
 33 |     }
 34 |    ],
 35 |    "source": [
 36 |     "# Exercício 1 - Crie um objeto a partir da classe abaixo, chamado roc1, passando 2 parâmetros e depois faça uma chamada\n",
 37 |     "# aos atributos e métodos\n",
 38 |     "from math import sqrt\n",
 39 |     "\n",
 40 |     "class Rocket():\n",
 41 |     "     \n",
 42 |     "    def __init__(self, x=0, y=0):\n",
 43 |     "        self.x = x\n",
 44 |     "        self.y = y\n",
 45 |     "        \n",
 46 |     "    def move_rocket(self, x_increment=0, y_increment=1):\n",
 47 |     "        self.x += x_increment\n",
 48 |     "        self.y += y_increment\n",
 49 |     "        \n",
 50 |     "    def print_rocket(self):\n",
 51 |     "        print(self.x, self.y)\n",
 52 |     "        \n",
 53 |     "    \n",
 54 |     "roc1 = Rocket(10,34)\n",
 55 |     "roc1.x\n",
 56 |     "roc1.y\n",
 57 |     "roc1.print_rocket()\n",
 58 |     "roc1.move_rocket(12, 44)\n",
 59 |     "roc1.print_rocket()"
 60 |    ]
 61 |   },
 62 |   {
 63 |    "cell_type": "code",
 64 |    "execution_count": 2,
 65 |    "metadata": {
 66 |     "collapsed": false
 67 |    },
 68 |    "outputs": [
 69 |     {
 70 |      "name": "stdout",
 71 |      "output_type": "stream",
 72 |      "text": [
 73 |       "Objeto criado\n"
 74 |      ]
 75 |     },
 76 |     {
 77 |      "data": {
 78 |       "text/plain": [
 79 |        "'O usuário Pele mora na cidade Três Corações'"
 80 |       ]
 81 |      },
 82 |      "execution_count": 2,
 83 |      "metadata": {},
 84 |      "output_type": "execute_result"
 85 |     }
 86 |    ],
 87 |    "source": [
 88 |     "# Exercício 2 - Crie uma classe chamada Pessoa() com os atributos: nome, cidade, telefone e e-mail. Use pelo menos 2\n",
 89 |     "# métodos especiais na sua classe. Crie um objeto da sua classe e faça uma chamada a pelo menos um dos seus métodos\n",
 90 |     "# especiais\n",
 91 |     "class Pessoa():\n",
 92 |     "    \n",
 93 |     "    def __init__(self, nome, cidade, telefone, email):\n",
 94 |     "        self.nome = nome\n",
 95 |     "        self.cidade = cidade\n",
 96 |     "        self.telefone = telefone\n",
 97 |     "        self.email = email\n",
 98 |     "        print(\"Objeto criado\")\n",
 99 |     "        \n",
100 |     "    def __str__(self):\n",
101 |     "        return \"O usuário \" + self.nome + \" mora na cidade \" + self.cidade\n",
102 |     "\n",
103 |     "P1 = Pessoa(\"Pele\", \"Três Corações\", 99887766, \"pele@gmail.com\")\n",
104 |     "str(P1)"
105 |    ]
106 |   },
107 |   {
108 |    "cell_type": "code",
109 |    "execution_count": 3,
110 |    "metadata": {
111 |     "collapsed": false
112 |    },
113 |    "outputs": [
114 |     {
115 |      "name": "stdout",
116 |      "output_type": "stream",
117 |      "text": [
118 |       "Valores para o objeto criado: Pequeno Led 64 GB\n"
119 |      ]
120 |     }
121 |    ],
122 |    "source": [
123 |     "# Exercício 3 - Crie a classe Smartphone com 2 atributos, tamanho e interface e crie a classe MP3Player com os \n",
124 |     "# atributos capacidade. A classe MP3player deve herdar os atributos da classe Smartphone.\n",
125 |     "class Smartphone(object):\n",
126 |     "    def __init__(self, tamanho, interface):\n",
127 |     "        self.tamanho = tamanho\n",
128 |     "        self.interface = interface\n",
129 |     "        \n",
130 |     "class MP3Player(Smartphone):\n",
131 |     "    def __init__(self, capacidade, tamanho = 'Pequeno', interface = 'Led'):\n",
132 |     "        self.capacidade = capacidade\n",
133 |     "        Smartphone.__init__(self, tamanho, interface)\n",
134 |     "        \n",
135 |     "    def print_mp3player(self):\n",
136 |     "        print(\"Valores para o objeto criado: %s %s %s\"  %(self.tamanho, self.interface, self.capacidade))\n",
137 |     "    \n",
138 |     "device1 = MP3Player('64 GB')\n",
139 |     "device1.print_mp3player()"
140 |    ]
141 |   },
142 |   {
143 |    "cell_type": "markdown",
144 |    "metadata": {},
145 |    "source": [
146 |     "### FIM"
147 |    ]
148 |   },
149 |   {
150 |    "cell_type": "markdown",
151 |    "metadata": {},
152 |    "source": [
153 |     "### Obrigado - Data Science Academy - <a href=http://facebook.com/dsacademy>facebook.com/dsacademybr</a>"
154 |    ]
155 |   }
156 |  ],
157 |  "metadata": {
158 |   "kernelspec": {
159 |    "display_name": "Python 3",
160 |    "language": "python",
161 |    "name": "python3"
162 |   },
163 |   "language_info": {
164 |    "codemirror_mode": {
165 |     "name": "ipython",
166 |     "version": 3
167 |    },
168 |    "file_extension": ".py",
169 |    "mimetype": "text/x-python",
170 |    "name": "python",
171 |    "nbconvert_exporter": "python",
172 |    "pygments_lexer": "ipython3",
173 |    "version": "3.5.1"
174 |   }
175 |  },
176 |  "nbformat": 4,
177 |  "nbformat_minor": 0
178 | }
179 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo05/DSA-Python-Capítulo5-Exercícios.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# <font color='blue'>Data Science Academy - Python Fundamentos - Capítulo 5</font>\n",
  8 |     "\n",
  9 |     "## Download: http://github.com/dsacademybr"
 10 |    ]
 11 |   },
 12 |   {
 13 |    "cell_type": "markdown",
 14 |    "metadata": {},
 15 |    "source": [
 16 |     "## Exercícios"
 17 |    ]
 18 |   },
 19 |   {
 20 |    "cell_type": "code",
 21 |    "execution_count": null,
 22 |    "metadata": {
 23 |     "collapsed": false
 24 |    },
 25 |    "outputs": [],
 26 |    "source": [
 27 |     "# Exercício 1 - Crie um objeto a partir da classe abaixo, chamado roc1, passando 2 parâmetros e depois faça uma chamada\n",
 28 |     "# aos atributos e métodos\n",
 29 |     "from math import sqrt\n",
 30 |     "\n",
 31 |     "class Rocket():\n",
 32 |     "     \n",
 33 |     "    def __init__(self, x=0, y=0):\n",
 34 |     "        self.x = x\n",
 35 |     "        self.y = y\n",
 36 |     "        \n",
 37 |     "    def move_rocket(self, x_increment=0, y_increment=1):\n",
 38 |     "        self.x += x_increment\n",
 39 |     "        self.y += y_increment\n",
 40 |     "        \n",
 41 |     "    def print_rocket(self):\n",
 42 |     "        print(self.x, self.y)\n",
 43 |     "        "
 44 |    ]
 45 |   },
 46 |   {
 47 |    "cell_type": "code",
 48 |    "execution_count": null,
 49 |    "metadata": {
 50 |     "collapsed": false
 51 |    },
 52 |    "outputs": [],
 53 |    "source": [
 54 |     "# Exercício 2 - Crie uma classe chamada Pessoa() com os atributos: nome, cidade, telefone e e-mail. Use pelo menos 2\n",
 55 |     "# métodos especiais na sua classe. Crie um objeto da sua classe e faça uma chamada a pelo menos um dos seus métodos\n",
 56 |     "# especiais\n"
 57 |    ]
 58 |   },
 59 |   {
 60 |    "cell_type": "code",
 61 |    "execution_count": null,
 62 |    "metadata": {
 63 |     "collapsed": false
 64 |    },
 65 |    "outputs": [],
 66 |    "source": [
 67 |     "# Exercício 3 - Crie a classe Smartphone com 2 atributos, tamanho e interface e crie a classe MP3Player com os \n",
 68 |     "# atributos capacidade. A classe MP3player deve herdar os atributos da classe Smartphone.\n"
 69 |    ]
 70 |   },
 71 |   {
 72 |    "cell_type": "markdown",
 73 |    "metadata": {},
 74 |    "source": [
 75 |     "### FIM"
 76 |    ]
 77 |   },
 78 |   {
 79 |    "cell_type": "markdown",
 80 |    "metadata": {},
 81 |    "source": [
 82 |     "### Obrigado - Data Science Academy - <a href=http://facebook.com/dsacademy>facebook.com/dsacademybr</a>"
 83 |    ]
 84 |   }
 85 |  ],
 86 |  "metadata": {
 87 |   "kernelspec": {
 88 |    "display_name": "Python 3",
 89 |    "language": "python",
 90 |    "name": "python3"
 91 |   },
 92 |   "language_info": {
 93 |    "codemirror_mode": {
 94 |     "name": "ipython",
 95 |     "version": 3
 96 |    },
 97 |    "file_extension": ".py",
 98 |    "mimetype": "text/x-python",
 99 |    "name": "python",
100 |    "nbconvert_exporter": "python",
101 |    "pygments_lexer": "ipython3",
102 |    "version": "3.5.1"
103 |   }
104 |  },
105 |  "nbformat": 4,
106 |  "nbformat_minor": 0
107 | }
108 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo05/DSA-Python-Capítulo5-Herança.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# <font color='blue'>Data Science Academy - Python Fundamentos - Capítulo 5</font>\n",
  8 |     "\n",
  9 |     "## Download: http://github.com/dsacademybr"
 10 |    ]
 11 |   },
 12 |   {
 13 |    "cell_type": "markdown",
 14 |    "metadata": {},
 15 |    "source": [
 16 |     "## Herança"
 17 |    ]
 18 |   },
 19 |   {
 20 |    "cell_type": "code",
 21 |    "execution_count": 1,
 22 |    "metadata": {
 23 |     "collapsed": true
 24 |    },
 25 |    "outputs": [],
 26 |    "source": [
 27 |     "# Criando a classe Animal\n",
 28 |     "class Animal(object):\n",
 29 |     "    def __init__(self):\n",
 30 |     "        print (\"Animal criado\")\n",
 31 |     "\n",
 32 |     "    def Identif(self):\n",
 33 |     "        print (\"Animal\")\n",
 34 |     "\n",
 35 |     "    def comer(self):\n",
 36 |     "        print (\"Comendo\")"
 37 |    ]
 38 |   },
 39 |   {
 40 |    "cell_type": "code",
 41 |    "execution_count": 2,
 42 |    "metadata": {
 43 |     "collapsed": true
 44 |    },
 45 |    "outputs": [],
 46 |    "source": [
 47 |     "# Criando a classe Cachorro\n",
 48 |     "class Cachorro(Animal):\n",
 49 |     "    def __init__(self):\n",
 50 |     "        Animal.__init__(self)\n",
 51 |     "        print (\"Objeto Cachorro criado\")\n",
 52 |     "\n",
 53 |     "    def Identif(self):\n",
 54 |     "        print (\"Cachorro\")\n",
 55 |     "\n",
 56 |     "    def latir(self):\n",
 57 |     "        print (\"Au Au!\")"
 58 |    ]
 59 |   },
 60 |   {
 61 |    "cell_type": "code",
 62 |    "execution_count": 3,
 63 |    "metadata": {
 64 |     "collapsed": false
 65 |    },
 66 |    "outputs": [
 67 |     {
 68 |      "name": "stdout",
 69 |      "output_type": "stream",
 70 |      "text": [
 71 |       "Animal criado\n",
 72 |       "Objeto Cachorro criado\n"
 73 |      ]
 74 |     }
 75 |    ],
 76 |    "source": [
 77 |     "# Criando um objeto (Instanciando a classe)\n",
 78 |     "puppy = Cachorro()"
 79 |    ]
 80 |   },
 81 |   {
 82 |    "cell_type": "code",
 83 |    "execution_count": 4,
 84 |    "metadata": {
 85 |     "collapsed": false
 86 |    },
 87 |    "outputs": [
 88 |     {
 89 |      "name": "stdout",
 90 |      "output_type": "stream",
 91 |      "text": [
 92 |       "Cachorro\n"
 93 |      ]
 94 |     }
 95 |    ],
 96 |    "source": [
 97 |     "# Executando o método da classe Cachorro (sub classe)\n",
 98 |     "puppy.Identif()"
 99 |    ]
100 |   },
101 |   {
102 |    "cell_type": "code",
103 |    "execution_count": 5,
104 |    "metadata": {
105 |     "collapsed": false
106 |    },
107 |    "outputs": [
108 |     {
109 |      "name": "stdout",
110 |      "output_type": "stream",
111 |      "text": [
112 |       "Comendo\n"
113 |      ]
114 |     }
115 |    ],
116 |    "source": [
117 |     "# Executando o método da classe Animal (super classe)\n",
118 |     "puppy.comer()"
119 |    ]
120 |   },
121 |   {
122 |    "cell_type": "code",
123 |    "execution_count": 6,
124 |    "metadata": {
125 |     "collapsed": false
126 |    },
127 |    "outputs": [
128 |     {
129 |      "name": "stdout",
130 |      "output_type": "stream",
131 |      "text": [
132 |       "Au Au!\n"
133 |      ]
134 |     }
135 |    ],
136 |    "source": [
137 |     "# Executando o método da classe Cachorro (sub classe)\n",
138 |     "puppy.latir()"
139 |    ]
140 |   },
141 |   {
142 |    "cell_type": "markdown",
143 |    "metadata": {},
144 |    "source": [
145 |     "# Fim"
146 |    ]
147 |   },
148 |   {
149 |    "cell_type": "markdown",
150 |    "metadata": {},
151 |    "source": [
152 |     "### Obrigado - Data Science Academy - <a href=http://facebook.com/dsacademy>facebook.com/dsacademybr</a>"
153 |    ]
154 |   }
155 |  ],
156 |  "metadata": {
157 |   "kernelspec": {
158 |    "display_name": "Python 3",
159 |    "language": "python",
160 |    "name": "python3"
161 |   },
162 |   "language_info": {
163 |    "codemirror_mode": {
164 |     "name": "ipython",
165 |     "version": 3
166 |    },
167 |    "file_extension": ".py",
168 |    "mimetype": "text/x-python",
169 |    "name": "python",
170 |    "nbconvert_exporter": "python",
171 |    "pygments_lexer": "ipython3",
172 |    "version": "3.5.1"
173 |   }
174 |  },
175 |  "nbformat": 4,
176 |  "nbformat_minor": 0
177 | }
178 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo05/DSA-Python-Capítulo5-MetodosEspeciais.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# <font color='blue'>Data Science Academy - Python Fundamentos - Capítulo 5</font>"
  8 |    ]
  9 |   },
 10 |   {
 11 |    "cell_type": "markdown",
 12 |    "metadata": {},
 13 |    "source": [
 14 |     "## Métodos Especiais"
 15 |    ]
 16 |   },
 17 |   {
 18 |    "cell_type": "code",
 19 |    "execution_count": 1,
 20 |    "metadata": {
 21 |     "collapsed": true
 22 |    },
 23 |    "outputs": [],
 24 |    "source": [
 25 |     "# Criando a classe Livro\n",
 26 |     "class Livro(object):\n",
 27 |     "    def __init__(self, titulo, autor, paginas):\n",
 28 |     "        print (\"Livro criado\")\n",
 29 |     "        self.titulo = titulo\n",
 30 |     "        self.autor = autor\n",
 31 |     "        self.paginas = paginas\n",
 32 |     "                \n",
 33 |     "    def __str__(self):\n",
 34 |     "        return \"Título: %s , autor: %s, páginas: %s \" \\\n",
 35 |     "    %(self.titulo, self.autor, self.paginas)\n",
 36 |     "\n",
 37 |     "    def __len__(self):\n",
 38 |     "        return self.paginas"
 39 |    ]
 40 |   },
 41 |   {
 42 |    "cell_type": "code",
 43 |    "execution_count": 2,
 44 |    "metadata": {
 45 |     "collapsed": false
 46 |    },
 47 |    "outputs": [
 48 |     {
 49 |      "name": "stdout",
 50 |      "output_type": "stream",
 51 |      "text": [
 52 |       "Livro criado\n"
 53 |      ]
 54 |     }
 55 |    ],
 56 |    "source": [
 57 |     "livro1 = Livro(\"Os Lusíadas\", \"Luis de Camões\", 8816)"
 58 |    ]
 59 |   },
 60 |   {
 61 |    "cell_type": "code",
 62 |    "execution_count": 3,
 63 |    "metadata": {
 64 |     "collapsed": false
 65 |    },
 66 |    "outputs": [
 67 |     {
 68 |      "name": "stdout",
 69 |      "output_type": "stream",
 70 |      "text": [
 71 |       "Título: Os Lusíadas , autor: Luis de Camões, páginas: 8816 \n"
 72 |      ]
 73 |     }
 74 |    ],
 75 |    "source": [
 76 |     "# Métodos especiais\n",
 77 |     "print(livro1)"
 78 |    ]
 79 |   },
 80 |   {
 81 |    "cell_type": "code",
 82 |    "execution_count": 4,
 83 |    "metadata": {
 84 |     "collapsed": false
 85 |    },
 86 |    "outputs": [
 87 |     {
 88 |      "data": {
 89 |       "text/plain": [
 90 |        "'Título: Os Lusíadas , autor: Luis de Camões, páginas: 8816 '"
 91 |       ]
 92 |      },
 93 |      "execution_count": 4,
 94 |      "metadata": {},
 95 |      "output_type": "execute_result"
 96 |     }
 97 |    ],
 98 |    "source": [
 99 |     "str(livro1)"
100 |    ]
101 |   },
102 |   {
103 |    "cell_type": "code",
104 |    "execution_count": 5,
105 |    "metadata": {
106 |     "collapsed": false
107 |    },
108 |    "outputs": [
109 |     {
110 |      "data": {
111 |       "text/plain": [
112 |        "8816"
113 |       ]
114 |      },
115 |      "execution_count": 5,
116 |      "metadata": {},
117 |      "output_type": "execute_result"
118 |     }
119 |    ],
120 |    "source": [
121 |     "len(livro1)"
122 |    ]
123 |   },
124 |   {
125 |    "cell_type": "code",
126 |    "execution_count": 6,
127 |    "metadata": {
128 |     "collapsed": false
129 |    },
130 |    "outputs": [],
131 |    "source": [
132 |     "# Ao executar a função del para remover um atributo, o Python executa:\n",
133 |     "# livro1.__delattr__(\"paginas\")\n",
134 |     "del livro1.paginas"
135 |    ]
136 |   },
137 |   {
138 |    "cell_type": "code",
139 |    "execution_count": 7,
140 |    "metadata": {
141 |     "collapsed": false
142 |    },
143 |    "outputs": [
144 |     {
145 |      "data": {
146 |       "text/plain": [
147 |        "False"
148 |       ]
149 |      },
150 |      "execution_count": 7,
151 |      "metadata": {},
152 |      "output_type": "execute_result"
153 |     }
154 |    ],
155 |    "source": [
156 |     "hasattr(livro1, \"paginas\")"
157 |    ]
158 |   },
159 |   {
160 |    "cell_type": "markdown",
161 |    "metadata": {},
162 |    "source": [
163 |     "# Fim"
164 |    ]
165 |   },
166 |   {
167 |    "cell_type": "markdown",
168 |    "metadata": {},
169 |    "source": [
170 |     "### Obrigado - Data Science Academy - <a href=http://facebook.com/dsacademy>facebook.com/dsacademybr</a>"
171 |    ]
172 |   }
173 |  ],
174 |  "metadata": {
175 |   "kernelspec": {
176 |    "display_name": "Python 3",
177 |    "language": "python",
178 |    "name": "python3"
179 |   },
180 |   "language_info": {
181 |    "codemirror_mode": {
182 |     "name": "ipython",
183 |     "version": 3
184 |    },
185 |    "file_extension": ".py",
186 |    "mimetype": "text/x-python",
187 |    "name": "python",
188 |    "nbconvert_exporter": "python",
189 |    "pygments_lexer": "ipython3",
190 |    "version": "3.5.1"
191 |   }
192 |  },
193 |  "nbformat": 4,
194 |  "nbformat_minor": 0
195 | }
196 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo05/DSA-Python-Capítulo5-Métodos.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# <font color='blue'>Data Science Academy - Python Fundamentos - Capítulo 5</font>\n",
  8 |     "\n",
  9 |     "## Download: http://github.com/dsacademybr"
 10 |    ]
 11 |   },
 12 |   {
 13 |    "cell_type": "markdown",
 14 |    "metadata": {},
 15 |    "source": [
 16 |     "## Métodos"
 17 |    ]
 18 |   },
 19 |   {
 20 |    "cell_type": "code",
 21 |    "execution_count": 1,
 22 |    "metadata": {
 23 |     "collapsed": true
 24 |    },
 25 |    "outputs": [],
 26 |    "source": [
 27 |     "# Criando uma classe chamada Circulo\n",
 28 |     "class Circulo(object):\n",
 29 |     "    \n",
 30 |     "    # O valor de pi é constante\n",
 31 |     "    pi = 3.14\n",
 32 |     "\n",
 33 |     "    # Quando um objeto desta classe for criado, este método será executado \n",
 34 |     "    # e o valor default do raio será 5.\n",
 35 |     "    def __init__(self, raio = 5):\n",
 36 |     "        self.raio = raio \n",
 37 |     "\n",
 38 |     "    # Esse método calcula a área. Self utiliza os atributos deste mesmo \n",
 39 |     "    # objeto\n",
 40 |     "    def area(self):\n",
 41 |     "        return (self.raio * self.raio) * Circulo.pi\n",
 42 |     "\n",
 43 |     "    # Método para gerar um novo raio\n",
 44 |     "    def setRaio(self, novo_raio):\n",
 45 |     "        self.raio = novo_raio\n",
 46 |     "\n",
 47 |     "    # Método para obter o raio do círculo\n",
 48 |     "    def getRaio(self):\n",
 49 |     "        return self.raio"
 50 |    ]
 51 |   },
 52 |   {
 53 |    "cell_type": "code",
 54 |    "execution_count": 2,
 55 |    "metadata": {
 56 |     "collapsed": true
 57 |    },
 58 |    "outputs": [],
 59 |    "source": [
 60 |     "# Criando o objeto circ. Uma instância da classe Circulo()\n",
 61 |     "circ = Circulo()"
 62 |    ]
 63 |   },
 64 |   {
 65 |    "cell_type": "code",
 66 |    "execution_count": 3,
 67 |    "metadata": {
 68 |     "collapsed": false
 69 |    },
 70 |    "outputs": [
 71 |     {
 72 |      "data": {
 73 |       "text/plain": [
 74 |        "5"
 75 |       ]
 76 |      },
 77 |      "execution_count": 3,
 78 |      "metadata": {},
 79 |      "output_type": "execute_result"
 80 |     }
 81 |    ],
 82 |    "source": [
 83 |     "# Executando um método da classe Circulo\n",
 84 |     "circ.getRaio()"
 85 |    ]
 86 |   },
 87 |   {
 88 |    "cell_type": "code",
 89 |    "execution_count": 4,
 90 |    "metadata": {
 91 |     "collapsed": false
 92 |    },
 93 |    "outputs": [
 94 |     {
 95 |      "name": "stdout",
 96 |      "output_type": "stream",
 97 |      "text": [
 98 |       "O raio é:  5\n"
 99 |      ]
100 |     }
101 |    ],
102 |    "source": [
103 |     "# Imprimindo o raio\n",
104 |     "print ('O raio é: ', circ.getRaio())"
105 |    ]
106 |   },
107 |   {
108 |    "cell_type": "code",
109 |    "execution_count": 5,
110 |    "metadata": {
111 |     "collapsed": false
112 |    },
113 |    "outputs": [
114 |     {
115 |      "name": "stdout",
116 |      "output_type": "stream",
117 |      "text": [
118 |       "Area é:  78.5\n"
119 |      ]
120 |     }
121 |    ],
122 |    "source": [
123 |     "# Imprimindo a area\n",
124 |     "print ('Area é: ', circ.area())"
125 |    ]
126 |   },
127 |   {
128 |    "cell_type": "code",
129 |    "execution_count": 6,
130 |    "metadata": {
131 |     "collapsed": false
132 |    },
133 |    "outputs": [],
134 |    "source": [
135 |     "# Gerando um novo valor para o raio do círculo\n",
136 |     "circ.setRaio(3)"
137 |    ]
138 |   },
139 |   {
140 |    "cell_type": "code",
141 |    "execution_count": 7,
142 |    "metadata": {
143 |     "collapsed": false
144 |    },
145 |    "outputs": [
146 |     {
147 |      "name": "stdout",
148 |      "output_type": "stream",
149 |      "text": [
150 |       "O novo raio é:  3\n"
151 |      ]
152 |     }
153 |    ],
154 |    "source": [
155 |     "# Imprimindo o novo raio\n",
156 |     "print ('O novo raio é: ', circ.getRaio())"
157 |    ]
158 |   },
159 |   {
160 |    "cell_type": "markdown",
161 |    "metadata": {},
162 |    "source": [
163 |     "# Fim"
164 |    ]
165 |   },
166 |   {
167 |    "cell_type": "markdown",
168 |    "metadata": {},
169 |    "source": [
170 |     "### Obrigado - Data Science Academy - <a href=http://facebook.com/dsacademy>facebook.com/dsacademybr</a>"
171 |    ]
172 |   }
173 |  ],
174 |  "metadata": {
175 |   "kernelspec": {
176 |    "display_name": "Python 3",
177 |    "language": "python",
178 |    "name": "python3"
179 |   },
180 |   "language_info": {
181 |    "codemirror_mode": {
182 |     "name": "ipython",
183 |     "version": 3
184 |    },
185 |    "file_extension": ".py",
186 |    "mimetype": "text/x-python",
187 |    "name": "python",
188 |    "nbconvert_exporter": "python",
189 |    "pygments_lexer": "ipython3",
190 |    "version": "3.5.1"
191 |   }
192 |  },
193 |  "nbformat": 4,
194 |  "nbformat_minor": 0
195 | }
196 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo06/Jupyter Notebook Parte1 - Criando um Banco de Dados SQLite.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# <font color='blue'>Data Science Academy - Python Fundamentos - Capítulo 6</font>\n",
  8 |     "\n",
  9 |     "## Download: http://github.com/dsacademybr"
 10 |    ]
 11 |   },
 12 |   {
 13 |    "cell_type": "markdown",
 14 |    "metadata": {},
 15 |    "source": [
 16 |     "### Acessando Banco de Dados com Python"
 17 |    ]
 18 |   },
 19 |   {
 20 |    "cell_type": "code",
 21 |    "execution_count": 1,
 22 |    "metadata": {
 23 |     "collapsed": false
 24 |    },
 25 |    "outputs": [],
 26 |    "source": [
 27 |     "# Importando o módulo de acesso ao SQLite\n",
 28 |     "import sqlite3"
 29 |    ]
 30 |   },
 31 |   {
 32 |    "cell_type": "code",
 33 |    "execution_count": 2,
 34 |    "metadata": {
 35 |     "collapsed": false
 36 |    },
 37 |    "outputs": [],
 38 |    "source": [
 39 |     "# Cria uma conexão com o banco de dados. \n",
 40 |     "# Se o banco de dados não existir, ele é criado neste momento.\n",
 41 |     "con = sqlite3.connect('escola.db')"
 42 |    ]
 43 |   },
 44 |   {
 45 |    "cell_type": "code",
 46 |    "execution_count": 3,
 47 |    "metadata": {
 48 |     "collapsed": false
 49 |    },
 50 |    "outputs": [
 51 |     {
 52 |      "data": {
 53 |       "text/plain": [
 54 |        "sqlite3.Connection"
 55 |       ]
 56 |      },
 57 |      "execution_count": 3,
 58 |      "metadata": {},
 59 |      "output_type": "execute_result"
 60 |     }
 61 |    ],
 62 |    "source": [
 63 |     "type(con)"
 64 |    ]
 65 |   },
 66 |   {
 67 |    "cell_type": "code",
 68 |    "execution_count": 4,
 69 |    "metadata": {
 70 |     "collapsed": true
 71 |    },
 72 |    "outputs": [],
 73 |    "source": [
 74 |     "# Criando um cursor \n",
 75 |     "# (Um cursor permite percorrer todos os registros em um conjunto de dados)\n",
 76 |     "cur = con.cursor()"
 77 |    ]
 78 |   },
 79 |   {
 80 |    "cell_type": "code",
 81 |    "execution_count": 5,
 82 |    "metadata": {
 83 |     "collapsed": false
 84 |    },
 85 |    "outputs": [
 86 |     {
 87 |      "data": {
 88 |       "text/plain": [
 89 |        "sqlite3.Cursor"
 90 |       ]
 91 |      },
 92 |      "execution_count": 5,
 93 |      "metadata": {},
 94 |      "output_type": "execute_result"
 95 |     }
 96 |    ],
 97 |    "source": [
 98 |     "type(cur)"
 99 |    ]
100 |   },
101 |   {
102 |    "cell_type": "code",
103 |    "execution_count": 6,
104 |    "metadata": {
105 |     "collapsed": false
106 |    },
107 |    "outputs": [],
108 |    "source": [
109 |     "# Cria uma instrução sql\n",
110 |     "sql_create = 'create table cursos '\\\n",
111 |     "'(id integer primary key, '\\\n",
112 |     "'titulo varchar(100), '\\\n",
113 |     "'categoria varchar(140))'"
114 |    ]
115 |   },
116 |   {
117 |    "cell_type": "code",
118 |    "execution_count": 7,
119 |    "metadata": {
120 |     "collapsed": false
121 |    },
122 |    "outputs": [
123 |     {
124 |      "data": {
125 |       "text/plain": [
126 |        "<sqlite3.Cursor at 0x106807f10>"
127 |       ]
128 |      },
129 |      "execution_count": 7,
130 |      "metadata": {},
131 |      "output_type": "execute_result"
132 |     }
133 |    ],
134 |    "source": [
135 |     "# Executando a instrução sql no cursor\n",
136 |     "cur.execute(sql_create)"
137 |    ]
138 |   },
139 |   {
140 |    "cell_type": "code",
141 |    "execution_count": 8,
142 |    "metadata": {
143 |     "collapsed": true
144 |    },
145 |    "outputs": [],
146 |    "source": [
147 |     "# Criando outra sentença SQL para inserir registros\n",
148 |     "sql_insert = 'insert into cursos values (?, ?, ?)'"
149 |    ]
150 |   },
151 |   {
152 |    "cell_type": "code",
153 |    "execution_count": 9,
154 |    "metadata": {
155 |     "collapsed": false
156 |    },
157 |    "outputs": [],
158 |    "source": [
159 |     "# Dados\n",
160 |     "recset = [(1000, 'Ciência de Dados', 'Data Science'),\n",
161 |     "          (1001, 'Big Data Fundamentos', 'Big Data'),\n",
162 |     "          (1002, 'Python Fundamentos', 'Análise de Dados')]"
163 |    ]
164 |   },
165 |   {
166 |    "cell_type": "code",
167 |    "execution_count": 10,
168 |    "metadata": {
169 |     "collapsed": false
170 |    },
171 |    "outputs": [],
172 |    "source": [
173 |     "# Inserindo os registros\n",
174 |     "for rec in recset:\n",
175 |     "    cur.execute(sql_insert, rec)"
176 |    ]
177 |   },
178 |   {
179 |    "cell_type": "code",
180 |    "execution_count": 11,
181 |    "metadata": {
182 |     "collapsed": true
183 |    },
184 |    "outputs": [],
185 |    "source": [
186 |     "# Grava a transação\n",
187 |     "con.commit()"
188 |    ]
189 |   },
190 |   {
191 |    "cell_type": "code",
192 |    "execution_count": 12,
193 |    "metadata": {
194 |     "collapsed": true
195 |    },
196 |    "outputs": [],
197 |    "source": [
198 |     "# Criando outra sentença SQL para selecionar registros\n",
199 |     "sql_select = 'select * from cursos'"
200 |    ]
201 |   },
202 |   {
203 |    "cell_type": "code",
204 |    "execution_count": 13,
205 |    "metadata": {
206 |     "collapsed": false
207 |    },
208 |    "outputs": [
209 |     {
210 |      "data": {
211 |       "text/plain": [
212 |        "<sqlite3.Cursor at 0x106807f10>"
213 |       ]
214 |      },
215 |      "execution_count": 13,
216 |      "metadata": {},
217 |      "output_type": "execute_result"
218 |     }
219 |    ],
220 |    "source": [
221 |     "# Seleciona todos os registros\n",
222 |     "cur.execute(sql_select)"
223 |    ]
224 |   },
225 |   {
226 |    "cell_type": "code",
227 |    "execution_count": 14,
228 |    "metadata": {
229 |     "collapsed": false
230 |    },
231 |    "outputs": [],
232 |    "source": [
233 |     "# Recupera os resultados\n",
234 |     "dados = cur.fetchall()"
235 |    ]
236 |   },
237 |   {
238 |    "cell_type": "code",
239 |    "execution_count": 15,
240 |    "metadata": {
241 |     "collapsed": false
242 |    },
243 |    "outputs": [
244 |     {
245 |      "name": "stdout",
246 |      "output_type": "stream",
247 |      "text": [
248 |       "Curso Id: 1000, Título: Ciência de Dados, Categoria: Data Science \n",
249 |       "\n",
250 |       "Curso Id: 1001, Título: Big Data Fundamentos, Categoria: Big Data \n",
251 |       "\n",
252 |       "Curso Id: 1002, Título: Python Fundamentos, Categoria: Análise de Dados \n",
253 |       "\n"
254 |      ]
255 |     }
256 |    ],
257 |    "source": [
258 |     "# Mostra\n",
259 |     "for linha in dados:\n",
260 |     "    print ('Curso Id: %d, Título: %s, Categoria: %s \\n' % linha)"
261 |    ]
262 |   },
263 |   {
264 |    "cell_type": "code",
265 |    "execution_count": 16,
266 |    "metadata": {
267 |     "collapsed": false
268 |    },
269 |    "outputs": [],
270 |    "source": [
271 |     "# Gerando outros registros\n",
272 |     "recset = [(1003, 'Gestão de Dados com MongoDB', 'Big Data'),\n",
273 |     "          (1004, 'R Fundamentos', 'Análise de Dados')]\n",
274 |     "\n",
275 |     "# Inserindo os registros\n",
276 |     "for rec in recset:\n",
277 |     "    cur.execute(sql_insert, rec)\n",
278 |     "    \n",
279 |     "# Gravando a transação\n",
280 |     "con.commit()"
281 |    ]
282 |   },
283 |   {
284 |    "cell_type": "code",
285 |    "execution_count": 17,
286 |    "metadata": {
287 |     "collapsed": false
288 |    },
289 |    "outputs": [
290 |     {
291 |      "name": "stdout",
292 |      "output_type": "stream",
293 |      "text": [
294 |       "Curso Id: 1000, Título: Ciência de Dados, Categoria: Data Science \n",
295 |       "\n",
296 |       "Curso Id: 1001, Título: Big Data Fundamentos, Categoria: Big Data \n",
297 |       "\n",
298 |       "Curso Id: 1002, Título: Python Fundamentos, Categoria: Análise de Dados \n",
299 |       "\n",
300 |       "Curso Id: 1003, Título: Gestão de Dados com MongoDB, Categoria: Big Data \n",
301 |       "\n",
302 |       "Curso Id: 1004, Título: R Fundamentos, Categoria: Análise de Dados \n",
303 |       "\n"
304 |      ]
305 |     }
306 |    ],
307 |    "source": [
308 |     "# Seleciona todos os registros\n",
309 |     "cur.execute('select * from cursos')\n",
310 |     "\n",
311 |     "# Recupera os resultados\n",
312 |     "recset = cur.fetchall()\n",
313 |     "\n",
314 |     "# Mostra\n",
315 |     "for rec in recset:\n",
316 |     "    print ('Curso Id: %d, Título: %s, Categoria: %s \\n' % rec)"
317 |    ]
318 |   },
319 |   {
320 |    "cell_type": "code",
321 |    "execution_count": 18,
322 |    "metadata": {
323 |     "collapsed": true
324 |    },
325 |    "outputs": [],
326 |    "source": [
327 |     "# Fecha a conexão\n",
328 |     "con.close()"
329 |    ]
330 |   },
331 |   {
332 |    "cell_type": "markdown",
333 |    "metadata": {},
334 |    "source": [
335 |     "# Fim"
336 |    ]
337 |   },
338 |   {
339 |    "cell_type": "markdown",
340 |    "metadata": {},
341 |    "source": [
342 |     "### Obrigado - Data Science Academy - <a href=http://facebook.com/dsacademy>facebook.com/dsacademybr</a>"
343 |    ]
344 |   }
345 |  ],
346 |  "metadata": {
347 |   "kernelspec": {
348 |    "display_name": "Python 3",
349 |    "language": "python",
350 |    "name": "python3"
351 |   },
352 |   "language_info": {
353 |    "codemirror_mode": {
354 |     "name": "ipython",
355 |     "version": 3
356 |    },
357 |    "file_extension": ".py",
358 |    "mimetype": "text/x-python",
359 |    "name": "python",
360 |    "nbconvert_exporter": "python",
361 |    "pygments_lexer": "ipython3",
362 |    "version": "3.5.1"
363 |   }
364 |  },
365 |  "nbformat": 4,
366 |  "nbformat_minor": 0
367 | }
368 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo06/Jupyter Notebook Parte2 - Instrução Insert no SQLite.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# <font color='blue'>Data Science Academy - Python Fundamentos - Capítulo 6</font>\n",
  8 |     "\n",
  9 |     "## Download: http://github.com/dsacademybr"
 10 |    ]
 11 |   },
 12 |   {
 13 |    "cell_type": "markdown",
 14 |    "metadata": {},
 15 |    "source": [
 16 |     "### Criando o Banco de Dados e Inserindo Dados"
 17 |    ]
 18 |   },
 19 |   {
 20 |    "cell_type": "code",
 21 |    "execution_count": 1,
 22 |    "metadata": {
 23 |     "collapsed": false
 24 |    },
 25 |    "outputs": [],
 26 |    "source": [
 27 |     "import sqlite3\n",
 28 |     " \n",
 29 |     "# Criando uma conexão\n",
 30 |     "conn = sqlite3.connect('dsa.db')   \n",
 31 |     "\n",
 32 |     "# Criando um cursor\n",
 33 |     "c = conn.cursor()\n",
 34 |     " \n",
 35 |     "# Função para criar uma tabela\n",
 36 |     "def create_table():\n",
 37 |     "    c.execute('CREATE TABLE IF NOT EXISTS produtos(id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, date TEXT, '\\\n",
 38 |     "              'prod_name TEXT, valor REAL)')\n",
 39 |     "    \n",
 40 |     "# Função para inserir uma linha\n",
 41 |     "def data_insert():\n",
 42 |     "    c.execute(\"INSERT INTO produtos VALUES(10, '2016-05-02 14:32:11', 'Teclado', 90 )\")\n",
 43 |     "    conn.commit()\n",
 44 |     "    c.close()\n",
 45 |     "    conn.close()"
 46 |    ]
 47 |   },
 48 |   {
 49 |    "cell_type": "code",
 50 |    "execution_count": 2,
 51 |    "metadata": {
 52 |     "collapsed": true
 53 |    },
 54 |    "outputs": [],
 55 |    "source": [
 56 |     "# Criar tabela\n",
 57 |     "create_table()"
 58 |    ]
 59 |   },
 60 |   {
 61 |    "cell_type": "code",
 62 |    "execution_count": 3,
 63 |    "metadata": {
 64 |     "collapsed": false
 65 |    },
 66 |    "outputs": [],
 67 |    "source": [
 68 |     "# Inserir dados\n",
 69 |     "data_insert()"
 70 |    ]
 71 |   },
 72 |   {
 73 |    "cell_type": "markdown",
 74 |    "metadata": {},
 75 |    "source": [
 76 |     "# Fim"
 77 |    ]
 78 |   },
 79 |   {
 80 |    "cell_type": "markdown",
 81 |    "metadata": {},
 82 |    "source": [
 83 |     "### Obrigado - Data Science Academy - <a href=http://facebook.com/dsacademy>facebook.com/dsacademybr</a>"
 84 |    ]
 85 |   }
 86 |  ],
 87 |  "metadata": {
 88 |   "kernelspec": {
 89 |    "display_name": "Python 3",
 90 |    "language": "python",
 91 |    "name": "python3"
 92 |   },
 93 |   "language_info": {
 94 |    "codemirror_mode": {
 95 |     "name": "ipython",
 96 |     "version": 3
 97 |    },
 98 |    "file_extension": ".py",
 99 |    "mimetype": "text/x-python",
100 |    "name": "python",
101 |    "nbconvert_exporter": "python",
102 |    "pygments_lexer": "ipython3",
103 |    "version": "3.5.1"
104 |   }
105 |  },
106 |  "nbformat": 4,
107 |  "nbformat_minor": 0
108 | }
109 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo06/Jupyter Notebook Parte3 - Instrução Insert no SQLite usando Variáveis.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# <font color='blue'>Data Science Academy - Python Fundamentos - Capítulo 6</font>\n",
  8 |     "\n",
  9 |     "## Download: http://github.com/dsacademybr"
 10 |    ]
 11 |   },
 12 |   {
 13 |    "cell_type": "markdown",
 14 |    "metadata": {},
 15 |    "source": [
 16 |     "### Inserindo Dados com Variáveis"
 17 |    ]
 18 |   },
 19 |   {
 20 |    "cell_type": "code",
 21 |    "execution_count": 1,
 22 |    "metadata": {
 23 |     "collapsed": true
 24 |    },
 25 |    "outputs": [],
 26 |    "source": [
 27 |     "import sqlite3\n",
 28 |     "import random\n",
 29 |     "import time\n",
 30 |     "import datetime\n",
 31 |     " \n",
 32 |     "# Criando uma conexão\n",
 33 |     "conn = sqlite3.connect('dsa.db')   \n",
 34 |     "\n",
 35 |     "# Criando um cursor\n",
 36 |     "c = conn.cursor()\n",
 37 |     " \n",
 38 |     "# Função para criar uma tabela\n",
 39 |     "def create_table():\n",
 40 |     "    c.execute('CREATE TABLE IF NOT EXISTS produtos(id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, date TEXT, '\\\n",
 41 |     "              'prod_name TEXT, valor REAL)')\n",
 42 |     "    \n",
 43 |     "# Função para inserir uma linha\n",
 44 |     "def data_insert():\n",
 45 |     "    c.execute(\"INSERT INTO produtos VALUES('2016-05-02 12:34:45', 'Teclado', 130.00 )\")\n",
 46 |     "    conn.commit()\n",
 47 |     "    c.close()\n",
 48 |     "    conn.close()\n",
 49 |     "    \n",
 50 |     "# Usando variáveis para inserir dados    \n",
 51 |     "def data_insert_var():\n",
 52 |     "    new_date = datetime.datetime.now()\n",
 53 |     "    new_prod_name = 'Monitor'\n",
 54 |     "    new_valor = random.randrange(50,100)\n",
 55 |     "    c.execute(\"INSERT INTO produtos (date, prod_name, valor) VALUES (?, ?, ?)\", \n",
 56 |     "              (new_date, new_prod_name, new_valor))\n",
 57 |     "    conn.commit()"
 58 |    ]
 59 |   },
 60 |   {
 61 |    "cell_type": "code",
 62 |    "execution_count": 2,
 63 |    "metadata": {
 64 |     "collapsed": false
 65 |    },
 66 |    "outputs": [],
 67 |    "source": [
 68 |     "# Gerando valores e inserindo na tabela\n",
 69 |     "for i in range(10):\n",
 70 |     "    data_insert_var()\n",
 71 |     "    time.sleep(1)"
 72 |    ]
 73 |   },
 74 |   {
 75 |    "cell_type": "code",
 76 |    "execution_count": 3,
 77 |    "metadata": {
 78 |     "collapsed": true
 79 |    },
 80 |    "outputs": [],
 81 |    "source": [
 82 |     "# Encerrando a conexão\n",
 83 |     "c.close()\n",
 84 |     "conn.close()"
 85 |    ]
 86 |   },
 87 |   {
 88 |    "cell_type": "markdown",
 89 |    "metadata": {},
 90 |    "source": [
 91 |     "# Fim"
 92 |    ]
 93 |   },
 94 |   {
 95 |    "cell_type": "markdown",
 96 |    "metadata": {},
 97 |    "source": [
 98 |     "### Obrigado - Data Science Academy - <a href=http://facebook.com/dsacademy>facebook.com/dsacademybr</a>"
 99 |    ]
100 |   }
101 |  ],
102 |  "metadata": {
103 |   "kernelspec": {
104 |    "display_name": "Python 3",
105 |    "language": "python",
106 |    "name": "python3"
107 |   },
108 |   "language_info": {
109 |    "codemirror_mode": {
110 |     "name": "ipython",
111 |     "version": 3
112 |    },
113 |    "file_extension": ".py",
114 |    "mimetype": "text/x-python",
115 |    "name": "python",
116 |    "nbconvert_exporter": "python",
117 |    "pygments_lexer": "ipython3",
118 |    "version": "3.5.1"
119 |   }
120 |  },
121 |  "nbformat": 4,
122 |  "nbformat_minor": 0
123 | }
124 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo06/Jupyter Notebook Parte4 - Instrução Select no SQLite.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# <font color='blue'>Data Science Academy - Python Fundamentos - Capítulo 6</font>\n",
  8 |     "\n",
  9 |     "## Download: http://github.com/dsacademybr"
 10 |    ]
 11 |   },
 12 |   {
 13 |    "cell_type": "markdown",
 14 |    "metadata": {},
 15 |    "source": [
 16 |     "### Leitura de dados"
 17 |    ]
 18 |   },
 19 |   {
 20 |    "cell_type": "code",
 21 |    "execution_count": 1,
 22 |    "metadata": {
 23 |     "collapsed": true
 24 |    },
 25 |    "outputs": [],
 26 |    "source": [
 27 |     "import sqlite3\n",
 28 |     "import random\n",
 29 |     "import time\n",
 30 |     "import datetime\n",
 31 |     " \n",
 32 |     "# Criando uma conexão\n",
 33 |     "conn = sqlite3.connect('dsa.db')   \n",
 34 |     "\n",
 35 |     "# Criando um cursor\n",
 36 |     "c = conn.cursor()\n",
 37 |     " \n",
 38 |     "# Função para criar uma tabela\n",
 39 |     "def create_table():\n",
 40 |     "    c.execute('CREATE TABLE IF NOT EXISTS produtos(id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, date TEXT, '\\\n",
 41 |     "              'prod_name TEXT, valor REAL)')\n",
 42 |     "\n",
 43 |     "# Função para inserir uma linha\n",
 44 |     "def data_insert():\n",
 45 |     "    c.execute(\"INSERT INTO produtos VALUES(002, '02-05-2016', 'teclado', 130 )\")\n",
 46 |     "    conn.commit()\n",
 47 |     "    c.close()\n",
 48 |     "    conn.close()\n",
 49 |     "    \n",
 50 |     "# Usando variáveis para inserir dados    \n",
 51 |     "def data_insert_var():\n",
 52 |     "    new_date = datetime.datetime.now()\n",
 53 |     "    new_prod_name = 'monitor'\n",
 54 |     "    new_valor = random.randrange(50,100)\n",
 55 |     "    c.execute(\"INSERT INTO produtos (date, prod_name, valor) VALUES (?, ?, ?, ?)\", \n",
 56 |     "              (new_date, new_prod_name, new_valor))\n",
 57 |     "    conn.commit()\n",
 58 |     "    \n",
 59 |     "# Leitura de dados\n",
 60 |     "def leitura_todos_dados():\n",
 61 |     "    c.execute(\"SELECT * FROM PRODUTOS\")\n",
 62 |     "    for linha in c.fetchall():\n",
 63 |     "        print(linha)\n",
 64 |     "        \n",
 65 |     "# Leitura de registros específicos\n",
 66 |     "def leitura_registros():\n",
 67 |     "    c.execute(\"SELECT * FROM PRODUTOS WHERE valor > 60.0\")\n",
 68 |     "    for linha in c.fetchall():\n",
 69 |     "        print(linha)      \n",
 70 |     "        \n",
 71 |     "# Leitura de colunas específicos\n",
 72 |     "def leitura_colunas():\n",
 73 |     "    c.execute(\"SELECT * FROM PRODUTOS\")\n",
 74 |     "    for linha in c.fetchall():\n",
 75 |     "        print(linha[3])         \n"
 76 |    ]
 77 |   },
 78 |   {
 79 |    "cell_type": "code",
 80 |    "execution_count": 2,
 81 |    "metadata": {
 82 |     "collapsed": false
 83 |    },
 84 |    "outputs": [
 85 |     {
 86 |      "name": "stdout",
 87 |      "output_type": "stream",
 88 |      "text": [
 89 |       "(10, '2016-05-02 14:32:11', 'Teclado', 90.0)\n",
 90 |       "(11, '2016-05-23 14:13:21.779164', 'Monitor', 70.0)\n",
 91 |       "(12, '2016-05-23 14:13:22.785889', 'Monitor', 60.0)\n",
 92 |       "(13, '2016-05-23 14:13:23.791211', 'Monitor', 50.0)\n",
 93 |       "(14, '2016-05-23 14:13:24.796350', 'Monitor', 92.0)\n",
 94 |       "(15, '2016-05-23 14:13:25.802804', 'Monitor', 91.0)\n",
 95 |       "(16, '2016-05-23 14:13:26.805365', 'Monitor', 62.0)\n",
 96 |       "(17, '2016-05-23 14:13:27.810955', 'Monitor', 83.0)\n",
 97 |       "(18, '2016-05-23 14:13:28.813340', 'Monitor', 82.0)\n",
 98 |       "(19, '2016-05-23 14:13:29.819722', 'Monitor', 98.0)\n",
 99 |       "(20, '2016-05-23 14:13:30.825445', 'Monitor', 71.0)\n"
100 |      ]
101 |     }
102 |    ],
103 |    "source": [
104 |     "# Select nos dados\n",
105 |     "leitura_todos_dados()"
106 |    ]
107 |   },
108 |   {
109 |    "cell_type": "code",
110 |    "execution_count": 3,
111 |    "metadata": {
112 |     "collapsed": false
113 |    },
114 |    "outputs": [
115 |     {
116 |      "name": "stdout",
117 |      "output_type": "stream",
118 |      "text": [
119 |       "(10, '2016-05-02 14:32:11', 'Teclado', 90.0)\n",
120 |       "(11, '2016-05-23 14:13:21.779164', 'Monitor', 70.0)\n",
121 |       "(14, '2016-05-23 14:13:24.796350', 'Monitor', 92.0)\n",
122 |       "(15, '2016-05-23 14:13:25.802804', 'Monitor', 91.0)\n",
123 |       "(16, '2016-05-23 14:13:26.805365', 'Monitor', 62.0)\n",
124 |       "(17, '2016-05-23 14:13:27.810955', 'Monitor', 83.0)\n",
125 |       "(18, '2016-05-23 14:13:28.813340', 'Monitor', 82.0)\n",
126 |       "(19, '2016-05-23 14:13:29.819722', 'Monitor', 98.0)\n",
127 |       "(20, '2016-05-23 14:13:30.825445', 'Monitor', 71.0)\n"
128 |      ]
129 |     }
130 |    ],
131 |    "source": [
132 |     "# Leitura de registros específicos\n",
133 |     "leitura_registros()"
134 |    ]
135 |   },
136 |   {
137 |    "cell_type": "code",
138 |    "execution_count": 4,
139 |    "metadata": {
140 |     "collapsed": false
141 |    },
142 |    "outputs": [
143 |     {
144 |      "name": "stdout",
145 |      "output_type": "stream",
146 |      "text": [
147 |       "90.0\n",
148 |       "70.0\n",
149 |       "60.0\n",
150 |       "50.0\n",
151 |       "92.0\n",
152 |       "91.0\n",
153 |       "62.0\n",
154 |       "83.0\n",
155 |       "82.0\n",
156 |       "98.0\n",
157 |       "71.0\n"
158 |      ]
159 |     }
160 |    ],
161 |    "source": [
162 |     "# Leitura de colunas específicas\n",
163 |     "leitura_colunas()"
164 |    ]
165 |   },
166 |   {
167 |    "cell_type": "code",
168 |    "execution_count": 5,
169 |    "metadata": {
170 |     "collapsed": true
171 |    },
172 |    "outputs": [],
173 |    "source": [
174 |     "# Encerrando a conexão\n",
175 |     "c.close()\n",
176 |     "conn.close()"
177 |    ]
178 |   },
179 |   {
180 |    "cell_type": "markdown",
181 |    "metadata": {},
182 |    "source": [
183 |     "# Fim"
184 |    ]
185 |   },
186 |   {
187 |    "cell_type": "markdown",
188 |    "metadata": {},
189 |    "source": [
190 |     "### Obrigado - Data Science Academy - <a href=http://facebook.com/dsacademy>facebook.com/dsacademybr</a>"
191 |    ]
192 |   }
193 |  ],
194 |  "metadata": {
195 |   "kernelspec": {
196 |    "display_name": "Python 3",
197 |    "language": "python",
198 |    "name": "python3"
199 |   },
200 |   "language_info": {
201 |    "codemirror_mode": {
202 |     "name": "ipython",
203 |     "version": 3
204 |    },
205 |    "file_extension": ".py",
206 |    "mimetype": "text/x-python",
207 |    "name": "python",
208 |    "nbconvert_exporter": "python",
209 |    "pygments_lexer": "ipython3",
210 |    "version": "3.5.1"
211 |   }
212 |  },
213 |  "nbformat": 4,
214 |  "nbformat_minor": 0
215 | }
216 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo06/Jupyter Notebook Parte5 - Instruções Update e Delete no SQLite.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# <font color='blue'>Data Science Academy - Python Fundamentos - Capítulo 6</font>\n",
  8 |     "\n",
  9 |     "## Download: http://github.com/dsacademybr"
 10 |    ]
 11 |   },
 12 |   {
 13 |    "cell_type": "markdown",
 14 |    "metadata": {},
 15 |    "source": [
 16 |     "### Update e Delete"
 17 |    ]
 18 |   },
 19 |   {
 20 |    "cell_type": "code",
 21 |    "execution_count": 5,
 22 |    "metadata": {
 23 |     "collapsed": true
 24 |    },
 25 |    "outputs": [],
 26 |    "source": [
 27 |     "import sqlite3\n",
 28 |     "import random\n",
 29 |     "import time\n",
 30 |     "import datetime\n",
 31 |     " \n",
 32 |     "# Criando uma conexão\n",
 33 |     "conn = sqlite3.connect('dsa.db')   \n",
 34 |     "\n",
 35 |     "# Criando um cursor\n",
 36 |     "c = conn.cursor()\n",
 37 |     " \n",
 38 |     "# Função para criar uma tabela\n",
 39 |     "def create_table():\n",
 40 |     "    c.execute('CREATE TABLE IF NOT EXISTS produtos(id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, date TEXT, '\\\n",
 41 |     "              'prod_name TEXT, valor REAL)')\n",
 42 |     "      \n",
 43 |     "# Função para inserir uma linha\n",
 44 |     "def data_insert():\n",
 45 |     "    c.execute(\"INSERT INTO produtos VALUES(002, '02-05-2016', 'teclado', 130 )\")\n",
 46 |     "    conn.commit()\n",
 47 |     "    c.close()\n",
 48 |     "    conn.close()\n",
 49 |     "    \n",
 50 |     "# Usando variáveis para inserir dados    \n",
 51 |     "def data_insert_var():\n",
 52 |     "    new_date = datetime.datetime.now()\n",
 53 |     "    new_prod_name = 'monitor'\n",
 54 |     "    new_valor = random.randrange(50,100)\n",
 55 |     "    c.execute(\"INSERT INTO produtos (date, prod_name, valor) VALUES (?, ?, ?, ?)\", \n",
 56 |     "              (new_date, new_prod_name, new_valor))\n",
 57 |     "    conn.commit()\n",
 58 |     "    \n",
 59 |     "# Leitura de dados\n",
 60 |     "def leitura_todos_dados():\n",
 61 |     "    c.execute(\"SELECT * FROM PRODUTOS\")\n",
 62 |     "    for linha in c.fetchall():\n",
 63 |     "        print(linha)\n",
 64 |     "        \n",
 65 |     "# Leitura de registros específicos\n",
 66 |     "def leitura_registros():\n",
 67 |     "    c.execute(\"SELECT * FROM PRODUTOS WHERE valor > 70.0\")\n",
 68 |     "    for linha in c.fetchall():\n",
 69 |     "        print(linha)      \n",
 70 |     "        \n",
 71 |     "# Leitura de colunas específicos\n",
 72 |     "def leitura_colunas():\n",
 73 |     "    c.execute(\"SELECT * FROM PRODUTOS\")\n",
 74 |     "    for linha in c.fetchall():\n",
 75 |     "        print(linha[3])  \n",
 76 |     "        \n",
 77 |     "# Update\n",
 78 |     "def atualiza_dados():\n",
 79 |     "    c.execute(\"UPDATE produtos SET valor = 70.00 WHERE valor = 80.0\")\n",
 80 |     "    conn.commit()\n",
 81 |     "    \n",
 82 |     "# Delete\n",
 83 |     "def remove_dados():\n",
 84 |     "    c.execute(\"DELETE FROM produtos WHERE valor = 60.0\")\n",
 85 |     "    conn.commit()"
 86 |    ]
 87 |   },
 88 |   {
 89 |    "cell_type": "code",
 90 |    "execution_count": 2,
 91 |    "metadata": {
 92 |     "collapsed": false
 93 |    },
 94 |    "outputs": [],
 95 |    "source": [
 96 |     "atualiza_dados()"
 97 |    ]
 98 |   },
 99 |   {
100 |    "cell_type": "code",
101 |    "execution_count": 3,
102 |    "metadata": {
103 |     "collapsed": false
104 |    },
105 |    "outputs": [
106 |     {
107 |      "name": "stdout",
108 |      "output_type": "stream",
109 |      "text": [
110 |       "(10, '2016-05-02 14:32:11', 'Teclado', 90.0)\n",
111 |       "(11, '2016-05-23 14:13:21.779164', 'Monitor', 70.0)\n",
112 |       "(12, '2016-05-23 14:13:22.785889', 'Monitor', 60.0)\n",
113 |       "(13, '2016-05-23 14:13:23.791211', 'Monitor', 50.0)\n",
114 |       "(14, '2016-05-23 14:13:24.796350', 'Monitor', 92.0)\n",
115 |       "(15, '2016-05-23 14:13:25.802804', 'Monitor', 91.0)\n",
116 |       "(16, '2016-05-23 14:13:26.805365', 'Monitor', 62.0)\n",
117 |       "(17, '2016-05-23 14:13:27.810955', 'Monitor', 83.0)\n",
118 |       "(18, '2016-05-23 14:13:28.813340', 'Monitor', 82.0)\n",
119 |       "(19, '2016-05-23 14:13:29.819722', 'Monitor', 98.0)\n",
120 |       "(20, '2016-05-23 14:13:30.825445', 'Monitor', 71.0)\n"
121 |      ]
122 |     }
123 |    ],
124 |    "source": [
125 |     "leitura_todos_dados()"
126 |    ]
127 |   },
128 |   {
129 |    "cell_type": "code",
130 |    "execution_count": 6,
131 |    "metadata": {
132 |     "collapsed": true
133 |    },
134 |    "outputs": [],
135 |    "source": [
136 |     "remove_dados()"
137 |    ]
138 |   },
139 |   {
140 |    "cell_type": "code",
141 |    "execution_count": 7,
142 |    "metadata": {
143 |     "collapsed": false
144 |    },
145 |    "outputs": [
146 |     {
147 |      "name": "stdout",
148 |      "output_type": "stream",
149 |      "text": [
150 |       "(10, '2016-05-02 14:32:11', 'Teclado', 90.0)\n",
151 |       "(11, '2016-05-23 14:13:21.779164', 'Monitor', 70.0)\n",
152 |       "(13, '2016-05-23 14:13:23.791211', 'Monitor', 50.0)\n",
153 |       "(14, '2016-05-23 14:13:24.796350', 'Monitor', 92.0)\n",
154 |       "(15, '2016-05-23 14:13:25.802804', 'Monitor', 91.0)\n",
155 |       "(16, '2016-05-23 14:13:26.805365', 'Monitor', 62.0)\n",
156 |       "(17, '2016-05-23 14:13:27.810955', 'Monitor', 83.0)\n",
157 |       "(18, '2016-05-23 14:13:28.813340', 'Monitor', 82.0)\n",
158 |       "(19, '2016-05-23 14:13:29.819722', 'Monitor', 98.0)\n",
159 |       "(20, '2016-05-23 14:13:30.825445', 'Monitor', 71.0)\n"
160 |      ]
161 |     }
162 |    ],
163 |    "source": [
164 |     "leitura_todos_dados()"
165 |    ]
166 |   },
167 |   {
168 |    "cell_type": "markdown",
169 |    "metadata": {},
170 |    "source": [
171 |     "# Fim"
172 |    ]
173 |   },
174 |   {
175 |    "cell_type": "markdown",
176 |    "metadata": {},
177 |    "source": [
178 |     "### Obrigado - Data Science Academy - <a href=http://facebook.com/dsacademy>facebook.com/dsacademybr</a>"
179 |    ]
180 |   }
181 |  ],
182 |  "metadata": {
183 |   "kernelspec": {
184 |    "display_name": "Python 3",
185 |    "language": "python",
186 |    "name": "python3"
187 |   },
188 |   "language_info": {
189 |    "codemirror_mode": {
190 |     "name": "ipython",
191 |     "version": 3
192 |    },
193 |    "file_extension": ".py",
194 |    "mimetype": "text/x-python",
195 |    "name": "python",
196 |    "nbconvert_exporter": "python",
197 |    "pygments_lexer": "ipython3",
198 |    "version": "3.5.1"
199 |   }
200 |  },
201 |  "nbformat": 4,
202 |  "nbformat_minor": 0
203 | }
204 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo06/Jupyter Notebook Parte9 - Stream de Dados do Twitter com MongoDB, Pandas e Scikit Learn.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# <font color='blue'>Data Science Academy - Python Fundamentos - Capítulo 6</font>\n",
  8 |     "\n",
  9 |     "## Download: http://github.com/dsacademybr"
 10 |    ]
 11 |   },
 12 |   {
 13 |    "cell_type": "markdown",
 14 |    "metadata": {},
 15 |    "source": [
 16 |     "### Stream de Dados do Twitter com MongoDB, Pandas e Scikit Learn"
 17 |    ]
 18 |   },
 19 |   {
 20 |    "cell_type": "markdown",
 21 |    "metadata": {},
 22 |    "source": [
 23 |     "Para instalar o tweepy, abra um prompt de comando e digite: pip install tweepy"
 24 |    ]
 25 |   },
 26 |   {
 27 |    "cell_type": "code",
 28 |    "execution_count": null,
 29 |    "metadata": {
 30 |     "collapsed": false
 31 |    },
 32 |    "outputs": [],
 33 |    "source": [
 34 |     "# Importando os módulos Tweepy, Datetime e Json\n",
 35 |     "from tweepy.streaming import StreamListener\n",
 36 |     "from tweepy import OAuthHandler\n",
 37 |     "from tweepy import Stream\n",
 38 |     "from datetime import datetime\n",
 39 |     "import json"
 40 |    ]
 41 |   },
 42 |   {
 43 |    "cell_type": "markdown",
 44 |    "metadata": {},
 45 |    "source": [
 46 |     "Veja no E-book como criar sua API no Twitter"
 47 |    ]
 48 |   },
 49 |   {
 50 |    "cell_type": "code",
 51 |    "execution_count": null,
 52 |    "metadata": {
 53 |     "collapsed": true
 54 |    },
 55 |    "outputs": [],
 56 |    "source": [
 57 |     "# Adicione aqui sua Consumer Key\n",
 58 |     "consumer_key = \"xxxxxxxxxxxxx\""
 59 |    ]
 60 |   },
 61 |   {
 62 |    "cell_type": "code",
 63 |    "execution_count": null,
 64 |    "metadata": {
 65 |     "collapsed": true
 66 |    },
 67 |    "outputs": [],
 68 |    "source": [
 69 |     "# Adicione aqui sua Consumer Secret \n",
 70 |     "consumer_secret = \"xxxxxxxxxxxxxxx\""
 71 |    ]
 72 |   },
 73 |   {
 74 |    "cell_type": "code",
 75 |    "execution_count": null,
 76 |    "metadata": {
 77 |     "collapsed": true
 78 |    },
 79 |    "outputs": [],
 80 |    "source": [
 81 |     "# Adicione aqui seu Access Token\n",
 82 |     "access_token = \"xxxxxxxxxxxx\""
 83 |    ]
 84 |   },
 85 |   {
 86 |    "cell_type": "code",
 87 |    "execution_count": null,
 88 |    "metadata": {
 89 |     "collapsed": true
 90 |    },
 91 |    "outputs": [],
 92 |    "source": [
 93 |     "# Adicione aqui seu Access Token Secret\n",
 94 |     "access_token_secret = \"xxxxxxxxxxxxxx\""
 95 |    ]
 96 |   },
 97 |   {
 98 |    "cell_type": "code",
 99 |    "execution_count": null,
100 |    "metadata": {
101 |     "collapsed": false
102 |    },
103 |    "outputs": [],
104 |    "source": [
105 |     "# Criando as chaves de autenticação\n",
106 |     "auth = OAuthHandler(consumer_key, consumer_secret)"
107 |    ]
108 |   },
109 |   {
110 |    "cell_type": "code",
111 |    "execution_count": null,
112 |    "metadata": {
113 |     "collapsed": false
114 |    },
115 |    "outputs": [],
116 |    "source": [
117 |     "auth.set_access_token(access_token, access_token_secret)"
118 |    ]
119 |   },
120 |   {
121 |    "cell_type": "code",
122 |    "execution_count": null,
123 |    "metadata": {
124 |     "collapsed": false
125 |    },
126 |    "outputs": [],
127 |    "source": [
128 |     "# Criando uma classe para capturar os stream de dados do Twitter e \n",
129 |     "# armazenar no MongoDB\n",
130 |     "class MyListener(StreamListener):\n",
131 |     "    def on_data(self, dados):\n",
132 |     "        tweet = json.loads(dados)\n",
133 |     "        created_at = tweet[\"created_at\"]\n",
134 |     "        id_str = tweet[\"id_str\"]\n",
135 |     "        text = tweet[\"text\"]\n",
136 |     "        obj = {\"created_at\":created_at,\"id_str\":id_str,\"text\":text,}\n",
137 |     "        tweetind = col.insert_one(obj).inserted_id\n",
138 |     "        print (obj)\n",
139 |     "        return True"
140 |    ]
141 |   },
142 |   {
143 |    "cell_type": "code",
144 |    "execution_count": null,
145 |    "metadata": {
146 |     "collapsed": true
147 |    },
148 |    "outputs": [],
149 |    "source": [
150 |     "# Criando o objeto mylistener\n",
151 |     "mylistener = MyListener()"
152 |    ]
153 |   },
154 |   {
155 |    "cell_type": "code",
156 |    "execution_count": null,
157 |    "metadata": {
158 |     "collapsed": false
159 |    },
160 |    "outputs": [],
161 |    "source": [
162 |     "# Criando o objeto mystream\n",
163 |     "mystream = Stream(auth, listener = mylistener)"
164 |    ]
165 |   },
166 |   {
167 |    "cell_type": "code",
168 |    "execution_count": null,
169 |    "metadata": {
170 |     "collapsed": false
171 |    },
172 |    "outputs": [],
173 |    "source": [
174 |     "# Importando do PyMongo o módulo MongoClient\n",
175 |     "from pymongo import MongoClient   "
176 |    ]
177 |   },
178 |   {
179 |    "cell_type": "code",
180 |    "execution_count": null,
181 |    "metadata": {
182 |     "collapsed": true
183 |    },
184 |    "outputs": [],
185 |    "source": [
186 |     "# Criando a conexão ao MongoDB\n",
187 |     "client = MongoClient('localhost', 27017)"
188 |    ]
189 |   },
190 |   {
191 |    "cell_type": "code",
192 |    "execution_count": null,
193 |    "metadata": {
194 |     "collapsed": true
195 |    },
196 |    "outputs": [],
197 |    "source": [
198 |     "# Criando o banco de dados twitterdb\n",
199 |     "db = client.twitterdb"
200 |    ]
201 |   },
202 |   {
203 |    "cell_type": "code",
204 |    "execution_count": null,
205 |    "metadata": {
206 |     "collapsed": true
207 |    },
208 |    "outputs": [],
209 |    "source": [
210 |     "# Criando a collection \"col\"\n",
211 |     "col = db.tweets "
212 |    ]
213 |   },
214 |   {
215 |    "cell_type": "code",
216 |    "execution_count": null,
217 |    "metadata": {
218 |     "collapsed": true
219 |    },
220 |    "outputs": [],
221 |    "source": [
222 |     "# Criando uma lista de palavras chave para buscar nos Tweets\n",
223 |     "keywords = ['Big Data', 'Python', 'Data Mining', 'Data Science']"
224 |    ]
225 |   },
226 |   {
227 |    "cell_type": "code",
228 |    "execution_count": null,
229 |    "metadata": {
230 |     "collapsed": false
231 |    },
232 |    "outputs": [],
233 |    "source": [
234 |     "# Iniciando o filtro e gravando os tweets no MongoDB\n",
235 |     "mystream.filter(track=keywords)"
236 |    ]
237 |   },
238 |   {
239 |    "cell_type": "markdown",
240 |    "metadata": {},
241 |    "source": [
242 |     "## --> Pressione o botão Stop na barra de ferramentas para encerrar a captura dos Tweets"
243 |    ]
244 |   },
245 |   {
246 |    "cell_type": "code",
247 |    "execution_count": null,
248 |    "metadata": {
249 |     "collapsed": true
250 |    },
251 |    "outputs": [],
252 |    "source": [
253 |     "mystream.disconnect()"
254 |    ]
255 |   },
256 |   {
257 |    "cell_type": "code",
258 |    "execution_count": null,
259 |    "metadata": {
260 |     "collapsed": false
261 |    },
262 |    "outputs": [],
263 |    "source": [
264 |     "# Verificando um documento no collection\n",
265 |     "col.find_one()"
266 |    ]
267 |   },
268 |   {
269 |    "cell_type": "code",
270 |    "execution_count": null,
271 |    "metadata": {
272 |     "collapsed": false
273 |    },
274 |    "outputs": [],
275 |    "source": [
276 |     "# criando um dataset com dados retornados do MongoDB\n",
277 |     "dataset = [{\"created_at\": item[\"created_at\"],\n",
278 |     "            \"text\": item[\"text\"],\n",
279 |     "           } for item in col.find()]"
280 |    ]
281 |   },
282 |   {
283 |    "cell_type": "code",
284 |    "execution_count": null,
285 |    "metadata": {
286 |     "collapsed": true
287 |    },
288 |    "outputs": [],
289 |    "source": [
290 |     "# Importando o módulo Pandas para trabalhar com datasets em Python\n",
291 |     "import pandas as pd"
292 |    ]
293 |   },
294 |   {
295 |    "cell_type": "code",
296 |    "execution_count": null,
297 |    "metadata": {
298 |     "collapsed": false
299 |    },
300 |    "outputs": [],
301 |    "source": [
302 |     "# Criando um dataframe a partir do dataset \n",
303 |     "df = pd.DataFrame(dataset)"
304 |    ]
305 |   },
306 |   {
307 |    "cell_type": "code",
308 |    "execution_count": null,
309 |    "metadata": {
310 |     "collapsed": false
311 |    },
312 |    "outputs": [],
313 |    "source": [
314 |     "# Imprimindo o dataframe\n",
315 |     "df"
316 |    ]
317 |   },
318 |   {
319 |    "cell_type": "code",
320 |    "execution_count": null,
321 |    "metadata": {
322 |     "collapsed": false
323 |    },
324 |    "outputs": [],
325 |    "source": [
326 |     "# Importando o módulo Scikit Learn\n",
327 |     "from sklearn.feature_extraction.text import CountVectorizer"
328 |    ]
329 |   },
330 |   {
331 |    "cell_type": "code",
332 |    "execution_count": null,
333 |    "metadata": {
334 |     "collapsed": false
335 |    },
336 |    "outputs": [],
337 |    "source": [
338 |     "# Usando o método CountVectorizer para criar uma matriz de documentos\n",
339 |     "cv = CountVectorizer()\n",
340 |     "count_matrix = cv.fit_transform(df.text)"
341 |    ]
342 |   },
343 |   {
344 |    "cell_type": "code",
345 |    "execution_count": null,
346 |    "metadata": {
347 |     "collapsed": false
348 |    },
349 |    "outputs": [],
350 |    "source": [
351 |     "# Contando o número de ocorrências das principais palavras em nosso dataset\n",
352 |     "word_count = pd.DataFrame(cv.get_feature_names(), columns=[\"word\"])\n",
353 |     "word_count[\"count\"] = count_matrix.sum(axis=0).tolist()[0]\n",
354 |     "word_count = word_count.sort_values(\"count\", ascending=False).reset_index(drop=True)\n",
355 |     "word_count[:50]"
356 |    ]
357 |   },
358 |   {
359 |    "cell_type": "markdown",
360 |    "metadata": {},
361 |    "source": [
362 |     "# Fim"
363 |    ]
364 |   },
365 |   {
366 |    "cell_type": "markdown",
367 |    "metadata": {},
368 |    "source": [
369 |     "### Obrigado - Data Science Academy - <a href=http://facebook.com/dsacademy>facebook.com/dsacademybr</a>"
370 |    ]
371 |   }
372 |  ],
373 |  "metadata": {
374 |   "kernelspec": {
375 |    "display_name": "Python 3",
376 |    "language": "python",
377 |    "name": "python3"
378 |   },
379 |   "language_info": {
380 |    "codemirror_mode": {
381 |     "name": "ipython",
382 |     "version": 3
383 |    },
384 |    "file_extension": ".py",
385 |    "mimetype": "text/x-python",
386 |    "name": "python",
387 |    "nbconvert_exporter": "python",
388 |    "pygments_lexer": "ipython3",
389 |    "version": "3.5.1"
390 |   }
391 |  },
392 |  "nbformat": 4,
393 |  "nbformat_minor": 0
394 | }
395 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo06/dsa.db:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mlhoffmann/PythonFundamentos/780daf19c7063edfef1fb4f045f0b104c91cfd9a/JupyterNotebooks/Capítulo06/dsa.db


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo06/escola.db:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mlhoffmann/PythonFundamentos/780daf19c7063edfef1fb4f045f0b104c91cfd9a/JupyterNotebooks/Capítulo06/escola.db


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo07/DSA-Python-Capítulo7-Datetime.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# <font color='blue'>Data Science Academy - Python Fundamentos - Capítulo 7</font>\n",
  8 |     "\n",
  9 |     "## Download: http://github.com/dsacademybr"
 10 |    ]
 11 |   },
 12 |   {
 13 |    "cell_type": "markdown",
 14 |    "metadata": {},
 15 |    "source": [
 16 |     "## Datetime\n",
 17 |     "Esse módulo permite a manipulação de datas em Python."
 18 |    ]
 19 |   },
 20 |   {
 21 |    "cell_type": "code",
 22 |    "execution_count": 1,
 23 |    "metadata": {
 24 |     "collapsed": false
 25 |    },
 26 |    "outputs": [],
 27 |    "source": [
 28 |     "import datetime"
 29 |    ]
 30 |   },
 31 |   {
 32 |    "cell_type": "code",
 33 |    "execution_count": 3,
 34 |    "metadata": {
 35 |     "collapsed": false
 36 |    },
 37 |    "outputs": [],
 38 |    "source": [
 39 |     "agora = datetime.datetime.now()"
 40 |    ]
 41 |   },
 42 |   {
 43 |    "cell_type": "code",
 44 |    "execution_count": 4,
 45 |    "metadata": {
 46 |     "collapsed": false
 47 |    },
 48 |    "outputs": [
 49 |     {
 50 |      "data": {
 51 |       "text/plain": [
 52 |        "datetime.datetime(2016, 5, 30, 20, 16, 1, 751134)"
 53 |       ]
 54 |      },
 55 |      "execution_count": 4,
 56 |      "metadata": {},
 57 |      "output_type": "execute_result"
 58 |     }
 59 |    ],
 60 |    "source": [
 61 |     "agora"
 62 |    ]
 63 |   },
 64 |   {
 65 |    "cell_type": "code",
 66 |    "execution_count": 5,
 67 |    "metadata": {
 68 |     "collapsed": false
 69 |    },
 70 |    "outputs": [],
 71 |    "source": [
 72 |     "t = datetime.time(7, 43, 28)"
 73 |    ]
 74 |   },
 75 |   {
 76 |    "cell_type": "code",
 77 |    "execution_count": 6,
 78 |    "metadata": {
 79 |     "collapsed": false
 80 |    },
 81 |    "outputs": [
 82 |     {
 83 |      "name": "stdout",
 84 |      "output_type": "stream",
 85 |      "text": [
 86 |       "07:43:28\n"
 87 |      ]
 88 |     }
 89 |    ],
 90 |    "source": [
 91 |     "print (t)"
 92 |    ]
 93 |   },
 94 |   {
 95 |    "cell_type": "code",
 96 |    "execution_count": 7,
 97 |    "metadata": {
 98 |     "collapsed": false
 99 |    },
100 |    "outputs": [
101 |     {
102 |      "name": "stdout",
103 |      "output_type": "stream",
104 |      "text": [
105 |       "Hora  : 7\n",
106 |       "Minute: 43\n",
107 |       "Segundo: 28\n",
108 |       "Microsegundo: 0\n"
109 |      ]
110 |     }
111 |    ],
112 |    "source": [
113 |     "print ('Hora  :', t.hour)\n",
114 |     "print ('Minute:', t.minute)\n",
115 |     "print ('Segundo:', t.second)\n",
116 |     "print ('Microsegundo:', t.microsecond)"
117 |    ]
118 |   },
119 |   {
120 |    "cell_type": "code",
121 |    "execution_count": 8,
122 |    "metadata": {
123 |     "collapsed": false
124 |    },
125 |    "outputs": [
126 |     {
127 |      "name": "stdout",
128 |      "output_type": "stream",
129 |      "text": [
130 |       "00:00:00\n"
131 |      ]
132 |     }
133 |    ],
134 |    "source": [
135 |     "print(datetime.time.min)"
136 |    ]
137 |   },
138 |   {
139 |    "cell_type": "code",
140 |    "execution_count": 9,
141 |    "metadata": {
142 |     "collapsed": true
143 |    },
144 |    "outputs": [],
145 |    "source": [
146 |     "hoje = datetime.date.today()"
147 |    ]
148 |   },
149 |   {
150 |    "cell_type": "code",
151 |    "execution_count": 10,
152 |    "metadata": {
153 |     "collapsed": false
154 |    },
155 |    "outputs": [
156 |     {
157 |      "name": "stdout",
158 |      "output_type": "stream",
159 |      "text": [
160 |       "2016-05-30\n",
161 |       "ctime: Mon May 30 00:00:00 2016\n",
162 |       "Ano: 2016\n",
163 |       "Mês : 5\n",
164 |       "Dia : 30\n"
165 |      ]
166 |     }
167 |    ],
168 |    "source": [
169 |     "print (hoje)\n",
170 |     "print ('ctime:', hoje.ctime())\n",
171 |     "print ('Ano:', hoje.year)\n",
172 |     "print ('Mês :', hoje.month)\n",
173 |     "print ('Dia :', hoje.day)"
174 |    ]
175 |   },
176 |   {
177 |    "cell_type": "code",
178 |    "execution_count": 11,
179 |    "metadata": {
180 |     "collapsed": false
181 |    },
182 |    "outputs": [
183 |     {
184 |      "name": "stdout",
185 |      "output_type": "stream",
186 |      "text": [
187 |       "d1: 2015-04-28\n"
188 |      ]
189 |     }
190 |    ],
191 |    "source": [
192 |     "d1 = datetime.date(2015, 4, 28)\n",
193 |     "print ('d1:', d1)"
194 |    ]
195 |   },
196 |   {
197 |    "cell_type": "code",
198 |    "execution_count": 12,
199 |    "metadata": {
200 |     "collapsed": false
201 |    },
202 |    "outputs": [
203 |     {
204 |      "name": "stdout",
205 |      "output_type": "stream",
206 |      "text": [
207 |       "d2: 2016-04-28\n"
208 |      ]
209 |     }
210 |    ],
211 |    "source": [
212 |     "d2 = d1.replace(year=2016)\n",
213 |     "print ('d2:', d2)"
214 |    ]
215 |   },
216 |   {
217 |    "cell_type": "code",
218 |    "execution_count": 13,
219 |    "metadata": {
220 |     "collapsed": false
221 |    },
222 |    "outputs": [
223 |     {
224 |      "data": {
225 |       "text/plain": [
226 |        "datetime.timedelta(366)"
227 |       ]
228 |      },
229 |      "execution_count": 13,
230 |      "metadata": {},
231 |      "output_type": "execute_result"
232 |     }
233 |    ],
234 |    "source": [
235 |     "# Diferença em dias emtre duas datas\n",
236 |     "d2 - d1"
237 |    ]
238 |   },
239 |   {
240 |    "cell_type": "markdown",
241 |    "metadata": {},
242 |    "source": [
243 |     "# FIM"
244 |    ]
245 |   },
246 |   {
247 |    "cell_type": "markdown",
248 |    "metadata": {},
249 |    "source": [
250 |     "### Obrigado - Data Science Academy - <a href=http://facebook.com/dsacademy>facebook.com/dsacademybr</a>"
251 |    ]
252 |   }
253 |  ],
254 |  "metadata": {
255 |   "kernelspec": {
256 |    "display_name": "Python 3",
257 |    "language": "python",
258 |    "name": "python3"
259 |   },
260 |   "language_info": {
261 |    "codemirror_mode": {
262 |     "name": "ipython",
263 |     "version": 3
264 |    },
265 |    "file_extension": ".py",
266 |    "mimetype": "text/x-python",
267 |    "name": "python",
268 |    "nbconvert_exporter": "python",
269 |    "pygments_lexer": "ipython3",
270 |    "version": "3.5.1"
271 |   }
272 |  },
273 |  "nbformat": 4,
274 |  "nbformat_minor": 0
275 | }
276 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo07/DSA-Python-Capítulo7-Enumerate.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# <font color='blue'>Data Science Academy - Python Fundamentos - Capítulo 7</font>\n",
  8 |     "\n",
  9 |     "## Download: http://github.com/dsacademybr"
 10 |    ]
 11 |   },
 12 |   {
 13 |    "cell_type": "markdown",
 14 |    "metadata": {},
 15 |    "source": [
 16 |     "## Enumerate"
 17 |    ]
 18 |   },
 19 |   {
 20 |    "cell_type": "code",
 21 |    "execution_count": 1,
 22 |    "metadata": {
 23 |     "collapsed": false
 24 |    },
 25 |    "outputs": [],
 26 |    "source": [
 27 |     "# Criando uma lista\n",
 28 |     "seq = ['a','b','c']"
 29 |    ]
 30 |   },
 31 |   {
 32 |    "cell_type": "code",
 33 |    "execution_count": 2,
 34 |    "metadata": {
 35 |     "collapsed": false
 36 |    },
 37 |    "outputs": [
 38 |     {
 39 |      "data": {
 40 |       "text/plain": [
 41 |        "<enumerate at 0x105581ab0>"
 42 |       ]
 43 |      },
 44 |      "execution_count": 2,
 45 |      "metadata": {},
 46 |      "output_type": "execute_result"
 47 |     }
 48 |    ],
 49 |    "source": [
 50 |     "enumerate(seq)"
 51 |    ]
 52 |   },
 53 |   {
 54 |    "cell_type": "code",
 55 |    "execution_count": 3,
 56 |    "metadata": {
 57 |     "collapsed": false
 58 |    },
 59 |    "outputs": [
 60 |     {
 61 |      "data": {
 62 |       "text/plain": [
 63 |        "[(0, 'a'), (1, 'b'), (2, 'c')]"
 64 |       ]
 65 |      },
 66 |      "execution_count": 3,
 67 |      "metadata": {},
 68 |      "output_type": "execute_result"
 69 |     }
 70 |    ],
 71 |    "source": [
 72 |     "list(enumerate(seq))"
 73 |    ]
 74 |   },
 75 |   {
 76 |    "cell_type": "code",
 77 |    "execution_count": 4,
 78 |    "metadata": {
 79 |     "collapsed": false
 80 |    },
 81 |    "outputs": [
 82 |     {
 83 |      "name": "stdout",
 84 |      "output_type": "stream",
 85 |      "text": [
 86 |       "0 a\n",
 87 |       "1 b\n",
 88 |       "2 c\n"
 89 |      ]
 90 |     }
 91 |    ],
 92 |    "source": [
 93 |     "# Imprimindo os valores de uma lista com a função enumerate() e \n",
 94 |     "# seus respectivos índices\n",
 95 |     "for indice, valor in enumerate(seq):\n",
 96 |     "    print (indice, valor)"
 97 |    ]
 98 |   },
 99 |   {
100 |    "cell_type": "code",
101 |    "execution_count": 5,
102 |    "metadata": {
103 |     "collapsed": false
104 |    },
105 |    "outputs": [
106 |     {
107 |      "name": "stdout",
108 |      "output_type": "stream",
109 |      "text": [
110 |       "a\n",
111 |       "b\n"
112 |      ]
113 |     }
114 |    ],
115 |    "source": [
116 |     "for indice, valor in enumerate(seq):\n",
117 |     "    if indice >= 2:\n",
118 |     "        break\n",
119 |     "    else:\n",
120 |     "        print (valor)"
121 |    ]
122 |   },
123 |   {
124 |    "cell_type": "code",
125 |    "execution_count": 6,
126 |    "metadata": {
127 |     "collapsed": true
128 |    },
129 |    "outputs": [],
130 |    "source": [
131 |     "lista = ['Marketing', 'Tecnologia', 'Business']"
132 |    ]
133 |   },
134 |   {
135 |    "cell_type": "code",
136 |    "execution_count": 7,
137 |    "metadata": {
138 |     "collapsed": false
139 |    },
140 |    "outputs": [
141 |     {
142 |      "name": "stdout",
143 |      "output_type": "stream",
144 |      "text": [
145 |       "0 Marketing\n",
146 |       "1 Tecnologia\n",
147 |       "2 Business\n"
148 |      ]
149 |     }
150 |    ],
151 |    "source": [
152 |     "for i, item in enumerate(lista):\n",
153 |     "    print(i, item)"
154 |    ]
155 |   },
156 |   {
157 |    "cell_type": "code",
158 |    "execution_count": 8,
159 |    "metadata": {
160 |     "collapsed": false
161 |    },
162 |    "outputs": [
163 |     {
164 |      "name": "stdout",
165 |      "output_type": "stream",
166 |      "text": [
167 |       "0 I\n",
168 |       "1 s\n",
169 |       "2 s\n",
170 |       "3 o\n",
171 |       "4  \n",
172 |       "5 é\n",
173 |       "6  \n",
174 |       "7 u\n",
175 |       "8 m\n",
176 |       "9 a\n",
177 |       "10  \n",
178 |       "11 s\n",
179 |       "12 t\n",
180 |       "13 r\n",
181 |       "14 i\n",
182 |       "15 n\n",
183 |       "16 g\n"
184 |      ]
185 |     }
186 |    ],
187 |    "source": [
188 |     "for i, item in enumerate('Isso é uma string'):\n",
189 |     "    print(i, item)"
190 |    ]
191 |   },
192 |   {
193 |    "cell_type": "code",
194 |    "execution_count": 9,
195 |    "metadata": {
196 |     "collapsed": false
197 |    },
198 |    "outputs": [
199 |     {
200 |      "name": "stdout",
201 |      "output_type": "stream",
202 |      "text": [
203 |       "0 0\n",
204 |       "1 1\n",
205 |       "2 2\n",
206 |       "3 3\n",
207 |       "4 4\n",
208 |       "5 5\n",
209 |       "6 6\n",
210 |       "7 7\n",
211 |       "8 8\n",
212 |       "9 9\n"
213 |      ]
214 |     }
215 |    ],
216 |    "source": [
217 |     "for i, item in enumerate(range(10)):\n",
218 |     "    print(i, item)"
219 |    ]
220 |   },
221 |   {
222 |    "cell_type": "markdown",
223 |    "metadata": {},
224 |    "source": [
225 |     "# FIM"
226 |    ]
227 |   },
228 |   {
229 |    "cell_type": "markdown",
230 |    "metadata": {},
231 |    "source": [
232 |     "### Obrigado - Data Science Academy - <a href=http://facebook.com/dsacademy>facebook.com/dsacademybr</a>"
233 |    ]
234 |   }
235 |  ],
236 |  "metadata": {
237 |   "kernelspec": {
238 |    "display_name": "Python 3",
239 |    "language": "python",
240 |    "name": "python3"
241 |   },
242 |   "language_info": {
243 |    "codemirror_mode": {
244 |     "name": "ipython",
245 |     "version": 3
246 |    },
247 |    "file_extension": ".py",
248 |    "mimetype": "text/x-python",
249 |    "name": "python",
250 |    "nbconvert_exporter": "python",
251 |    "pygments_lexer": "ipython3",
252 |    "version": "3.5.1"
253 |   }
254 |  },
255 |  "nbformat": 4,
256 |  "nbformat_minor": 0
257 | }
258 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo07/DSA-Python-Capítulo7-Filter.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# <font color='blue'>Data Science Academy - Python Fundamentos - Capítulo 7</font>\n",
  8 |     "\n",
  9 |     "## Download: http://github.com/dsacademybr"
 10 |    ]
 11 |   },
 12 |   {
 13 |    "cell_type": "markdown",
 14 |    "metadata": {},
 15 |    "source": [
 16 |     "## Filter"
 17 |    ]
 18 |   },
 19 |   {
 20 |    "cell_type": "code",
 21 |    "execution_count": 1,
 22 |    "metadata": {
 23 |     "collapsed": false
 24 |    },
 25 |    "outputs": [],
 26 |    "source": [
 27 |     "# Criando uma função\n",
 28 |     "def verificaPar(num):\n",
 29 |     "    if num % 2 == 0:\n",
 30 |     "        return True\n",
 31 |     "    else:\n",
 32 |     "        return False"
 33 |    ]
 34 |   },
 35 |   {
 36 |    "cell_type": "code",
 37 |    "execution_count": 2,
 38 |    "metadata": {
 39 |     "collapsed": false
 40 |    },
 41 |    "outputs": [
 42 |     {
 43 |      "data": {
 44 |       "text/plain": [
 45 |        "False"
 46 |       ]
 47 |      },
 48 |      "execution_count": 2,
 49 |      "metadata": {},
 50 |      "output_type": "execute_result"
 51 |     }
 52 |    ],
 53 |    "source": [
 54 |     "# Chamando a função e passando um número como parâmetro. Retornará \n",
 55 |     "# Falso de for ímpar e True se for par.\n",
 56 |     "verificaPar(35)"
 57 |    ]
 58 |   },
 59 |   {
 60 |    "cell_type": "code",
 61 |    "execution_count": 3,
 62 |    "metadata": {
 63 |     "collapsed": false
 64 |    },
 65 |    "outputs": [],
 66 |    "source": [
 67 |     "lista = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]"
 68 |    ]
 69 |   },
 70 |   {
 71 |    "cell_type": "code",
 72 |    "execution_count": 4,
 73 |    "metadata": {
 74 |     "collapsed": false
 75 |    },
 76 |    "outputs": [
 77 |     {
 78 |      "data": {
 79 |       "text/plain": [
 80 |        "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]"
 81 |       ]
 82 |      },
 83 |      "execution_count": 4,
 84 |      "metadata": {},
 85 |      "output_type": "execute_result"
 86 |     }
 87 |    ],
 88 |    "source": [
 89 |     "lista"
 90 |    ]
 91 |   },
 92 |   {
 93 |    "cell_type": "code",
 94 |    "execution_count": 5,
 95 |    "metadata": {
 96 |     "collapsed": false
 97 |    },
 98 |    "outputs": [
 99 |     {
100 |      "data": {
101 |       "text/plain": [
102 |        "<filter at 0x105d8c5f8>"
103 |       ]
104 |      },
105 |      "execution_count": 5,
106 |      "metadata": {},
107 |      "output_type": "execute_result"
108 |     }
109 |    ],
110 |    "source": [
111 |     "filter(verificaPar, lista)"
112 |    ]
113 |   },
114 |   {
115 |    "cell_type": "code",
116 |    "execution_count": 6,
117 |    "metadata": {
118 |     "collapsed": false
119 |    },
120 |    "outputs": [
121 |     {
122 |      "data": {
123 |       "text/plain": [
124 |        "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]"
125 |       ]
126 |      },
127 |      "execution_count": 6,
128 |      "metadata": {},
129 |      "output_type": "execute_result"
130 |     }
131 |    ],
132 |    "source": [
133 |     "list(filter(verificaPar, lista))"
134 |    ]
135 |   },
136 |   {
137 |    "cell_type": "code",
138 |    "execution_count": 7,
139 |    "metadata": {
140 |     "collapsed": false
141 |    },
142 |    "outputs": [
143 |     {
144 |      "data": {
145 |       "text/plain": [
146 |        "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]"
147 |       ]
148 |      },
149 |      "execution_count": 7,
150 |      "metadata": {},
151 |      "output_type": "execute_result"
152 |     }
153 |    ],
154 |    "source": [
155 |     "list(filter(lambda x: x%2==0, lista))"
156 |    ]
157 |   },
158 |   {
159 |    "cell_type": "code",
160 |    "execution_count": 8,
161 |    "metadata": {
162 |     "collapsed": false
163 |    },
164 |    "outputs": [
165 |     {
166 |      "data": {
167 |       "text/plain": [
168 |        "[9, 10, 11, 12, 13, 14, 15, 16, 17, 18]"
169 |       ]
170 |      },
171 |      "execution_count": 8,
172 |      "metadata": {},
173 |      "output_type": "execute_result"
174 |     }
175 |    ],
176 |    "source": [
177 |     "list(filter(lambda num: num > 8, lista))"
178 |    ]
179 |   },
180 |   {
181 |    "cell_type": "markdown",
182 |    "metadata": {},
183 |    "source": [
184 |     "# Fim"
185 |    ]
186 |   },
187 |   {
188 |    "cell_type": "markdown",
189 |    "metadata": {},
190 |    "source": [
191 |     "### Obrigado - Data Science Academy - <a href=http://facebook.com/dsacademy>facebook.com/dsacademybr</a>"
192 |    ]
193 |   }
194 |  ],
195 |  "metadata": {
196 |   "kernelspec": {
197 |    "display_name": "Python 3",
198 |    "language": "python",
199 |    "name": "python3"
200 |   },
201 |   "language_info": {
202 |    "codemirror_mode": {
203 |     "name": "ipython",
204 |     "version": 3
205 |    },
206 |    "file_extension": ".py",
207 |    "mimetype": "text/x-python",
208 |    "name": "python",
209 |    "nbconvert_exporter": "python",
210 |    "pygments_lexer": "ipython3",
211 |    "version": "3.5.1"
212 |   }
213 |  },
214 |  "nbformat": 4,
215 |  "nbformat_minor": 0
216 | }
217 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo07/DSA-Python-Capítulo7-List Comprehensions.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {
  6 |     "collapsed": true
  7 |    },
  8 |    "source": [
  9 |     "# <font color='blue'>Data Science Academy - Python Fundamentos - Capítulo 7</font>\n",
 10 |     "\n",
 11 |     "## Download: http://github.com/dsacademybr"
 12 |    ]
 13 |   },
 14 |   {
 15 |    "cell_type": "markdown",
 16 |    "metadata": {},
 17 |    "source": [
 18 |     "## List Comprehension"
 19 |    ]
 20 |   },
 21 |   {
 22 |    "cell_type": "code",
 23 |    "execution_count": 1,
 24 |    "metadata": {
 25 |     "collapsed": true
 26 |    },
 27 |    "outputs": [],
 28 |    "source": [
 29 |     "# Retornar cada caracter em uma sequência de caracteres\n",
 30 |     "lst = [x for x in 'python']"
 31 |    ]
 32 |   },
 33 |   {
 34 |    "cell_type": "code",
 35 |    "execution_count": 2,
 36 |    "metadata": {
 37 |     "collapsed": false
 38 |    },
 39 |    "outputs": [
 40 |     {
 41 |      "data": {
 42 |       "text/plain": [
 43 |        "['p', 'y', 't', 'h', 'o', 'n']"
 44 |       ]
 45 |      },
 46 |      "execution_count": 2,
 47 |      "metadata": {},
 48 |      "output_type": "execute_result"
 49 |     }
 50 |    ],
 51 |    "source": [
 52 |     "# Check\n",
 53 |     "lst"
 54 |    ]
 55 |   },
 56 |   {
 57 |    "cell_type": "code",
 58 |    "execution_count": 3,
 59 |    "metadata": {
 60 |     "collapsed": false
 61 |    },
 62 |    "outputs": [
 63 |     {
 64 |      "data": {
 65 |       "text/plain": [
 66 |        "list"
 67 |       ]
 68 |      },
 69 |      "execution_count": 3,
 70 |      "metadata": {},
 71 |      "output_type": "execute_result"
 72 |     }
 73 |    ],
 74 |    "source": [
 75 |     "type(lst)"
 76 |    ]
 77 |   },
 78 |   {
 79 |    "cell_type": "code",
 80 |    "execution_count": 4,
 81 |    "metadata": {
 82 |     "collapsed": true
 83 |    },
 84 |    "outputs": [],
 85 |    "source": [
 86 |     "# Raiz quadrada e um range de números e retornar uma lista\n",
 87 |     "lst = [x**2 for x in range(0,11)]"
 88 |    ]
 89 |   },
 90 |   {
 91 |    "cell_type": "code",
 92 |    "execution_count": 5,
 93 |    "metadata": {
 94 |     "collapsed": false
 95 |    },
 96 |    "outputs": [
 97 |     {
 98 |      "data": {
 99 |       "text/plain": [
100 |        "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]"
101 |       ]
102 |      },
103 |      "execution_count": 5,
104 |      "metadata": {},
105 |      "output_type": "execute_result"
106 |     }
107 |    ],
108 |    "source": [
109 |     "lst"
110 |    ]
111 |   },
112 |   {
113 |    "cell_type": "code",
114 |    "execution_count": 6,
115 |    "metadata": {
116 |     "collapsed": true
117 |    },
118 |    "outputs": [],
119 |    "source": [
120 |     "# Verificar os números pares em um range de números\n",
121 |     "lst = [x for x in range(11) if x % 2 == 0]"
122 |    ]
123 |   },
124 |   {
125 |    "cell_type": "code",
126 |    "execution_count": 7,
127 |    "metadata": {
128 |     "collapsed": false
129 |    },
130 |    "outputs": [
131 |     {
132 |      "data": {
133 |       "text/plain": [
134 |        "[0, 2, 4, 6, 8, 10]"
135 |       ]
136 |      },
137 |      "execution_count": 7,
138 |      "metadata": {},
139 |      "output_type": "execute_result"
140 |     }
141 |    ],
142 |    "source": [
143 |     "lst"
144 |    ]
145 |   },
146 |   {
147 |    "cell_type": "code",
148 |    "execution_count": 8,
149 |    "metadata": {
150 |     "collapsed": false
151 |    },
152 |    "outputs": [
153 |     {
154 |      "data": {
155 |       "text/plain": [
156 |        "[32.0, 50.0, 68.18, 94.1]"
157 |       ]
158 |      },
159 |      "execution_count": 8,
160 |      "metadata": {},
161 |      "output_type": "execute_result"
162 |     }
163 |    ],
164 |    "source": [
165 |     "# Converter Celsius para Fahrenheit\n",
166 |     "celsius = [0,10,20.1,34.5]\n",
167 |     "\n",
168 |     "fahrenheit = [ ((float(9)/5)*temp + 32) for temp in celsius ]\n",
169 |     "\n",
170 |     "fahrenheit"
171 |    ]
172 |   },
173 |   {
174 |    "cell_type": "code",
175 |    "execution_count": 9,
176 |    "metadata": {
177 |     "collapsed": false
178 |    },
179 |    "outputs": [],
180 |    "source": [
181 |     "# Operações aninhadas\n",
182 |     "lst = [ x**2 for x in [x**2 for x in range(11)]]"
183 |    ]
184 |   },
185 |   {
186 |    "cell_type": "code",
187 |    "execution_count": 10,
188 |    "metadata": {
189 |     "collapsed": false
190 |    },
191 |    "outputs": [
192 |     {
193 |      "data": {
194 |       "text/plain": [
195 |        "[0, 1, 16, 81, 256, 625, 1296, 2401, 4096, 6561, 10000]"
196 |       ]
197 |      },
198 |      "execution_count": 10,
199 |      "metadata": {},
200 |      "output_type": "execute_result"
201 |     }
202 |    ],
203 |    "source": [
204 |     "lst"
205 |    ]
206 |   },
207 |   {
208 |    "cell_type": "markdown",
209 |    "metadata": {},
210 |    "source": [
211 |     "# FIM"
212 |    ]
213 |   },
214 |   {
215 |    "cell_type": "markdown",
216 |    "metadata": {},
217 |    "source": [
218 |     "### Obrigado - Data Science Academy - <a href=http://facebook.com/dsacademy>facebook.com/dsacademybr</a>"
219 |    ]
220 |   }
221 |  ],
222 |  "metadata": {
223 |   "kernelspec": {
224 |    "display_name": "Python 3",
225 |    "language": "python",
226 |    "name": "python3"
227 |   },
228 |   "language_info": {
229 |    "codemirror_mode": {
230 |     "name": "ipython",
231 |     "version": 3
232 |    },
233 |    "file_extension": ".py",
234 |    "mimetype": "text/x-python",
235 |    "name": "python",
236 |    "nbconvert_exporter": "python",
237 |    "pygments_lexer": "ipython3",
238 |    "version": "3.5.1"
239 |   }
240 |  },
241 |  "nbformat": 4,
242 |  "nbformat_minor": 0
243 | }
244 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo07/DSA-Python-Capítulo7-Map.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# <font color='blue'>Data Science Academy - Python Fundamentos - Capítulo 7</font>\n",
  8 |     "\n",
  9 |     "## Download: http://github.com/dsacademybr"
 10 |    ]
 11 |   },
 12 |   {
 13 |    "cell_type": "markdown",
 14 |    "metadata": {},
 15 |    "source": [
 16 |     "## Map"
 17 |    ]
 18 |   },
 19 |   {
 20 |    "cell_type": "code",
 21 |    "execution_count": 1,
 22 |    "metadata": {
 23 |     "collapsed": false
 24 |    },
 25 |    "outputs": [],
 26 |    "source": [
 27 |     "# Criando duas funções\n",
 28 |     "\n",
 29 |     "# Função 1 - Recebe uma temperatura como parâmetro e retorna a \n",
 30 |     "# temperatura em Fahrenheit\n",
 31 |     "def fahrenheit(T):\n",
 32 |     "    return ((float(9)/5)*T + 32)\n",
 33 |     "\n",
 34 |     "# Função 2 - Recebe uma temperatura como parâmetro e retorna a \n",
 35 |     "# temperatura em Celsius\n",
 36 |     "def celsius(T):\n",
 37 |     "    return (float(5)/9)*(T-32)"
 38 |    ]
 39 |   },
 40 |   {
 41 |    "cell_type": "code",
 42 |    "execution_count": 2,
 43 |    "metadata": {
 44 |     "collapsed": true
 45 |    },
 46 |    "outputs": [],
 47 |    "source": [
 48 |     "# Criando uma lista\n",
 49 |     "temperaturas = [0, 22.5, 40, 100]"
 50 |    ]
 51 |   },
 52 |   {
 53 |    "cell_type": "code",
 54 |    "execution_count": 3,
 55 |    "metadata": {
 56 |     "collapsed": false
 57 |    },
 58 |    "outputs": [
 59 |     {
 60 |      "data": {
 61 |       "text/plain": [
 62 |        "<map at 0x1062a7550>"
 63 |       ]
 64 |      },
 65 |      "execution_count": 3,
 66 |      "metadata": {},
 67 |      "output_type": "execute_result"
 68 |     }
 69 |    ],
 70 |    "source": [
 71 |     "# Aplicando a função a cada elemento da lista de temperaturas. \n",
 72 |     "# Em Python 3, a funçãp map() retornar um iterator\n",
 73 |     "map(fahrenheit, temperaturas)"
 74 |    ]
 75 |   },
 76 |   {
 77 |    "cell_type": "code",
 78 |    "execution_count": 4,
 79 |    "metadata": {
 80 |     "collapsed": false
 81 |    },
 82 |    "outputs": [
 83 |     {
 84 |      "data": {
 85 |       "text/plain": [
 86 |        "[32.0, 72.5, 104.0, 212.0]"
 87 |       ]
 88 |      },
 89 |      "execution_count": 4,
 90 |      "metadata": {},
 91 |      "output_type": "execute_result"
 92 |     }
 93 |    ],
 94 |    "source": [
 95 |     "# Função map() reotrnando a lista de temperaturas convertidas em Fahrenheit\n",
 96 |     "list(map(fahrenheit, temperaturas))"
 97 |    ]
 98 |   },
 99 |   {
100 |    "cell_type": "code",
101 |    "execution_count": 5,
102 |    "metadata": {
103 |     "collapsed": false
104 |    },
105 |    "outputs": [
106 |     {
107 |      "name": "stdout",
108 |      "output_type": "stream",
109 |      "text": [
110 |       "32.0\n",
111 |       "72.5\n",
112 |       "104.0\n",
113 |       "212.0\n"
114 |      ]
115 |     }
116 |    ],
117 |    "source": [
118 |     "# Usando um loop for para imprimir o resultado da função map()\n",
119 |     "for temp in map(fahrenheit, temperaturas):\n",
120 |     "    print(temp)"
121 |    ]
122 |   },
123 |   {
124 |    "cell_type": "code",
125 |    "execution_count": 6,
126 |    "metadata": {
127 |     "collapsed": false
128 |    },
129 |    "outputs": [
130 |     {
131 |      "data": {
132 |       "text/plain": [
133 |        "<map at 0x1062a7828>"
134 |       ]
135 |      },
136 |      "execution_count": 6,
137 |      "metadata": {},
138 |      "output_type": "execute_result"
139 |     }
140 |    ],
141 |    "source": [
142 |     "# Convertendo para Celsius\n",
143 |     "map(celsius, temperaturas)"
144 |    ]
145 |   },
146 |   {
147 |    "cell_type": "code",
148 |    "execution_count": 7,
149 |    "metadata": {
150 |     "collapsed": false
151 |    },
152 |    "outputs": [
153 |     {
154 |      "data": {
155 |       "text/plain": [
156 |        "[-17.77777777777778, -5.277777777777778, 4.444444444444445, 37.77777777777778]"
157 |       ]
158 |      },
159 |      "execution_count": 7,
160 |      "metadata": {},
161 |      "output_type": "execute_result"
162 |     }
163 |    ],
164 |    "source": [
165 |     "list(map(celsius, temperaturas))"
166 |    ]
167 |   },
168 |   {
169 |    "cell_type": "code",
170 |    "execution_count": 8,
171 |    "metadata": {
172 |     "collapsed": false
173 |    },
174 |    "outputs": [
175 |     {
176 |      "data": {
177 |       "text/plain": [
178 |        "<map at 0x1062a72b0>"
179 |       ]
180 |      },
181 |      "execution_count": 8,
182 |      "metadata": {},
183 |      "output_type": "execute_result"
184 |     }
185 |    ],
186 |    "source": [
187 |     "# Usando lambda\n",
188 |     "map(lambda x: (5.0/9)*(x - 32), temperaturas)"
189 |    ]
190 |   },
191 |   {
192 |    "cell_type": "code",
193 |    "execution_count": 9,
194 |    "metadata": {
195 |     "collapsed": false
196 |    },
197 |    "outputs": [
198 |     {
199 |      "data": {
200 |       "text/plain": [
201 |        "[-17.77777777777778, -5.277777777777778, 4.444444444444445, 37.77777777777778]"
202 |       ]
203 |      },
204 |      "execution_count": 9,
205 |      "metadata": {},
206 |      "output_type": "execute_result"
207 |     }
208 |    ],
209 |    "source": [
210 |     "list(map(lambda x: (5.0/9)*(x - 32), temperaturas))"
211 |    ]
212 |   },
213 |   {
214 |    "cell_type": "code",
215 |    "execution_count": 10,
216 |    "metadata": {
217 |     "collapsed": false
218 |    },
219 |    "outputs": [],
220 |    "source": [
221 |     "# Somando os elementos de 2 listas\n",
222 |     "a = [1,2,3,4]\n",
223 |     "b = [5,6,7,8]"
224 |    ]
225 |   },
226 |   {
227 |    "cell_type": "code",
228 |    "execution_count": 11,
229 |    "metadata": {
230 |     "collapsed": false
231 |    },
232 |    "outputs": [
233 |     {
234 |      "data": {
235 |       "text/plain": [
236 |        "[6, 8, 10, 12]"
237 |       ]
238 |      },
239 |      "execution_count": 11,
240 |      "metadata": {},
241 |      "output_type": "execute_result"
242 |     }
243 |    ],
244 |    "source": [
245 |     "list(map(lambda x,y:x+y, a, b))"
246 |    ]
247 |   },
248 |   {
249 |    "cell_type": "code",
250 |    "execution_count": 12,
251 |    "metadata": {
252 |     "collapsed": false
253 |    },
254 |    "outputs": [],
255 |    "source": [
256 |     "# Somando os elementos de 3 listas\n",
257 |     "a = [1,2,3,4]\n",
258 |     "b = [5,6,7,8]\n",
259 |     "c = [9,10,11,12]"
260 |    ]
261 |   },
262 |   {
263 |    "cell_type": "code",
264 |    "execution_count": 13,
265 |    "metadata": {
266 |     "collapsed": false
267 |    },
268 |    "outputs": [
269 |     {
270 |      "data": {
271 |       "text/plain": [
272 |        "[15, 18, 21, 24]"
273 |       ]
274 |      },
275 |      "execution_count": 13,
276 |      "metadata": {},
277 |      "output_type": "execute_result"
278 |     }
279 |    ],
280 |    "source": [
281 |     "list(map(lambda x,y,z:x+y+z, a, b, c))"
282 |    ]
283 |   },
284 |   {
285 |    "cell_type": "markdown",
286 |    "metadata": {},
287 |    "source": [
288 |     "# Fim"
289 |    ]
290 |   },
291 |   {
292 |    "cell_type": "markdown",
293 |    "metadata": {},
294 |    "source": [
295 |     "### Obrigado - Data Science Academy - <a href=http://facebook.com/dsacademy>facebook.com/dsacademybr</a>"
296 |    ]
297 |   }
298 |  ],
299 |  "metadata": {
300 |   "kernelspec": {
301 |    "display_name": "Python 3",
302 |    "language": "python",
303 |    "name": "python3"
304 |   },
305 |   "language_info": {
306 |    "codemirror_mode": {
307 |     "name": "ipython",
308 |     "version": 3
309 |    },
310 |    "file_extension": ".py",
311 |    "mimetype": "text/x-python",
312 |    "name": "python",
313 |    "nbconvert_exporter": "python",
314 |    "pygments_lexer": "ipython3",
315 |    "version": "3.5.1"
316 |   }
317 |  },
318 |  "nbformat": 4,
319 |  "nbformat_minor": 0
320 | }
321 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo07/DSA-Python-Capítulo7-Python-Debugger.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# <font color='blue'>Data Science Academy - Python Fundamentos - Capítulo 7</font>\n",
  8 |     "\n",
  9 |     "## Download: http://github.com/dsacademybr"
 10 |    ]
 11 |   },
 12 |   {
 13 |    "cell_type": "markdown",
 14 |    "metadata": {},
 15 |    "source": [
 16 |     "## Python Debugger"
 17 |    ]
 18 |   },
 19 |   {
 20 |    "cell_type": "code",
 21 |    "execution_count": 1,
 22 |    "metadata": {
 23 |     "collapsed": false
 24 |    },
 25 |    "outputs": [],
 26 |    "source": [
 27 |     "a = [4,5,6]\n",
 28 |     "b = 2\n",
 29 |     "c = 3"
 30 |    ]
 31 |   },
 32 |   {
 33 |    "cell_type": "code",
 34 |    "execution_count": 2,
 35 |    "metadata": {
 36 |     "collapsed": false
 37 |    },
 38 |    "outputs": [
 39 |     {
 40 |      "name": "stdout",
 41 |      "output_type": "stream",
 42 |      "text": [
 43 |       "5\n"
 44 |      ]
 45 |     }
 46 |    ],
 47 |    "source": [
 48 |     "resultado = b + c\n",
 49 |     "print (resultado)"
 50 |    ]
 51 |   },
 52 |   {
 53 |    "cell_type": "code",
 54 |    "execution_count": 3,
 55 |    "metadata": {
 56 |     "collapsed": false
 57 |    },
 58 |    "outputs": [
 59 |     {
 60 |      "ename": "TypeError",
 61 |      "evalue": "can only concatenate list (not \"int\") to list",
 62 |      "output_type": "error",
 63 |      "traceback": [
 64 |       "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
 65 |       "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
 66 |       "\u001b[0;32m<ipython-input-3-1c2cf6777bd2>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mresultado2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mresultado2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
 67 |       "\u001b[0;31mTypeError\u001b[0m: can only concatenate list (not \"int\") to list"
 68 |      ]
 69 |     }
 70 |    ],
 71 |    "source": [
 72 |     "resultado2 = a + b\n",
 73 |     "print (resultado2)"
 74 |    ]
 75 |   },
 76 |   {
 77 |    "cell_type": "code",
 78 |    "execution_count": 4,
 79 |    "metadata": {
 80 |     "collapsed": false
 81 |    },
 82 |    "outputs": [],
 83 |    "source": [
 84 |     "import pdb"
 85 |    ]
 86 |   },
 87 |   {
 88 |    "cell_type": "code",
 89 |    "execution_count": null,
 90 |    "metadata": {
 91 |     "collapsed": false
 92 |    },
 93 |    "outputs": [
 94 |     {
 95 |      "name": "stdout",
 96 |      "output_type": "stream",
 97 |      "text": [
 98 |       "5\n",
 99 |       "--Return--\n",
100 |       "> <ipython-input-5-bd74863cf262>(8)<module>()->None\n",
101 |       "-> pdb.set_trace()\n",
102 |       "(Pdb) a + b\n",
103 |       "(Pdb) [4,5,6] + 2\n",
104 |       "*** TypeError: can only concatenate list (not \"int\") to list\n"
105 |      ]
106 |     }
107 |    ],
108 |    "source": [
109 |     "a = [4,5,6]\n",
110 |     "b = 2\n",
111 |     "c = 3\n",
112 |     "\n",
113 |     "resultado = b + c\n",
114 |     "print (resultado)\n",
115 |     "\n",
116 |     "pdb.set_trace()\n",
117 |     "\n",
118 |     "resultado2 = a + b\n",
119 |     "print (resultado2)"
120 |    ]
121 |   },
122 |   {
123 |    "cell_type": "markdown",
124 |    "metadata": {},
125 |    "source": [
126 |     "# FIM"
127 |    ]
128 |   },
129 |   {
130 |    "cell_type": "markdown",
131 |    "metadata": {},
132 |    "source": [
133 |     "### Obrigado - Data Science Academy - <a href=http://facebook.com/dsacademy>facebook.com/dsacademybr</a>"
134 |    ]
135 |   }
136 |  ],
137 |  "metadata": {
138 |   "kernelspec": {
139 |    "display_name": "Python 3",
140 |    "language": "python",
141 |    "name": "python3"
142 |   },
143 |   "language_info": {
144 |    "codemirror_mode": {
145 |     "name": "ipython",
146 |     "version": 3
147 |    },
148 |    "file_extension": ".py",
149 |    "mimetype": "text/x-python",
150 |    "name": "python",
151 |    "nbconvert_exporter": "python",
152 |    "pygments_lexer": "ipython3",
153 |    "version": "3.5.1"
154 |   }
155 |  },
156 |  "nbformat": 4,
157 |  "nbformat_minor": 0
158 | }
159 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo07/DSA-Python-Capítulo7-Zip.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# <font color='blue'>Data Science Academy - Python Fundamentos - Capítulo 7</font>\n",
  8 |     "\n",
  9 |     "## Download: http://github.com/dsacademybr"
 10 |    ]
 11 |   },
 12 |   {
 13 |    "cell_type": "markdown",
 14 |    "metadata": {},
 15 |    "source": [
 16 |     "## Zip"
 17 |    ]
 18 |   },
 19 |   {
 20 |    "cell_type": "code",
 21 |    "execution_count": 1,
 22 |    "metadata": {
 23 |     "collapsed": false
 24 |    },
 25 |    "outputs": [],
 26 |    "source": [
 27 |     "# Criando duas listas\n",
 28 |     "x = [1,2,3]\n",
 29 |     "y = [4,5,6]"
 30 |    ]
 31 |   },
 32 |   {
 33 |    "cell_type": "code",
 34 |    "execution_count": 2,
 35 |    "metadata": {
 36 |     "collapsed": false
 37 |    },
 38 |    "outputs": [
 39 |     {
 40 |      "data": {
 41 |       "text/plain": [
 42 |        "<zip at 0x106858a48>"
 43 |       ]
 44 |      },
 45 |      "execution_count": 2,
 46 |      "metadata": {},
 47 |      "output_type": "execute_result"
 48 |     }
 49 |    ],
 50 |    "source": [
 51 |     "# Unindo as listas. Em Python3 retorna um iterator\n",
 52 |     "zip(x, y)"
 53 |    ]
 54 |   },
 55 |   {
 56 |    "cell_type": "code",
 57 |    "execution_count": 3,
 58 |    "metadata": {
 59 |     "collapsed": false
 60 |    },
 61 |    "outputs": [
 62 |     {
 63 |      "data": {
 64 |       "text/plain": [
 65 |        "[(1, 4), (2, 5), (3, 6)]"
 66 |       ]
 67 |      },
 68 |      "execution_count": 3,
 69 |      "metadata": {},
 70 |      "output_type": "execute_result"
 71 |     }
 72 |    ],
 73 |    "source": [
 74 |     "# Perceba que zip retorna tuplas. Neste caso, uma lista de tuplas\n",
 75 |     "list(zip(x,y))"
 76 |    ]
 77 |   },
 78 |   {
 79 |    "cell_type": "code",
 80 |    "execution_count": 4,
 81 |    "metadata": {
 82 |     "collapsed": false
 83 |    },
 84 |    "outputs": [
 85 |     {
 86 |      "data": {
 87 |       "text/plain": [
 88 |        "[('A', 'x'), ('B', 'y')]"
 89 |       ]
 90 |      },
 91 |      "execution_count": 4,
 92 |      "metadata": {},
 93 |      "output_type": "execute_result"
 94 |     }
 95 |    ],
 96 |    "source": [
 97 |     "# Atenção quando as sequências tiverem número diferente de elementos\n",
 98 |     "list(zip('ABCD', 'xy'))"
 99 |    ]
100 |   },
101 |   {
102 |    "cell_type": "code",
103 |    "execution_count": 5,
104 |    "metadata": {
105 |     "collapsed": false
106 |    },
107 |    "outputs": [],
108 |    "source": [
109 |     "# Criando duas listas\n",
110 |     "a = [1,2,3]\n",
111 |     "b = [4,5,6,7,8]"
112 |    ]
113 |   },
114 |   {
115 |    "cell_type": "code",
116 |    "execution_count": 6,
117 |    "metadata": {
118 |     "collapsed": false
119 |    },
120 |    "outputs": [
121 |     {
122 |      "data": {
123 |       "text/plain": [
124 |        "[(1, 4), (2, 5), (3, 6)]"
125 |       ]
126 |      },
127 |      "execution_count": 6,
128 |      "metadata": {},
129 |      "output_type": "execute_result"
130 |     }
131 |    ],
132 |    "source": [
133 |     "list(zip(a,b)) "
134 |    ]
135 |   },
136 |   {
137 |    "cell_type": "code",
138 |    "execution_count": 7,
139 |    "metadata": {
140 |     "collapsed": false
141 |    },
142 |    "outputs": [],
143 |    "source": [
144 |     "# Criando 2 dicionários\n",
145 |     "d1 = {'a':1,'b':2}\n",
146 |     "d2 = {'c':4,'d':5}"
147 |    ]
148 |   },
149 |   {
150 |    "cell_type": "code",
151 |    "execution_count": 8,
152 |    "metadata": {
153 |     "collapsed": false
154 |    },
155 |    "outputs": [
156 |     {
157 |      "data": {
158 |       "text/plain": [
159 |        "[('a', 'd'), ('b', 'c')]"
160 |       ]
161 |      },
162 |      "execution_count": 8,
163 |      "metadata": {},
164 |      "output_type": "execute_result"
165 |     }
166 |    ],
167 |    "source": [
168 |     "# Zip vai unir as chaves\n",
169 |     "list(zip(d1,d2))"
170 |    ]
171 |   },
172 |   {
173 |    "cell_type": "code",
174 |    "execution_count": 9,
175 |    "metadata": {
176 |     "collapsed": false
177 |    },
178 |    "outputs": [
179 |     {
180 |      "data": {
181 |       "text/plain": [
182 |        "[('a', 5), ('b', 4)]"
183 |       ]
184 |      },
185 |      "execution_count": 9,
186 |      "metadata": {},
187 |      "output_type": "execute_result"
188 |     }
189 |    ],
190 |    "source": [
191 |     "# Zip pode unir os valores (itens)\n",
192 |     "list(zip(d1, d2.values()))"
193 |    ]
194 |   },
195 |   {
196 |    "cell_type": "code",
197 |    "execution_count": 10,
198 |    "metadata": {
199 |     "collapsed": false
200 |    },
201 |    "outputs": [],
202 |    "source": [
203 |     "# Criando uma função para trocar valores entre 2 dicionários\n",
204 |     "def trocaValores(d1, d2):\n",
205 |     "    dicTemp = {}\n",
206 |     "    \n",
207 |     "    for d1key, d2val in zip(d1,d2.values()):\n",
208 |     "        dicTemp[d1key] = d2val\n",
209 |     "    \n",
210 |     "    return dicTemp"
211 |    ]
212 |   },
213 |   {
214 |    "cell_type": "code",
215 |    "execution_count": 11,
216 |    "metadata": {
217 |     "collapsed": false
218 |    },
219 |    "outputs": [
220 |     {
221 |      "data": {
222 |       "text/plain": [
223 |        "{'a': 5, 'b': 4}"
224 |       ]
225 |      },
226 |      "execution_count": 11,
227 |      "metadata": {},
228 |      "output_type": "execute_result"
229 |     }
230 |    ],
231 |    "source": [
232 |     "trocaValores(d1, d2)"
233 |    ]
234 |   },
235 |   {
236 |    "cell_type": "markdown",
237 |    "metadata": {},
238 |    "source": [
239 |     "# FIM"
240 |    ]
241 |   },
242 |   {
243 |    "cell_type": "markdown",
244 |    "metadata": {},
245 |    "source": [
246 |     "### Obrigado - Data Science Academy - <a href=http://facebook.com/dsacademy>facebook.com/dsacademybr</a>"
247 |    ]
248 |   }
249 |  ],
250 |  "metadata": {
251 |   "kernelspec": {
252 |    "display_name": "Python 3",
253 |    "language": "python",
254 |    "name": "python3"
255 |   },
256 |   "language_info": {
257 |    "codemirror_mode": {
258 |     "name": "ipython",
259 |     "version": 3
260 |    },
261 |    "file_extension": ".py",
262 |    "mimetype": "text/x-python",
263 |    "name": "python",
264 |    "nbconvert_exporter": "python",
265 |    "pygments_lexer": "ipython3",
266 |    "version": "3.5.1"
267 |   }
268 |  },
269 |  "nbformat": 4,
270 |  "nbformat_minor": 0
271 | }
272 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo07/cientista.txt:
--------------------------------------------------------------------------------
1 | Cientista de Dados é 
2 | Cientista de Dados é a profissão 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo07/dados.json:
--------------------------------------------------------------------------------
1 | {"similar": ["c", "Modula-3", "lisp"], "nome": "Guido van Rossum", "linguagem": "Python", "users": 1000000}


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo07/json_data.txt:
--------------------------------------------------------------------------------
1 | {"similar": ["c", "Modula-3", "lisp"], "nome": "Guido van Rossum", "linguagem": "Python", "users": 1000000}


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo07/logfile.txt:
--------------------------------------------------------------------------------
1 | Gravando no log...


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo07/numeros.csv:
--------------------------------------------------------------------------------
1 | primeira,segunda,terceira
2 | 55,93,76
3 | 62,14,86
4 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo07/reduce.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mlhoffmann/PythonFundamentos/780daf19c7063edfef1fb4f045f0b104c91cfd9a/JupyterNotebooks/Capítulo07/reduce.png


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo07/testandoerros.txt:
--------------------------------------------------------------------------------
1 | Gravando no arquivo


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo07/testfile.txt:
--------------------------------------------------------------------------------
1 | Gravando no arquivo


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo08/DSA-Python-Capítulo8-Matplotlib-Mapas.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# <font color='blue'>Data Science Academy - Python Fundamentos - Capítulo 8</font>\n",
  8 |     "\n",
  9 |     "## Download: http://github.com/dsacademybr"
 10 |    ]
 11 |   },
 12 |   {
 13 |    "cell_type": "markdown",
 14 |    "metadata": {},
 15 |    "source": [
 16 |     "### Matplotlib"
 17 |    ]
 18 |   },
 19 |   {
 20 |    "cell_type": "markdown",
 21 |    "metadata": {},
 22 |    "source": [
 23 |     "## Criando Mapas"
 24 |    ]
 25 |   },
 26 |   {
 27 |    "cell_type": "markdown",
 28 |    "metadata": {},
 29 |    "source": [
 30 |     "### Para usuários do Windows, executar o procedimento abaixo para instalar o basemap."
 31 |    ]
 32 |   },
 33 |   {
 34 |    "cell_type": "markdown",
 35 |    "metadata": {},
 36 |    "source": [
 37 |     "### 1- Acessar o site http://www.lfd.uci.edu/~gohlke/pythonlibs/\n",
 38 |     "### 2- Baixar o arquivo basemap-1.0.8-cp35-none-win_amd64.whl\n",
 39 |     "### 3- Colocar o arquivo no diretório de instalação do Anaconda\n",
 40 |     "### 4- No prompt de comando, nevegar até o diretório de instalação do Anaconda e executar\n",
 41 |     "### 5- pip install basemap-1.0.8-cp35-none-win_amd64.whl"
 42 |    ]
 43 |   },
 44 |   {
 45 |    "cell_type": "markdown",
 46 |    "metadata": {},
 47 |    "source": [
 48 |     "### Usuários Mac e Linux, executar: pip install basemap"
 49 |    ]
 50 |   },
 51 |   {
 52 |    "cell_type": "code",
 53 |    "execution_count": 1,
 54 |    "metadata": {
 55 |     "collapsed": true
 56 |    },
 57 |    "outputs": [],
 58 |    "source": [
 59 |     "from mpl_toolkits.basemap import Basemap\n",
 60 |     "from mpl_toolkits.mplot3d.axes3d import Axes3D\n",
 61 |     "import matplotlib.pyplot as plt"
 62 |    ]
 63 |   },
 64 |   {
 65 |    "cell_type": "code",
 66 |    "execution_count": 2,
 67 |    "metadata": {
 68 |     "collapsed": true
 69 |    },
 70 |    "outputs": [],
 71 |    "source": [
 72 |     "# Mapa do globo terrestre\n",
 73 |     "map = Basemap(projection = 'ortho', lat_0 = 0, lon_0 = 0)\n",
 74 |     "\n",
 75 |     "# Definindo a cor do globo\n",
 76 |     "map.drawmapboundary(fill_color = 'aqua')\n",
 77 |     "\n",
 78 |     "# Preenchendo a cor dos continentes\n",
 79 |     "map.fillcontinents(color = 'coral', lake_color = 'aqua')\n",
 80 |     "\n",
 81 |     "map.drawcoastlines()\n",
 82 |     "\n",
 83 |     "plt.show()\n",
 84 |     "plt.savefig('Globo.png')"
 85 |    ]
 86 |   },
 87 |   {
 88 |    "cell_type": "code",
 89 |    "execution_count": 3,
 90 |    "metadata": {
 91 |     "collapsed": false
 92 |    },
 93 |    "outputs": [],
 94 |    "source": [
 95 |     "# Mapa do globo terrestre expandido\n",
 96 |     "from mpl_toolkits.basemap import Basemap\n",
 97 |     "import matplotlib.pyplot as plt\n",
 98 |     "\n",
 99 |     "map = Basemap()\n",
100 |     "\n",
101 |     "map.drawcoastlines()\n",
102 |     "\n",
103 |     "# Mostrar e gravar\n",
104 |     "plt.show()\n",
105 |     "plt.savefig('Globo-expandido.png')"
106 |    ]
107 |   },
108 |   {
109 |    "cell_type": "code",
110 |    "execution_count": 4,
111 |    "metadata": {
112 |     "collapsed": false
113 |    },
114 |    "outputs": [],
115 |    "source": [
116 |     "# Cria um mapa usando Basemap\n",
117 |     "from mpl_toolkits.basemap import Basemap\n",
118 |     "from mpl_toolkits.mplot3d import Axes3D\n",
119 |     "from matplotlib import pyplot\n",
120 |     "from numpy import arange\n",
121 |     "\n",
122 |     "mapa = Basemap(projection = 'robin', lat_0 = -20, lon_0 = -50,\n",
123 |     "resolution = 'l', area_thresh = 1e3)\n",
124 |     "\n",
125 |     "# desenha a costa dos continentes\n",
126 |     "mapa.drawcoastlines(color='#777799')\n",
127 |     "\n",
128 |     "# Desenha as fronteiras\n",
129 |     "mapa.drawcountries(color='#ccccee')\n",
130 |     "\n",
131 |     "# Pinta os continentes\n",
132 |     "mapa.fillcontinents(color='#ddddcc')\n",
133 |     "\n",
134 |     "# Desenha os meridianos\n",
135 |     "mapa.drawmeridians(arange(0, 360, 30), color='#ccccee')\n",
136 |     "\n",
137 |     "# Desenha os paralelos\n",
138 |     "mapa.drawparallels(arange(-180, 180, 30), color='#ccccee')\n",
139 |     "\n",
140 |     "# Desenha os limites do mapa\n",
141 |     "mapa.drawmapboundary()\n",
142 |     "\n",
143 |     "# Mostrar e gravar\n",
144 |     "plt.show()\n",
145 |     "pyplot.savefig('Mapa.png', dpi=150)"
146 |    ]
147 |   },
148 |   {
149 |    "cell_type": "code",
150 |    "execution_count": 5,
151 |    "metadata": {
152 |     "collapsed": false
153 |    },
154 |    "outputs": [],
155 |    "source": [
156 |     "# Plot contour\n",
157 |     "from mpl_toolkits.basemap import Basemap\n",
158 |     "import matplotlib.pyplot as plt\n",
159 |     "import numpy as np\n",
160 |     "\n",
161 |     "# Criando o mapa base\n",
162 |     "map = Basemap(projection = 'ortho', lat_0 = 45, lon_0 = -100, resolution = 'l')\n",
163 |     "\n",
164 |     "# Definindo as linhas dos continentes\n",
165 |     "map.drawcoastlines(linewidth = 0.25)\n",
166 |     "map.drawcountries(linewidth = 0.25)\n",
167 |     "map.fillcontinents(color = 'coral', lake_color = 'aqua')\n",
168 |     "\n",
169 |     "# Desenhando os limites\n",
170 |     "map.drawmapboundary(fill_color = 'aqua')\n",
171 |     "\n",
172 |     "# Desenhando latitude e longitude\n",
173 |     "map.drawmeridians(np.arange(0,360,30))\n",
174 |     "map.drawparallels(np.arange(-90,90,30))\n",
175 |     "\n",
176 |     "# Desenhando os grids\n",
177 |     "nlats = 73; nlons = 145; delta = 2.*np.pi/(nlons-1)\n",
178 |     "lats = (0.5*np.pi-delta*np.indices((nlats,nlons))[0,:,:])\n",
179 |     "lons = (delta*np.indices((nlats,nlons))[1,:,:])\n",
180 |     "wave = 0.75*(np.sin(2.*lats)**8*np.cos(4.*lons))\n",
181 |     "mean = 0.5*np.cos(2.*lats)*((np.sin(2.*lats))**2 + 2.)\n",
182 |     "\n",
183 |     "# Projetando coordeandas.\n",
184 |     "x, y = map(lons*180./np.pi, lats*180./np.pi)\n",
185 |     "\n",
186 |     "# Dados do mapa\n",
187 |     "cs = map.contour(x,y,wave+mean,15,linewidths=1.5)\n",
188 |     "plt.title('Linhas sobre o continente')\n",
189 |     "\n",
190 |     "# Mostrar e gravar\n",
191 |     "plt.show()\n",
192 |     "pyplot.savefig('Continentes.png')"
193 |    ]
194 |   },
195 |   {
196 |    "cell_type": "code",
197 |    "execution_count": 6,
198 |    "metadata": {
199 |     "collapsed": true
200 |    },
201 |    "outputs": [],
202 |    "source": [
203 |     "# Mapas dia e noite\n",
204 |     "import numpy as np\n",
205 |     "from mpl_toolkits.basemap import Basemap\n",
206 |     "import matplotlib.pyplot as plt\n",
207 |     "from datetime import datetime\n",
208 |     "\n",
209 |     "# Projeção\n",
210 |     "map = Basemap(projection='mill',lon_0=180)\n",
211 |     "\n",
212 |     "# Linhas meridianas e paralelas.\n",
213 |     "map.drawcoastlines()\n",
214 |     "map.drawparallels(np.arange(-90,90,30),labels=[1,0,0,0])\n",
215 |     "map.drawmeridians(np.arange(map.lonmin,map.lonmax+30,60),labels=[0,0,0,1])\n",
216 |     "\n",
217 |     "# Cores\n",
218 |     "map.drawmapboundary(fill_color='aqua')\n",
219 |     "map.fillcontinents(color='coral',lake_color='aqua')\n",
220 |     "\n",
221 |     "# Sombreando as noites. Time em UTC.\n",
222 |     "date = datetime.utcnow()\n",
223 |     "CS=map.nightshade(date)\n",
224 |     "# plt.title('Mapa Dia/Noite %s (UTC)' % date.strftime(\"%d %b %Y %H:%M:%S\"))\n",
225 |     "plt.title('Mapa Dia/Noite')\n",
226 |     "\n",
227 |     "# Mostrar e gravar\n",
228 |     "plt.show()\n",
229 |     "pyplot.savefig('Dia-Noite.png')"
230 |    ]
231 |   },
232 |   {
233 |    "cell_type": "code",
234 |    "execution_count": 7,
235 |    "metadata": {
236 |     "collapsed": true
237 |    },
238 |    "outputs": [],
239 |    "source": [
240 |     "# Acesse esse site para mais exemplos com Basemap\n",
241 |     "# http://matplotlib.org/basemap/users/examples.html"
242 |    ]
243 |   },
244 |   {
245 |    "cell_type": "markdown",
246 |    "metadata": {},
247 |    "source": [
248 |     "# Fim"
249 |    ]
250 |   },
251 |   {
252 |    "cell_type": "markdown",
253 |    "metadata": {},
254 |    "source": [
255 |     "### Obrigado - Data Science Academy - <a href=http://facebook.com/dsacademy>facebook.com/dsacademybr</a>"
256 |    ]
257 |   }
258 |  ],
259 |  "metadata": {
260 |   "kernelspec": {
261 |    "display_name": "Python 3",
262 |    "language": "python",
263 |    "name": "python3"
264 |   },
265 |   "language_info": {
266 |    "codemirror_mode": {
267 |     "name": "ipython",
268 |     "version": 3
269 |    },
270 |    "file_extension": ".py",
271 |    "mimetype": "text/x-python",
272 |    "name": "python",
273 |    "nbconvert_exporter": "python",
274 |    "pygments_lexer": "ipython3",
275 |    "version": "3.5.1"
276 |   }
277 |  },
278 |  "nbformat": 4,
279 |  "nbformat_minor": 0
280 | }
281 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo08/Matplotlib-Continentes.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mlhoffmann/PythonFundamentos/780daf19c7063edfef1fb4f045f0b104c91cfd9a/JupyterNotebooks/Capítulo08/Matplotlib-Continentes.png


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo08/Matplotlib-Dia-Noite.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mlhoffmann/PythonFundamentos/780daf19c7063edfef1fb4f045f0b104c91cfd9a/JupyterNotebooks/Capítulo08/Matplotlib-Dia-Noite.png


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo08/Matplotlib-Globo-expandido.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mlhoffmann/PythonFundamentos/780daf19c7063edfef1fb4f045f0b104c91cfd9a/JupyterNotebooks/Capítulo08/Matplotlib-Globo-expandido.png


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo08/Matplotlib-Globo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mlhoffmann/PythonFundamentos/780daf19c7063edfef1fb4f045f0b104c91cfd9a/JupyterNotebooks/Capítulo08/Matplotlib-Globo.png


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo08/Matplotlib-Mapa.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mlhoffmann/PythonFundamentos/780daf19c7063edfef1fb4f045f0b104c91cfd9a/JupyterNotebooks/Capítulo08/Matplotlib-Mapa.png


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo08/ScrapyProject/Scrapy/Scraping.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mlhoffmann/PythonFundamentos/780daf19c7063edfef1fb4f045f0b104c91cfd9a/JupyterNotebooks/Capítulo08/ScrapyProject/Scrapy/Scraping.png


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo08/ScrapyProject/Scrapy/Scrapy.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mlhoffmann/PythonFundamentos/780daf19c7063edfef1fb4f045f0b104c91cfd9a/JupyterNotebooks/Capítulo08/ScrapyProject/Scrapy/Scrapy.png


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo08/ScrapyProject/items.json:
--------------------------------------------------------------------------------
 1 | [
 2 | {"url": "/questions/38044964/cant-read-framework", "title": "Cant read framework"},
 3 | {"url": "/questions/38044963/monitoring-startactivity-in-logcat", "title": "Monitoring startActivity in logcat"},
 4 | {"url": "/questions/38044962/tricky-idea-about-programming-a-random-data-sorter-new-idea", "title": "Tricky idea about programming a random data sorter, new idea"},
 5 | {"url": "/questions/38044961/elasticsearch-term-vectors-not-being-returned", "title": "elasticsearch term vectors not being returned"},
 6 | {"url": "/questions/38044955/sigma-or-summation-function-in-excel", "title": "Sigma or Summation function in Excel"},
 7 | {"url": "/questions/38044954/can-i-have-a-single-sqslistener-annotation-listen-to-queues-in-multiple-regions", "title": "Can I have a single @SqsListener annotation listen to queues in multiple regions?"},
 8 | {"url": "/questions/38044953/is-there-any-tools-can-convert-ctl-or-ltl-statements-to-smtformat", "title": "is there any tools can convert CTL or LTL statements to SMTformat? [on hold]"},
 9 | {"url": "/questions/38044952/butterknife-onclick-does-not-trigger-the-method-in-a-fragment", "title": "Butterknife onclick does not trigger the method in a fragment"},
10 | {"url": "/questions/38044950/extending-data-object-in-typescript", "title": "Extending Data Object in TypeScript"},
11 | {"url": "/questions/38044949/instantiating-a-class-in-java", "title": "Instantiating a class in java"},
12 | {"url": "/questions/38044947/add-duration-for-reloadrowsatindexpaths-swift", "title": "Add duration for reloadRowsAtIndexPaths (swift)"},
13 | {"url": "/questions/38044946/storing-an-ordered-list-array-of-another-entity-in-a-core-data-entity", "title": "Storing an ordered list (array) of another entity in a Core Data entity?"},
14 | {"url": "/questions/38044945/how-do-you-update-model-from-directive-in-angular-2", "title": "How do you update model from directive in Angular 2?"},
15 | {"url": "/questions/38044944/odoo-how-to-insert-data-to-multiple-tables-with-foreign-constraint", "title": "Odoo how to insert data to multiple tables with foreign constraint?"},
16 | {"url": "/questions/38044942/unable-to-pull-strings-from-an-xml-file-unity-3d-c-sharp", "title": "Unable to pull strings from an XML File Unity 3D C#"},
17 | {"url": "/questions/38044941/batch-file-for-curl", "title": "batch file for curl"},
18 | {"url": "/questions/38044940/0x800a01b6-javascript-runtime-error-object-doesnt-support-property-or-method", "title": "0x800a01b6 - JavaScript runtime error: Object doesn't support property or method 'call'"},
19 | {"url": "/questions/38044939/im-just-learning-how-to-code-in-school-and-im-struggling-like-crazy", "title": "I'm just learning how to code in school and I'm struggling like crazy"},
20 | {"url": "/questions/38044937/retrieving-data-from-namedtuple-record-structure-fails", "title": "Retrieving data from namedtuple record structure fails"},
21 | {"url": "/questions/38044936/application-keeps-crashing", "title": "Application keeps Crashing"},
22 | {"url": "/questions/38044934/lnk2019unresolved-external-symbol-public-void-thiscall-listintpush-fron", "title": "LNK2019\tunresolved external symbol \u201cpublic: void __thiscall List<int>::push_front(int const &)\u201d referenced in function _main"},
23 | {"url": "/questions/38044933/blackjack-game-for-loops-not-in-vs-in", "title": "blackjack game: for loops 'not in' vs 'in'"},
24 | {"url": "/questions/38044932/classcastexception-thrown-when-calling-newinstance", "title": "ClassCastException thrown when calling .newInstance"},
25 | {"url": "/questions/38044931/installing-cheese-on-sd-card-when-running-from-emmc", "title": "Installing 'cheese' on SD Card , when running from eMMC"},
26 | {"url": "/questions/38044930/c-sharp-how-to-populate-datagridview-with-different-column-style-from-table", "title": "C# - How to populate datagridview with different column style from table?"},
27 | {"url": "/questions/38044929/share-button-in-android-navigation-drawer", "title": "Share button in Android Navigation Drawer"},
28 | {"url": "/questions/38044924/elasticsearch-nested-indexing-using-pentaho-data-integration", "title": "Elasticsearch Nested Indexing using Pentaho Data Integration"},
29 | {"url": "/questions/38044922/datetimepicker-access-violation-error", "title": "datetimepicker access violation error"},
30 | {"url": "/questions/38044921/im-having-an-issue-with-emulating-or-using-my-xperia-z1-with-android-studio-it-s", "title": "Im having an issue with emulating or using my xperia z1 with android studio.It says \u201c/dev/kvm is not found\u201d"},
31 | {"url": "/questions/38044919/multiple-promise-all-because-multiple-arrays", "title": "Multiple Promise.all() because multiple arrays"},
32 | {"url": "/questions/38044917/optimizing-calculations-of-historical-data", "title": "Optimizing calculations of historical data"},
33 | {"url": "/questions/38044916/how-to-pass-an-array-from-php-to-chart-js-data", "title": "How to pass an array from php to chart.js data?"},
34 | {"url": "/questions/38044911/how-can-i-create-a-temporary-table-in-mariadb-or-mysql", "title": "How can I create a temporary table in mariadb or mysql?"},
35 | {"url": "/questions/38044910/must-i-call-uiactivityindicatorview-stopanimating-before-uiview-removefromsuperv", "title": "Must I call UIActivityIndicatorView.stopAnimating before UIView.removeFromSuperview?"},
36 | {"url": "/questions/38044908/guidelines-for-implementing-oauth-2-0-in-jsf-applications", "title": "Guidelines for implementing OAuth 2.0 in JSF applications"},
37 | {"url": "/questions/38044907/what-happens-to-the-server-if-you-have-open-transaction-in-mssql", "title": "What happens to the server if you have open transaction in MSSQL?"},
38 | {"url": "/questions/38044899/changes-made-to-scope-in-directives-controller-unavailable-to-the-view", "title": "Changes made to $scope in directive's controller unavailable to the view"},
39 | {"url": "/questions/38044898/display-dialogs-in-a-loop-and-act-on-the-accept-event", "title": "Display dialogs in a loop and act on the accept event."},
40 | {"url": "/questions/38044897/find-address-and-add-marker-on-maps-sdk", "title": "Find address and add marker on Maps SDK"},
41 | {"url": "/questions/38044895/get-a-website-url-when-routing", "title": "GET a website url when routing"},
42 | {"url": "/questions/38044892/c-sharp-linq-return-child-elements-also", "title": "C# Linq return Child elements also"},
43 | {"url": "/questions/38044891/how-to-split-string-within-each-element-of-a-list-in-r-and-keep-unique-strings", "title": "How to split string within each element of a list in R, and keep unique strings in element"},
44 | {"url": "/questions/38044887/libary-technology-for-handling-csv-uploads-in-c-sharp", "title": "Libary/Technology for handling CSV uploads in C#"},
45 | {"url": "/questions/38044886/path-of-file-in-python", "title": "Path of file in Python"},
46 | {"url": "/questions/38044885/google-drive-api-get-edit-url-aka-alternatelink-for-file-with-php-sdk", "title": "Google Drive API get edit url (aka alternateLink) for file with PHP SDK"},
47 | {"url": "/questions/38044884/time-variables-in-bash-scripting", "title": "Time Variables in Bash Scripting"},
48 | {"url": "/questions/38044883/c-sharp-reading-a-byte-array-as-a-string", "title": "C# reading a byte array as a string"},
49 | {"url": "/questions/38044882/adding-external-library-into-qt-creator-project-mac-os-special-syntax", "title": "Adding external library into Qt Creator project, Mac OS special syntax?"}
50 | ]


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo08/ScrapyProject/scrapy.cfg:
--------------------------------------------------------------------------------
 1 | # Automatically created by: scrapy startproject
 2 | #
 3 | # For more information about the [deploy] section see:
 4 | # https://scrapyd.readthedocs.org/en/latest/deploy.html
 5 | 
 6 | [settings]
 7 | default = stack.settings
 8 | 
 9 | [deploy]
10 | #url = http://localhost:6800/
11 | project = stack
12 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo08/ScrapyProject/stack/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mlhoffmann/PythonFundamentos/780daf19c7063edfef1fb4f045f0b104c91cfd9a/JupyterNotebooks/Capítulo08/ScrapyProject/stack/__init__.py


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo08/ScrapyProject/stack/__pycache__/__init__.cpython-35.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mlhoffmann/PythonFundamentos/780daf19c7063edfef1fb4f045f0b104c91cfd9a/JupyterNotebooks/Capítulo08/ScrapyProject/stack/__pycache__/__init__.cpython-35.pyc


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo08/ScrapyProject/stack/__pycache__/items.cpython-35.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mlhoffmann/PythonFundamentos/780daf19c7063edfef1fb4f045f0b104c91cfd9a/JupyterNotebooks/Capítulo08/ScrapyProject/stack/__pycache__/items.cpython-35.pyc


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo08/ScrapyProject/stack/__pycache__/pipelines.cpython-35.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mlhoffmann/PythonFundamentos/780daf19c7063edfef1fb4f045f0b104c91cfd9a/JupyterNotebooks/Capítulo08/ScrapyProject/stack/__pycache__/pipelines.cpython-35.pyc


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo08/ScrapyProject/stack/__pycache__/settings.cpython-35.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mlhoffmann/PythonFundamentos/780daf19c7063edfef1fb4f045f0b104c91cfd9a/JupyterNotebooks/Capítulo08/ScrapyProject/stack/__pycache__/settings.cpython-35.pyc


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo08/ScrapyProject/stack/items.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | # Define here the models for your scraped items
 4 | #
 5 | # See documentation in:
 6 | # http://doc.scrapy.org/en/latest/topics/items.html
 7 | 
 8 | from scrapy.item import Item, Field
 9 | 
10 | class StackItem(Item):
11 |     title = Field()
12 |     url = Field()
13 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo08/ScrapyProject/stack/pipelines.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | # Define your item pipelines here
 4 | #
 5 | # Don't forget to add your pipeline to the ITEM_PIPELINES setting
 6 | # See: http://doc.scrapy.org/en/latest/topics/item-pipeline.html
 7 | 
 8 | 
 9 | class StackPipeline(object):
10 |     def process_item(self, item, spider):
11 |         return item
12 | 
13 | 
14 | import pymongo
15 | 
16 | from scrapy.conf import settings
17 | from scrapy.exceptions import DropItem
18 | from scrapy import log
19 | 
20 | 
21 | class MongoDBPipeline(object):
22 | 
23 |     def __init__(self):
24 |         connection = pymongo.MongoClient(
25 |             settings['MONGODB_SERVER'],
26 |             settings['MONGODB_PORT']
27 |         )
28 |         db = connection[settings['MONGODB_DB']]
29 |         self.collection = db[settings['MONGODB_COLLECTION']]
30 | 
31 |     def process_item(self, item, spider):
32 |         valid = True
33 |         for data in item:
34 |             if not data:
35 |                 valid = False
36 |                 raise DropItem("Missing {0}!".format(data))
37 |         if valid:
38 |             self.collection.insert(dict(item))
39 |             log.msg("Question added to MongoDB database!",
40 |                     level=log.DEBUG, spider=spider)
41 |         return item
42 | 
43 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo08/ScrapyProject/stack/settings.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | # Scrapy settings for stack project
 4 | #
 5 | # For simplicity, this file contains only settings considered important or
 6 | # commonly used. You can find more settings consulting the documentation:
 7 | #
 8 | #     http://doc.scrapy.org/en/latest/topics/settings.html
 9 | #     http://scrapy.readthedocs.org/en/latest/topics/downloader-middleware.html
10 | #     http://scrapy.readthedocs.org/en/latest/topics/spider-middleware.html
11 | 
12 | BOT_NAME = 'stack'
13 | 
14 | SPIDER_MODULES = ['stack.spiders']
15 | NEWSPIDER_MODULE = 'stack.spiders'
16 | 
17 | ITEM_PIPELINES = {'stack.pipelines.MongoDBPipeline':300}
18 | 
19 | MONGODB_SERVER = "localhost"
20 | MONGODB_PORT = 27017
21 | MONGODB_DB = "stackoverflow"
22 | MONGODB_COLLECTION = "questions"
23 | 
24 | 
25 | # Crawl responsibly by identifying yourself (and your website) on the user-agent
26 | #USER_AGENT = 'stack (+http://www.yourdomain.com)'
27 | 
28 | # Obey robots.txt rules
29 | ROBOTSTXT_OBEY = True
30 | 
31 | # Configure maximum concurrent requests performed by Scrapy (default: 16)
32 | #CONCURRENT_REQUESTS = 32
33 | 
34 | # Configure a delay for requests for the same website (default: 0)
35 | # See http://scrapy.readthedocs.org/en/latest/topics/settings.html#download-delay
36 | # See also autothrottle settings and docs
37 | #DOWNLOAD_DELAY = 3
38 | # The download delay setting will honor only one of:
39 | #CONCURRENT_REQUESTS_PER_DOMAIN = 16
40 | #CONCURRENT_REQUESTS_PER_IP = 16
41 | 
42 | # Disable cookies (enabled by default)
43 | #COOKIES_ENABLED = False
44 | 
45 | # Disable Telnet Console (enabled by default)
46 | #TELNETCONSOLE_ENABLED = False
47 | 
48 | # Override the default request headers:
49 | #DEFAULT_REQUEST_HEADERS = {
50 | #   'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
51 | #   'Accept-Language': 'en',
52 | #}
53 | 
54 | # Enable or disable spider middlewares
55 | # See http://scrapy.readthedocs.org/en/latest/topics/spider-middleware.html
56 | #SPIDER_MIDDLEWARES = {
57 | #    'stack.middlewares.MyCustomSpiderMiddleware': 543,
58 | #}
59 | 
60 | # Enable or disable downloader middlewares
61 | # See http://scrapy.readthedocs.org/en/latest/topics/downloader-middleware.html
62 | #DOWNLOADER_MIDDLEWARES = {
63 | #    'stack.middlewares.MyCustomDownloaderMiddleware': 543,
64 | #}
65 | 
66 | # Enable or disable extensions
67 | # See http://scrapy.readthedocs.org/en/latest/topics/extensions.html
68 | #EXTENSIONS = {
69 | #    'scrapy.extensions.telnet.TelnetConsole': None,
70 | #}
71 | 
72 | # Configure item pipelines
73 | # See http://scrapy.readthedocs.org/en/latest/topics/item-pipeline.html
74 | #ITEM_PIPELINES = {
75 | #    'stack.pipelines.SomePipeline': 300,
76 | #}
77 | 
78 | # Enable and configure the AutoThrottle extension (disabled by default)
79 | # See http://doc.scrapy.org/en/latest/topics/autothrottle.html
80 | #AUTOTHROTTLE_ENABLED = True
81 | # The initial download delay
82 | #AUTOTHROTTLE_START_DELAY = 5
83 | # The maximum download delay to be set in case of high latencies
84 | #AUTOTHROTTLE_MAX_DELAY = 60
85 | # The average number of requests Scrapy should be sending in parallel to
86 | # each remote server
87 | #AUTOTHROTTLE_TARGET_CONCURRENCY = 1.0
88 | # Enable showing throttling stats for every response received:
89 | #AUTOTHROTTLE_DEBUG = False
90 | 
91 | # Enable and configure HTTP caching (disabled by default)
92 | # See http://scrapy.readthedocs.org/en/latest/topics/downloader-middleware.html#httpcache-middleware-settings
93 | #HTTPCACHE_ENABLED = True
94 | #HTTPCACHE_EXPIRATION_SECS = 0
95 | #HTTPCACHE_DIR = 'httpcache'
96 | #HTTPCACHE_IGNORE_HTTP_CODES = []
97 | #HTTPCACHE_STORAGE = 'scrapy.extensions.httpcache.FilesystemCacheStorage'
98 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo08/ScrapyProject/stack/spiders/__init__.py:
--------------------------------------------------------------------------------
1 | # This package will contain the spiders of your Scrapy project
2 | #
3 | # Please refer to the documentation for information on how to create and manage
4 | # your spiders.
5 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo08/ScrapyProject/stack/spiders/__pycache__/__init__.cpython-35.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mlhoffmann/PythonFundamentos/780daf19c7063edfef1fb4f045f0b104c91cfd9a/JupyterNotebooks/Capítulo08/ScrapyProject/stack/spiders/__pycache__/__init__.cpython-35.pyc


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo08/ScrapyProject/stack/spiders/__pycache__/stack_spider.cpython-35.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mlhoffmann/PythonFundamentos/780daf19c7063edfef1fb4f045f0b104c91cfd9a/JupyterNotebooks/Capítulo08/ScrapyProject/stack/spiders/__pycache__/stack_spider.cpython-35.pyc


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo08/ScrapyProject/stack/spiders/stack_spider.py:
--------------------------------------------------------------------------------
 1 | from scrapy import Spider
 2 | from scrapy.selector import Selector
 3 | 
 4 | from stack.items import StackItem
 5 | 
 6 | class StackSpider(Spider):
 7 |     name = "stack"
 8 |     allowed_domains = ["stackoverflow.com"]
 9 |     start_urls = [
10 |         "http://stackoverflow.com/questions?pagesize=50&sort=newest",
11 |     ]
12 | 
13 |     def parse(self, response):
14 |         questions = Selector(response).xpath('//div[@class="summary"]/h3')
15 | 
16 |         for question in questions:
17 |             item = StackItem()
18 |             item['title'] = question.xpath(
19 |                 'a[@class="question-hyperlink"]/text()').extract()[0]
20 |             item['url'] = question.xpath(
21 |                 'a[@class="question-hyperlink"]/@href').extract()[0]
22 |             yield item
23 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo08/gmap_plot.html:
--------------------------------------------------------------------------------
 1 | 
 2 | <!DOCTYPE html>
 3 | <html lang="en">
 4 |     <head>
 5 |         <meta charset="utf-8">
 6 |         <title>Bokeh Plot</title>
 7 |         
 8 | <link rel="stylesheet" href="https://cdn.pydata.org/bokeh/release/bokeh-0.11.1.min.css" type="text/css" />
 9 |         
10 | <script type="text/javascript" src="https://cdn.pydata.org/bokeh/release/bokeh-0.11.1.min.js"></script>
11 | <script type="text/javascript">
12 |     Bokeh.set_log_level("info");
13 | </script>
14 |     </head>
15 |     <body>
16 |         
17 |         <div class="plotdiv" id="740f640f-88f4-4195-ba35-130ad6073026"></div>
18 |         
19 |         <script type="text/javascript">
20 |             Bokeh.$(function() {
21 |             var docs_json = {"e9867ffa-33ef-43ba-b399-1e57e081559e":{"roots":{"references":[{"attributes":{"fill_alpha":{"value":0.8},"fill_color":{"value":"blue"},"line_color":{"value":null},"size":{"units":"screen","value":15},"x":{"field":"lon"},"y":{"field":"lat"}},"id":"099b4726-7c10-4fcf-be80-25fc4c00b082","type":"Circle"},{"attributes":{"plot":{"id":"91d49c9b-b075-4e6a-9905-7faacbb82c65","type":"GMapPlot"}},"id":"3c625601-e826-4620-b205-e11ee6b51a29","type":"WheelZoomTool"},{"attributes":{"callback":null},"id":"1f9983c7-c3cc-41c0-b5b8-eee555f466ee","type":"DataRange1d"},{"attributes":{"plot":{"id":"91d49c9b-b075-4e6a-9905-7faacbb82c65","type":"GMapPlot"}},"id":"19d3df8a-7187-4377-ac36-202fad75c3c7","type":"PanTool"},{"attributes":{"data_source":{"id":"a5a01ae1-efff-41a8-bf6e-cccf423e538e","type":"ColumnDataSource"},"glyph":{"id":"099b4726-7c10-4fcf-be80-25fc4c00b082","type":"Circle"},"hover_glyph":null,"nonselection_glyph":null,"selection_glyph":null},"id":"f7234f08-06b2-4b67-b618-301a0a3400de","type":"GlyphRenderer"},{"attributes":{"map_options":{"lat":-23.5431786,"lng":-46.62918450000001,"map_type":"roadmap","zoom":11},"renderers":[{"id":"f7234f08-06b2-4b67-b618-301a0a3400de","type":"GlyphRenderer"},{"id":"1a4dcf3e-70dd-4fe7-a476-cffb8b66dace","type":"BoxAnnotation"}],"title":"S\u00e3o Paulo","tool_events":{"id":"c9a3c7b9-1c94-4148-acf1-07ede9e7c6ce","type":"ToolEvents"},"tools":[{"id":"19d3df8a-7187-4377-ac36-202fad75c3c7","type":"PanTool"},{"id":"3c625601-e826-4620-b205-e11ee6b51a29","type":"WheelZoomTool"},{"id":"f100c5ff-80b8-421c-8a95-f85ce49d22d7","type":"BoxSelectTool"}],"x_range":{"id":"db11abde-d487-4f13-9185-6843a6a56187","type":"DataRange1d"},"y_range":{"id":"1f9983c7-c3cc-41c0-b5b8-eee555f466ee","type":"DataRange1d"}},"id":"91d49c9b-b075-4e6a-9905-7faacbb82c65","type":"GMapPlot"},{"attributes":{"callback":null},"id":"db11abde-d487-4f13-9185-6843a6a56187","type":"DataRange1d"},{"attributes":{"bottom_units":"screen","fill_alpha":{"value":0.5},"fill_color":{"value":"lightgrey"},"left_units":"screen","level":"overlay","line_alpha":{"value":1.0},"line_color":{"value":"black"},"line_dash":[4,4],"line_width":{"value":2},"plot":null,"render_mode":"css","right_units":"screen","top_units":"screen"},"id":"1a4dcf3e-70dd-4fe7-a476-cffb8b66dace","type":"BoxAnnotation"},{"attributes":{"callback":null,"overlay":{"id":"1a4dcf3e-70dd-4fe7-a476-cffb8b66dace","type":"BoxAnnotation"},"plot":{"id":"91d49c9b-b075-4e6a-9905-7faacbb82c65","type":"GMapPlot"}},"id":"f100c5ff-80b8-421c-8a95-f85ce49d22d7","type":"BoxSelectTool"},{"attributes":{},"id":"c9a3c7b9-1c94-4148-acf1-07ede9e7c6ce","type":"ToolEvents"},{"attributes":{"callback":null,"column_names":["lon","lat"],"data":{"lat":[-23.54,-46.62],"lon":[97.7,97.74]}},"id":"a5a01ae1-efff-41a8-bf6e-cccf423e538e","type":"ColumnDataSource"}],"root_ids":["91d49c9b-b075-4e6a-9905-7faacbb82c65"]},"title":"Bokeh Application","version":"0.11.1"}};
22 |             var render_items = [{"docid":"e9867ffa-33ef-43ba-b399-1e57e081559e","elementid":"740f640f-88f4-4195-ba35-130ad6073026","modelid":"91d49c9b-b075-4e6a-9905-7faacbb82c65"}];
23 |             
24 |             Bokeh.embed.embed_items(docs_json, render_items);
25 |         });
26 |         </script>
27 |     </body>
28 | </html>


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo08/iris.csv:
--------------------------------------------------------------------------------
  1 | sepal_length,sepal_width,petal_length,petal_width,species
  2 | 5.1,3.5,1.4,0.2,setosa
  3 | 4.9,3,1.4,0.2,setosa
  4 | 4.7,3.2,1.3,0.2,setosa
  5 | 4.6,3.1,1.5,0.2,setosa
  6 | 5,3.6,1.4,0.2,setosa
  7 | 5.4,3.9,1.7,0.4,setosa
  8 | 4.6,3.4,1.4,0.3,setosa
  9 | 5,3.4,1.5,0.2,setosa
 10 | 4.4,2.9,1.4,0.2,setosa
 11 | 4.9,3.1,1.5,0.1,setosa
 12 | 5.4,3.7,1.5,0.2,setosa
 13 | 4.8,3.4,1.6,0.2,setosa
 14 | 4.8,3,1.4,0.1,setosa
 15 | 4.3,3,1.1,0.1,setosa
 16 | 5.8,4,1.2,0.2,setosa
 17 | 5.7,4.4,1.5,0.4,setosa
 18 | 5.4,3.9,1.3,0.4,setosa
 19 | 5.1,3.5,1.4,0.3,setosa
 20 | 5.7,3.8,1.7,0.3,setosa
 21 | 5.1,3.8,1.5,0.3,setosa
 22 | 5.4,3.4,1.7,0.2,setosa
 23 | 5.1,3.7,1.5,0.4,setosa
 24 | 4.6,3.6,1,0.2,setosa
 25 | 5.1,3.3,1.7,0.5,setosa
 26 | 4.8,3.4,1.9,0.2,setosa
 27 | 5,3,1.6,0.2,setosa
 28 | 5,3.4,1.6,0.4,setosa
 29 | 5.2,3.5,1.5,0.2,setosa
 30 | 5.2,3.4,1.4,0.2,setosa
 31 | 4.7,3.2,1.6,0.2,setosa
 32 | 4.8,3.1,1.6,0.2,setosa
 33 | 5.4,3.4,1.5,0.4,setosa
 34 | 5.2,4.1,1.5,0.1,setosa
 35 | 5.5,4.2,1.4,0.2,setosa
 36 | 4.9,3.1,1.5,0.1,setosa
 37 | 5,3.2,1.2,0.2,setosa
 38 | 5.5,3.5,1.3,0.2,setosa
 39 | 4.9,3.1,1.5,0.1,setosa
 40 | 4.4,3,1.3,0.2,setosa
 41 | 5.1,3.4,1.5,0.2,setosa
 42 | 5,3.5,1.3,0.3,setosa
 43 | 4.5,2.3,1.3,0.3,setosa
 44 | 4.4,3.2,1.3,0.2,setosa
 45 | 5,3.5,1.6,0.6,setosa
 46 | 5.1,3.8,1.9,0.4,setosa
 47 | 4.8,3,1.4,0.3,setosa
 48 | 5.1,3.8,1.6,0.2,setosa
 49 | 4.6,3.2,1.4,0.2,setosa
 50 | 5.3,3.7,1.5,0.2,setosa
 51 | 5,3.3,1.4,0.2,setosa
 52 | 7,3.2,4.7,1.4,versicolor
 53 | 6.4,3.2,4.5,1.5,versicolor
 54 | 6.9,3.1,4.9,1.5,versicolor
 55 | 5.5,2.3,4,1.3,versicolor
 56 | 6.5,2.8,4.6,1.5,versicolor
 57 | 5.7,2.8,4.5,1.3,versicolor
 58 | 6.3,3.3,4.7,1.6,versicolor
 59 | 4.9,2.4,3.3,1,versicolor
 60 | 6.6,2.9,4.6,1.3,versicolor
 61 | 5.2,2.7,3.9,1.4,versicolor
 62 | 5,2,3.5,1,versicolor
 63 | 5.9,3,4.2,1.5,versicolor
 64 | 6,2.2,4,1,versicolor
 65 | 6.1,2.9,4.7,1.4,versicolor
 66 | 5.6,2.9,3.6,1.3,versicolor
 67 | 6.7,3.1,4.4,1.4,versicolor
 68 | 5.6,3,4.5,1.5,versicolor
 69 | 5.8,2.7,4.1,1,versicolor
 70 | 6.2,2.2,4.5,1.5,versicolor
 71 | 5.6,2.5,3.9,1.1,versicolor
 72 | 5.9,3.2,4.8,1.8,versicolor
 73 | 6.1,2.8,4,1.3,versicolor
 74 | 6.3,2.5,4.9,1.5,versicolor
 75 | 6.1,2.8,4.7,1.2,versicolor
 76 | 6.4,2.9,4.3,1.3,versicolor
 77 | 6.6,3,4.4,1.4,versicolor
 78 | 6.8,2.8,4.8,1.4,versicolor
 79 | 6.7,3,5,1.7,versicolor
 80 | 6,2.9,4.5,1.5,versicolor
 81 | 5.7,2.6,3.5,1,versicolor
 82 | 5.5,2.4,3.8,1.1,versicolor
 83 | 5.5,2.4,3.7,1,versicolor
 84 | 5.8,2.7,3.9,1.2,versicolor
 85 | 6,2.7,5.1,1.6,versicolor
 86 | 5.4,3,4.5,1.5,versicolor
 87 | 6,3.4,4.5,1.6,versicolor
 88 | 6.7,3.1,4.7,1.5,versicolor
 89 | 6.3,2.3,4.4,1.3,versicolor
 90 | 5.6,3,4.1,1.3,versicolor
 91 | 5.5,2.5,4,1.3,versicolor
 92 | 5.5,2.6,4.4,1.2,versicolor
 93 | 6.1,3,4.6,1.4,versicolor
 94 | 5.8,2.6,4,1.2,versicolor
 95 | 5,2.3,3.3,1,versicolor
 96 | 5.6,2.7,4.2,1.3,versicolor
 97 | 5.7,3,4.2,1.2,versicolor
 98 | 5.7,2.9,4.2,1.3,versicolor
 99 | 6.2,2.9,4.3,1.3,versicolor
100 | 5.1,2.5,3,1.1,versicolor
101 | 5.7,2.8,4.1,1.3,versicolor
102 | 6.3,3.3,6,2.5,virginica
103 | 5.8,2.7,5.1,1.9,virginica
104 | 7.1,3,5.9,2.1,virginica
105 | 6.3,2.9,5.6,1.8,virginica
106 | 6.5,3,5.8,2.2,virginica
107 | 7.6,3,6.6,2.1,virginica
108 | 4.9,2.5,4.5,1.7,virginica
109 | 7.3,2.9,6.3,1.8,virginica
110 | 6.7,2.5,5.8,1.8,virginica
111 | 7.2,3.6,6.1,2.5,virginica
112 | 6.5,3.2,5.1,2,virginica
113 | 6.4,2.7,5.3,1.9,virginica
114 | 6.8,3,5.5,2.1,virginica
115 | 5.7,2.5,5,2,virginica
116 | 5.8,2.8,5.1,2.4,virginica
117 | 6.4,3.2,5.3,2.3,virginica
118 | 6.5,3,5.5,1.8,virginica
119 | 7.7,3.8,6.7,2.2,virginica
120 | 7.7,2.6,6.9,2.3,virginica
121 | 6,2.2,5,1.5,virginica
122 | 6.9,3.2,5.7,2.3,virginica
123 | 5.6,2.8,4.9,2,virginica
124 | 7.7,2.8,6.7,2,virginica
125 | 6.3,2.7,4.9,1.8,virginica
126 | 6.7,3.3,5.7,2.1,virginica
127 | 7.2,3.2,6,1.8,virginica
128 | 6.2,2.8,4.8,1.8,virginica
129 | 6.1,3,4.9,1.8,virginica
130 | 6.4,2.8,5.6,2.1,virginica
131 | 7.2,3,5.8,1.6,virginica
132 | 7.4,2.8,6.1,1.9,virginica
133 | 7.9,3.8,6.4,2,virginica
134 | 6.4,2.8,5.6,2.2,virginica
135 | 6.3,2.8,5.1,1.5,virginica
136 | 6.1,2.6,5.6,1.4,virginica
137 | 7.7,3,6.1,2.3,virginica
138 | 6.3,3.4,5.6,2.4,virginica
139 | 6.4,3.1,5.5,1.8,virginica
140 | 6,3,4.8,1.8,virginica
141 | 6.9,3.1,5.4,2.1,virginica
142 | 6.7,3.1,5.6,2.4,virginica
143 | 6.9,3.1,5.1,2.3,virginica
144 | 5.8,2.7,5.1,1.9,virginica
145 | 6.8,3.2,5.9,2.3,virginica
146 | 6.7,3.3,5.7,2.5,virginica
147 | 6.7,3,5.2,2.3,virginica
148 | 6.3,2.5,5,1.9,virginica
149 | 6.5,3,5.2,2,virginica
150 | 6.2,3.4,5.4,2.3,virginica
151 | 5.9,3,5.1,1.8,virginica
152 | 


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo08/linear.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mlhoffmann/PythonFundamentos/780daf19c7063edfef1fb4f045f0b104c91cfd9a/JupyterNotebooks/Capítulo08/linear.png


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo08/ml_map.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mlhoffmann/PythonFundamentos/780daf19c7063edfef1fb4f045f0b104c91cfd9a/JupyterNotebooks/Capítulo08/ml_map.png


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo09/DSA-Python-Capitulo9-Reconhecimento-de-Imagens.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mlhoffmann/PythonFundamentos/780daf19c7063edfef1fb4f045f0b104c91cfd9a/JupyterNotebooks/Capítulo09/DSA-Python-Capitulo9-Reconhecimento-de-Imagens.pdf


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo09/Dados-Pesquisa-2016.csv.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mlhoffmann/PythonFundamentos/780daf19c7063edfef1fb4f045f0b104c91cfd9a/JupyterNotebooks/Capítulo09/Dados-Pesquisa-2016.csv.zip


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo09/test.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mlhoffmann/PythonFundamentos/780daf19c7063edfef1fb4f045f0b104c91cfd9a/JupyterNotebooks/Capítulo09/test.zip


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo09/train.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mlhoffmann/PythonFundamentos/780daf19c7063edfef1fb4f045f0b104c91cfd9a/JupyterNotebooks/Capítulo09/train.zip


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo10/ConfusionMatrix.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mlhoffmann/PythonFundamentos/780daf19c7063edfef1fb4f045f0b104c91cfd9a/JupyterNotebooks/Capítulo10/ConfusionMatrix.jpg


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo10/Treinamento.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mlhoffmann/PythonFundamentos/780daf19c7063edfef1fb4f045f0b104c91cfd9a/JupyterNotebooks/Capítulo10/Treinamento.png


--------------------------------------------------------------------------------
/JupyterNotebooks/Capítulo10/Workflow.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mlhoffmann/PythonFundamentos/780daf19c7063edfef1fb4f045f0b104c91cfd9a/JupyterNotebooks/Capítulo10/Workflow.png


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Python Fundamentos
 2 | 
 3 | Data Science Academy - Python Fundamentos para Análise de Dados
 4 | 
 5 | Seja Bem-vindo ao Repositório do curso Python Fundamentos para Análise de Dados. Aqui você encontra todos os Jupyter Notebooks usados no curso, bem como os exercícios.
 6 | 
 7 | http://www.datascienceacademy.com.br
 8 | 
 9 | 
10 | 
11 | 


--------------------------------------------------------------------------------