├── .gitignore
├── 01_variaveis_e_tipos.ipynb
├── 02_funcoes.ipynb
├── 03_condicionais.ipynb
├── 04_loops.ipynb
├── 05_lists.ipynb
├── 06_strings.ipynb
├── 07_tuplas.ipynb
├── 08_dicionarios.ipynb
├── 09_bibliotecas_externas.ipynb
├── README.md
├── codigos_base
├── 01_variaveis_e_tipos.ipynb
├── 02_funcoes.ipynb
├── 03_condicionais.ipynb
├── 04_loops.ipynb
├── 05_lists.ipynb
├── 06_strings.ipynb
├── 07_tuplas.ipynb
├── 08_dicionarios.ipynb
└── 09_bibliotecas_externas.ipynb
├── hello_world.py
└── imagens
└── exemplo_lista_indices.png
/.gitignore:
--------------------------------------------------------------------------------
1 | preparacao
--------------------------------------------------------------------------------
/01_variaveis_e_tipos.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "## **Python Essencial para Data Science**\n",
8 | "**Prof. Dr. Samuel Martins (@hisamuka @xavecoding)**
\n",
9 | "xavecoding: https://youtube.com/c/xavecoding
\n",
10 | "\n",
11 | "Neste tutorial, vamos aprender os conceitos básicos para desenvolvermos nossos primeiros programas em Python!
\n",
12 | "Boa parte dos exemplos deste tutorial é inspirado no [curso de Python do Kaggle](https://www.kaggle.com/learn/python).
\n",
13 | "\n",
14 | "![\"Creative](\"https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png\")
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License."
15 | ]
16 | },
17 | {
18 | "cell_type": "code",
19 | "execution_count": 1,
20 | "metadata": {},
21 | "outputs": [
22 | {
23 | "data": {
24 | "text/html": [
25 | "\n"
28 | ],
29 | "text/plain": [
30 | ""
31 | ]
32 | },
33 | "metadata": {},
34 | "output_type": "display_data"
35 | }
36 | ],
37 | "source": [
38 | "%%html\n",
39 | ""
42 | ]
43 | },
44 | {
45 | "cell_type": "markdown",
46 | "metadata": {},
47 | "source": [
48 | "## Variáveis\n",
49 | "\n",
50 | "### Tipos\n",
51 | "Python tem diferentes tipos de dados, mas no fundo, *tudo é um objeto*.
\n",
52 | "Variáveis podem ser definidas em qualquer lugar.\n",
53 | "\n",
54 | "Veja alguns tipos:\n",
55 | "\n",
56 | "| Tipo | Exemplo |\n",
57 | "|---------|-------------------|\n",
58 | "| Integer | 1 10 -4 |\n",
59 | "| Float | 1.0 -0.223 3.1415 |\n",
60 | "| String | \"Hello world\" |"
61 | ]
62 | },
63 | {
64 | "cell_type": "markdown",
65 | "metadata": {},
66 | "source": [
67 | "## Instanciando variáveis"
68 | ]
69 | },
70 | {
71 | "cell_type": "code",
72 | "execution_count": 9,
73 | "metadata": {},
74 | "outputs": [],
75 | "source": [
76 | "nome = 'Luke skywalker'\n",
77 | "idade = 18\n",
78 | "peso = 70.5"
79 | ]
80 | },
81 | {
82 | "cell_type": "code",
83 | "execution_count": 10,
84 | "metadata": {},
85 | "outputs": [
86 | {
87 | "data": {
88 | "text/plain": [
89 | "'Luke skywalker'"
90 | ]
91 | },
92 | "execution_count": 10,
93 | "metadata": {},
94 | "output_type": "execute_result"
95 | }
96 | ],
97 | "source": [
98 | "nome"
99 | ]
100 | },
101 | {
102 | "cell_type": "code",
103 | "execution_count": 11,
104 | "metadata": {},
105 | "outputs": [
106 | {
107 | "data": {
108 | "text/plain": [
109 | "18"
110 | ]
111 | },
112 | "execution_count": 11,
113 | "metadata": {},
114 | "output_type": "execute_result"
115 | }
116 | ],
117 | "source": [
118 | "idade"
119 | ]
120 | },
121 | {
122 | "cell_type": "code",
123 | "execution_count": 12,
124 | "metadata": {},
125 | "outputs": [
126 | {
127 | "data": {
128 | "text/plain": [
129 | "70.5"
130 | ]
131 | },
132 | "execution_count": 12,
133 | "metadata": {},
134 | "output_type": "execute_result"
135 | }
136 | ],
137 | "source": [
138 | "peso"
139 | ]
140 | },
141 | {
142 | "cell_type": "code",
143 | "execution_count": 14,
144 | "metadata": {},
145 | "outputs": [
146 | {
147 | "name": "stdout",
148 | "output_type": "stream",
149 | "text": [
150 | "Luke skywalker\n"
151 | ]
152 | }
153 | ],
154 | "source": [
155 | "print(nome)"
156 | ]
157 | },
158 | {
159 | "cell_type": "raw",
160 | "metadata": {},
161 | "source": [
162 | "print(nome, idade, peso)"
163 | ]
164 | },
165 | {
166 | "cell_type": "markdown",
167 | "metadata": {},
168 | "source": [
169 | "### Type()\n",
170 | "Use a função type() para descobrir o tipo de uma variável."
171 | ]
172 | },
173 | {
174 | "cell_type": "code",
175 | "execution_count": 16,
176 | "metadata": {},
177 | "outputs": [
178 | {
179 | "data": {
180 | "text/plain": [
181 | "str"
182 | ]
183 | },
184 | "execution_count": 16,
185 | "metadata": {},
186 | "output_type": "execute_result"
187 | }
188 | ],
189 | "source": [
190 | "type(nome)"
191 | ]
192 | },
193 | {
194 | "cell_type": "code",
195 | "execution_count": 17,
196 | "metadata": {},
197 | "outputs": [
198 | {
199 | "data": {
200 | "text/plain": [
201 | "int"
202 | ]
203 | },
204 | "execution_count": 17,
205 | "metadata": {},
206 | "output_type": "execute_result"
207 | }
208 | ],
209 | "source": [
210 | "type(idade)"
211 | ]
212 | },
213 | {
214 | "cell_type": "code",
215 | "execution_count": 18,
216 | "metadata": {},
217 | "outputs": [
218 | {
219 | "data": {
220 | "text/plain": [
221 | "float"
222 | ]
223 | },
224 | "execution_count": 18,
225 | "metadata": {},
226 | "output_type": "execute_result"
227 | }
228 | ],
229 | "source": [
230 | "type(peso)"
231 | ]
232 | },
233 | {
234 | "cell_type": "code",
235 | "execution_count": 19,
236 | "metadata": {},
237 | "outputs": [
238 | {
239 | "data": {
240 | "text/plain": [
241 | "float"
242 | ]
243 | },
244 | "execution_count": 19,
245 | "metadata": {},
246 | "output_type": "execute_result"
247 | }
248 | ],
249 | "source": [
250 | "type(10.0)"
251 | ]
252 | },
253 | {
254 | "cell_type": "code",
255 | "execution_count": 20,
256 | "metadata": {},
257 | "outputs": [
258 | {
259 | "data": {
260 | "text/plain": [
261 | "int"
262 | ]
263 | },
264 | "execution_count": 20,
265 | "metadata": {},
266 | "output_type": "execute_result"
267 | }
268 | ],
269 | "source": [
270 | "type(10)"
271 | ]
272 | },
273 | {
274 | "cell_type": "markdown",
275 | "metadata": {},
276 | "source": [
277 | "### Dir()\n",
278 | "Use a função dir() para descobrir **todos os métodos** associados a um objeto:"
279 | ]
280 | },
281 | {
282 | "cell_type": "code",
283 | "execution_count": 22,
284 | "metadata": {},
285 | "outputs": [
286 | {
287 | "data": {
288 | "text/plain": [
289 | "['__add__',\n",
290 | " '__class__',\n",
291 | " '__contains__',\n",
292 | " '__delattr__',\n",
293 | " '__dir__',\n",
294 | " '__doc__',\n",
295 | " '__eq__',\n",
296 | " '__format__',\n",
297 | " '__ge__',\n",
298 | " '__getattribute__',\n",
299 | " '__getitem__',\n",
300 | " '__getnewargs__',\n",
301 | " '__gt__',\n",
302 | " '__hash__',\n",
303 | " '__init__',\n",
304 | " '__init_subclass__',\n",
305 | " '__iter__',\n",
306 | " '__le__',\n",
307 | " '__len__',\n",
308 | " '__lt__',\n",
309 | " '__mod__',\n",
310 | " '__mul__',\n",
311 | " '__ne__',\n",
312 | " '__new__',\n",
313 | " '__reduce__',\n",
314 | " '__reduce_ex__',\n",
315 | " '__repr__',\n",
316 | " '__rmod__',\n",
317 | " '__rmul__',\n",
318 | " '__setattr__',\n",
319 | " '__sizeof__',\n",
320 | " '__str__',\n",
321 | " '__subclasshook__',\n",
322 | " 'capitalize',\n",
323 | " 'casefold',\n",
324 | " 'center',\n",
325 | " 'count',\n",
326 | " 'encode',\n",
327 | " 'endswith',\n",
328 | " 'expandtabs',\n",
329 | " 'find',\n",
330 | " 'format',\n",
331 | " 'format_map',\n",
332 | " 'index',\n",
333 | " 'isalnum',\n",
334 | " 'isalpha',\n",
335 | " 'isascii',\n",
336 | " 'isdecimal',\n",
337 | " 'isdigit',\n",
338 | " 'isidentifier',\n",
339 | " 'islower',\n",
340 | " 'isnumeric',\n",
341 | " 'isprintable',\n",
342 | " 'isspace',\n",
343 | " 'istitle',\n",
344 | " 'isupper',\n",
345 | " 'join',\n",
346 | " 'ljust',\n",
347 | " 'lower',\n",
348 | " 'lstrip',\n",
349 | " 'maketrans',\n",
350 | " 'partition',\n",
351 | " 'replace',\n",
352 | " 'rfind',\n",
353 | " 'rindex',\n",
354 | " 'rjust',\n",
355 | " 'rpartition',\n",
356 | " 'rsplit',\n",
357 | " 'rstrip',\n",
358 | " 'split',\n",
359 | " 'splitlines',\n",
360 | " 'startswith',\n",
361 | " 'strip',\n",
362 | " 'swapcase',\n",
363 | " 'title',\n",
364 | " 'translate',\n",
365 | " 'upper',\n",
366 | " 'zfill']"
367 | ]
368 | },
369 | "execution_count": 22,
370 | "metadata": {},
371 | "output_type": "execute_result"
372 | }
373 | ],
374 | "source": [
375 | "dir(nome)"
376 | ]
377 | },
378 | {
379 | "cell_type": "markdown",
380 | "metadata": {},
381 | "source": [
382 | "### Usando métodos\n",
383 | "Métodos podem ser acessados usando: objeto.metodo"
384 | ]
385 | },
386 | {
387 | "cell_type": "code",
388 | "execution_count": 25,
389 | "metadata": {},
390 | "outputs": [
391 | {
392 | "data": {
393 | "text/plain": [
394 | "'Luke skywalker'"
395 | ]
396 | },
397 | "execution_count": 25,
398 | "metadata": {},
399 | "output_type": "execute_result"
400 | }
401 | ],
402 | "source": [
403 | "nome"
404 | ]
405 | },
406 | {
407 | "cell_type": "code",
408 | "execution_count": 26,
409 | "metadata": {},
410 | "outputs": [
411 | {
412 | "data": {
413 | "text/plain": [
414 | "'LUKE SKYWALKER'"
415 | ]
416 | },
417 | "execution_count": 26,
418 | "metadata": {},
419 | "output_type": "execute_result"
420 | }
421 | ],
422 | "source": [
423 | "nome.upper()"
424 | ]
425 | },
426 | {
427 | "cell_type": "markdown",
428 | "metadata": {},
429 | "source": [
430 | "### Atribuição Múltipla"
431 | ]
432 | },
433 | {
434 | "cell_type": "code",
435 | "execution_count": 27,
436 | "metadata": {},
437 | "outputs": [],
438 | "source": [
439 | "nome, idade, peso = 'Yoda', 1000, 10.5"
440 | ]
441 | },
442 | {
443 | "cell_type": "code",
444 | "execution_count": 28,
445 | "metadata": {},
446 | "outputs": [
447 | {
448 | "name": "stdout",
449 | "output_type": "stream",
450 | "text": [
451 | "Yoda 1000 10.5\n"
452 | ]
453 | }
454 | ],
455 | "source": [
456 | "print(nome, idade, peso)"
457 | ]
458 | },
459 | {
460 | "cell_type": "markdown",
461 | "metadata": {},
462 | "source": [
463 | "### Python é uma linguagem *case-sensitive*"
464 | ]
465 | },
466 | {
467 | "cell_type": "code",
468 | "execution_count": 29,
469 | "metadata": {},
470 | "outputs": [
471 | {
472 | "name": "stdout",
473 | "output_type": "stream",
474 | "text": [
475 | "15\n"
476 | ]
477 | }
478 | ],
479 | "source": [
480 | "a = 10\n",
481 | "b = 5\n",
482 | "c = a + b\n",
483 | "print(c)"
484 | ]
485 | },
486 | {
487 | "cell_type": "code",
488 | "execution_count": 30,
489 | "metadata": {},
490 | "outputs": [
491 | {
492 | "name": "stdout",
493 | "output_type": "stream",
494 | "text": [
495 | "11\n"
496 | ]
497 | }
498 | ],
499 | "source": [
500 | "B = 1\n",
501 | "d = a + B\n",
502 | "print(d)"
503 | ]
504 | },
505 | {
506 | "cell_type": "markdown",
507 | "metadata": {},
508 | "source": [
509 | "### Dinamicamente e Fortemente tipada\n",
510 | "\n",
511 | "**Dinamicamente:** o tipo é definido no momento da atribuição
\n",
512 | "**Fortemente:** o interpretador não muda o tipo de uma variável inesperadamente"
513 | ]
514 | },
515 | {
516 | "cell_type": "code",
517 | "execution_count": 34,
518 | "metadata": {},
519 | "outputs": [
520 | {
521 | "data": {
522 | "text/plain": [
523 | "10"
524 | ]
525 | },
526 | "execution_count": 34,
527 | "metadata": {},
528 | "output_type": "execute_result"
529 | }
530 | ],
531 | "source": [
532 | "a"
533 | ]
534 | },
535 | {
536 | "cell_type": "code",
537 | "execution_count": 36,
538 | "metadata": {},
539 | "outputs": [
540 | {
541 | "name": "stdout",
542 | "output_type": "stream",
543 | "text": [
544 | "\n",
545 | "\n"
546 | ]
547 | }
548 | ],
549 | "source": [
550 | "print(type(a))\n",
551 | "\n",
552 | "a = '10'\n",
553 | "print(type(a))"
554 | ]
555 | },
556 | {
557 | "cell_type": "code",
558 | "execution_count": 38,
559 | "metadata": {},
560 | "outputs": [
561 | {
562 | "ename": "TypeError",
563 | "evalue": "can only concatenate str (not \"int\") to str",
564 | "output_type": "error",
565 | "traceback": [
566 | "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
567 | "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
568 | "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mc\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[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
569 | "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
570 | ]
571 | }
572 | ],
573 | "source": [
574 | "c = a + b"
575 | ]
576 | },
577 | {
578 | "cell_type": "code",
579 | "execution_count": 39,
580 | "metadata": {},
581 | "outputs": [
582 | {
583 | "data": {
584 | "text/plain": [
585 | "'Luke Skywalker'"
586 | ]
587 | },
588 | "execution_count": 39,
589 | "metadata": {},
590 | "output_type": "execute_result"
591 | }
592 | ],
593 | "source": [
594 | "'Luke ' + 'Skywalker'"
595 | ]
596 | },
597 | {
598 | "cell_type": "markdown",
599 | "metadata": {},
600 | "source": [
601 | "### Conversão de Tipos (*Casting*)"
602 | ]
603 | },
604 | {
605 | "cell_type": "code",
606 | "execution_count": 40,
607 | "metadata": {},
608 | "outputs": [
609 | {
610 | "data": {
611 | "text/plain": [
612 | "'10'"
613 | ]
614 | },
615 | "execution_count": 40,
616 | "metadata": {},
617 | "output_type": "execute_result"
618 | }
619 | ],
620 | "source": [
621 | "a"
622 | ]
623 | },
624 | {
625 | "cell_type": "code",
626 | "execution_count": 41,
627 | "metadata": {},
628 | "outputs": [
629 | {
630 | "data": {
631 | "text/plain": [
632 | "5"
633 | ]
634 | },
635 | "execution_count": 41,
636 | "metadata": {},
637 | "output_type": "execute_result"
638 | }
639 | ],
640 | "source": [
641 | "b"
642 | ]
643 | },
644 | {
645 | "cell_type": "code",
646 | "execution_count": 43,
647 | "metadata": {},
648 | "outputs": [
649 | {
650 | "name": "stdout",
651 | "output_type": "stream",
652 | "text": [
653 | "15\n"
654 | ]
655 | }
656 | ],
657 | "source": [
658 | "# a função retorna uma cópia convertida do que foi passado pra ela, ou seja, ela não altera\n",
659 | "# a variável (ou valor) que foi passado pra ela\n",
660 | "c = int(a) + b\n",
661 | "print(c)"
662 | ]
663 | },
664 | {
665 | "cell_type": "code",
666 | "execution_count": 44,
667 | "metadata": {},
668 | "outputs": [
669 | {
670 | "data": {
671 | "text/plain": [
672 | "'10'"
673 | ]
674 | },
675 | "execution_count": 44,
676 | "metadata": {},
677 | "output_type": "execute_result"
678 | }
679 | ],
680 | "source": [
681 | "a"
682 | ]
683 | },
684 | {
685 | "cell_type": "markdown",
686 | "metadata": {},
687 | "source": [
688 | "### Operadores Aritméticos\n",
689 | "\n",
690 | "| Operador | Nome | Descrição |\n",
691 | "|--------------|----------------------|--------------------------------------------------------------------------------------|\n",
692 | "| ``a + b`` | Adição | Soma de ``a`` e ``b`` |\n",
693 | "| ``a - b`` | Subtração | Diferença de ``a`` e ``b`` |\n",
694 | "| ``a * b`` | Multiplicação | Produto de ``a`` e ``b`` |\n",
695 | "| ``a / b`` | Divisão 'verdadeira' | Quociente de ``a`` e ``b`` |\n",
696 | "| ``a // b`` | Piso da Divisão | Quociente de ``a`` e ``b``, removendo partes fracionadas (arredondamento para baixo) |\n",
697 | "| ``a % b`` | Módulo | Resto da divisão de a ``a`` por ``b`` |\n",
698 | "| ``a ** b`` | Exponenciação | ``a`` elevado a ``b`` |\n",
699 | "| ``-a`` | Negação | Negativo de ``a`` |"
700 | ]
701 | },
702 | {
703 | "cell_type": "code",
704 | "execution_count": 46,
705 | "metadata": {},
706 | "outputs": [
707 | {
708 | "name": "stdout",
709 | "output_type": "stream",
710 | "text": [
711 | "2.5\n",
712 | "3.0\n",
713 | "3.0\n"
714 | ]
715 | }
716 | ],
717 | "source": [
718 | "# Divisão 'verdadeira'\n",
719 | "print(5 / 2)\n",
720 | "print(6 / 2)\n",
721 | "print(6 / 2.0)"
722 | ]
723 | },
724 | {
725 | "cell_type": "code",
726 | "execution_count": 48,
727 | "metadata": {},
728 | "outputs": [
729 | {
730 | "name": "stdout",
731 | "output_type": "stream",
732 | "text": [
733 | "2\n",
734 | "2.0\n",
735 | "3\n",
736 | "3.0\n"
737 | ]
738 | }
739 | ],
740 | "source": [
741 | "# Piso da divisão - ignora os decimais do resultado\n",
742 | "print(5 // 2)\n",
743 | "print(5 // 2.0)\n",
744 | "print(6 // 2)\n",
745 | "print(6 // 2.0)"
746 | ]
747 | },
748 | {
749 | "cell_type": "markdown",
750 | "metadata": {},
751 | "source": [
752 | "### A função print()\n",
753 | "A função _print()_ imprime uma string na tela/console.
\n",
754 | "Uma string pode ser definida com **aspas simples ''** ou **aspas duplas \"\"**.\n",
755 | "\n",
756 | "Por convenção, a comunidade usa **aspas simples ''**"
757 | ]
758 | },
759 | {
760 | "cell_type": "code",
761 | "execution_count": 49,
762 | "metadata": {},
763 | "outputs": [
764 | {
765 | "name": "stdout",
766 | "output_type": "stream",
767 | "text": [
768 | "Imprimindo com aspas simples!\n",
769 | "Imprimindo com aspas duplas!\n"
770 | ]
771 | }
772 | ],
773 | "source": [
774 | "print('Imprimindo com aspas simples!')\n",
775 | "print(\"Imprimindo com aspas duplas!\")"
776 | ]
777 | },
778 | {
779 | "cell_type": "markdown",
780 | "metadata": {},
781 | "source": [
782 | "
Para imprimir valores de _variáveis_ junto com uma _string/texto_, utilize a letra **_f_** antes das primeiras aspas, e coloque a variável entre **_{}_** (Python 3.6+):"
783 | ]
784 | },
785 | {
786 | "cell_type": "code",
787 | "execution_count": 50,
788 | "metadata": {},
789 | "outputs": [
790 | {
791 | "data": {
792 | "text/plain": [
793 | "('Yoda', 1000, 10.5)"
794 | ]
795 | },
796 | "execution_count": 50,
797 | "metadata": {},
798 | "output_type": "execute_result"
799 | }
800 | ],
801 | "source": [
802 | "nome, idade, peso"
803 | ]
804 | },
805 | {
806 | "cell_type": "code",
807 | "execution_count": 51,
808 | "metadata": {},
809 | "outputs": [
810 | {
811 | "name": "stdout",
812 | "output_type": "stream",
813 | "text": [
814 | "Meu nome eh Yoda\n",
815 | "Tenho 1000 anos\n",
816 | "Peso 10.5 kg\n"
817 | ]
818 | }
819 | ],
820 | "source": [
821 | "print(f'Meu nome eh {r}')\n",
822 | "print(f'Tenho {idade} anos')\n",
823 | "print(f'Peso {peso} kg')"
824 | ]
825 | },
826 | {
827 | "cell_type": "code",
828 | "execution_count": 52,
829 | "metadata": {},
830 | "outputs": [
831 | {
832 | "name": "stdout",
833 | "output_type": "stream",
834 | "text": [
835 | "Meu nome eh Yoda\n",
836 | "Tenho 1000 anos\n",
837 | "Peso 10.5 kg\n"
838 | ]
839 | }
840 | ],
841 | "source": [
842 | "print(f'Meu nome eh {nome}\\nTenho {idade} anos\\nPeso {peso} kg')"
843 | ]
844 | },
845 | {
846 | "cell_type": "markdown",
847 | "metadata": {},
848 | "source": [
849 | "
\n",
850 | "Alternativa, temos outras formas de impressão vindas de versões mais antigas do Python, porém ainda válidas:"
851 | ]
852 | },
853 | {
854 | "cell_type": "code",
855 | "execution_count": 57,
856 | "metadata": {},
857 | "outputs": [
858 | {
859 | "name": "stdout",
860 | "output_type": "stream",
861 | "text": [
862 | "Meu nome eh Yoda\n",
863 | "Tenho 1000 anos\n",
864 | "Peso 10.5 kg\n",
865 | "\n",
866 | "Meu nome eh Yoda\n",
867 | "Tenho 1000 anos\n",
868 | "Peso 10.5 kg\n"
869 | ]
870 | }
871 | ],
872 | "source": [
873 | "# usando .format\n",
874 | "print('Meu nome eh {}'.format(nome))\n",
875 | "print('Tenho {} anos'.format(idade))\n",
876 | "print('Peso {} kg\\n'.format(peso))\n",
877 | "\n",
878 | "print('Meu nome eh {0}\\nTenho {1} anos\\nPeso {2} kg'.format(nome, idade, peso))"
879 | ]
880 | },
881 | {
882 | "cell_type": "code",
883 | "execution_count": 59,
884 | "metadata": {},
885 | "outputs": [
886 | {
887 | "name": "stdout",
888 | "output_type": "stream",
889 | "text": [
890 | "Meu nome eh Yoda\n",
891 | "Tenho 1000 anos\n",
892 | "Peso 10.500000 kg\n",
893 | "\n",
894 | "Meu nome eh Yoda\n",
895 | "Tenho 1000 anos\n",
896 | "Peso 10.500000 kg\n"
897 | ]
898 | }
899 | ],
900 | "source": [
901 | "# usando % (é o jeito mais próximo de C)\n",
902 | "print('Meu nome eh %s' % nome)\n",
903 | "print('Tenho %d anos' % idade)\n",
904 | "print('Peso %f kg\\n' % peso)\n",
905 | "\n",
906 | "print('Meu nome eh %s\\nTenho %d anos\\nPeso %f kg' % (nome, idade, peso))"
907 | ]
908 | }
909 | ],
910 | "metadata": {
911 | "kernelspec": {
912 | "display_name": "Python 3",
913 | "language": "python",
914 | "name": "python3"
915 | },
916 | "language_info": {
917 | "codemirror_mode": {
918 | "name": "ipython",
919 | "version": 3
920 | },
921 | "file_extension": ".py",
922 | "mimetype": "text/x-python",
923 | "name": "python",
924 | "nbconvert_exporter": "python",
925 | "pygments_lexer": "ipython3",
926 | "version": "3.8.5"
927 | }
928 | },
929 | "nbformat": 4,
930 | "nbformat_minor": 4
931 | }
932 |
--------------------------------------------------------------------------------
/02_funcoes.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "## **Python Essencial para Data Science**\n",
8 | "**Prof. Dr. Samuel Martins (@hisamuka @xavecoding)**
\n",
9 | "xavecoding: https://youtube.com/c/xavecoding
\n",
10 | "\n",
11 | "
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License."
12 | ]
13 | },
14 | {
15 | "cell_type": "markdown",
16 | "metadata": {},
17 | "source": [
18 | "## Funções\n",
19 | "\n",
20 | "### Esqueleto de uma função em python:\n",
21 | "\n",
22 | "def functionName(param1, param2, param3=val):\n",
23 | " instruction 01\n",
24 | " instruction 02\n",
25 | " return X\n",
26 | ""
27 | ]
28 | },
29 | {
30 | "cell_type": "markdown",
31 | "metadata": {},
32 | "source": [
33 | "### Funções podem NÃO ter retorno"
34 | ]
35 | },
36 | {
37 | "cell_type": "code",
38 | "execution_count": 2,
39 | "metadata": {},
40 | "outputs": [
41 | {
42 | "name": "stdout",
43 | "output_type": "stream",
44 | "text": [
45 | "Imprimindo a variavel x\n",
46 | "10\n",
47 | "\n",
48 | "Imprimindo a variavel x\n",
49 | "Darth Vader\n",
50 | "\n"
51 | ]
52 | }
53 | ],
54 | "source": [
55 | "def print_parametro(x):\n",
56 | " print('Imprimindo a variavel x')\n",
57 | " print(x)\n",
58 | " print('')\n",
59 | "\n",
60 | "a = 10\n",
61 | "print_parametro(a)\n",
62 | "\n",
63 | "nome = 'Darth Vader'\n",
64 | "print_parametro(nome)"
65 | ]
66 | },
67 | {
68 | "cell_type": "markdown",
69 | "metadata": {},
70 | "source": [
71 | "### Funções podem ter retorno"
72 | ]
73 | },
74 | {
75 | "cell_type": "code",
76 | "execution_count": 7,
77 | "metadata": {},
78 | "outputs": [
79 | {
80 | "name": "stdout",
81 | "output_type": "stream",
82 | "text": [
83 | "30\n"
84 | ]
85 | }
86 | ],
87 | "source": [
88 | "def soma(x, y):\n",
89 | " return x + y\n",
90 | "\n",
91 | "a = 10\n",
92 | "b = 20\n",
93 | "c = soma(a, b)\n",
94 | "\n",
95 | "print(c)"
96 | ]
97 | },
98 | {
99 | "cell_type": "code",
100 | "execution_count": 8,
101 | "metadata": {},
102 | "outputs": [
103 | {
104 | "data": {
105 | "text/plain": [
106 | "function"
107 | ]
108 | },
109 | "execution_count": 8,
110 | "metadata": {},
111 | "output_type": "execute_result"
112 | }
113 | ],
114 | "source": [
115 | "type(soma)"
116 | ]
117 | },
118 | {
119 | "cell_type": "markdown",
120 | "metadata": {},
121 | "source": [
122 | "### Funções podem ter múltiplos retornos"
123 | ]
124 | },
125 | {
126 | "cell_type": "code",
127 | "execution_count": 11,
128 | "metadata": {},
129 | "outputs": [
130 | {
131 | "name": "stdout",
132 | "output_type": "stream",
133 | "text": [
134 | "\n",
135 | "10 + 20 = 30\n",
136 | "10 - 20 = -10\n"
137 | ]
138 | }
139 | ],
140 | "source": [
141 | "def soma_e_subtracao(x, y):\n",
142 | " soma = x + y\n",
143 | " sub = x - y\n",
144 | " print(type(soma))\n",
145 | " \n",
146 | " return soma, sub\n",
147 | "\n",
148 | "a = 10\n",
149 | "b = 20\n",
150 | "\n",
151 | "soma_ab, sub_ab = soma_e_subtracao(a, b)\n",
152 | "print(f'{a} + {b} = {soma_ab}\\n{a} - {b} = {sub_ab}')"
153 | ]
154 | },
155 | {
156 | "cell_type": "code",
157 | "execution_count": 12,
158 | "metadata": {},
159 | "outputs": [
160 | {
161 | "data": {
162 | "text/plain": [
163 | "function"
164 | ]
165 | },
166 | "execution_count": 12,
167 | "metadata": {},
168 | "output_type": "execute_result"
169 | }
170 | ],
171 | "source": [
172 | "type(soma)"
173 | ]
174 | },
175 | {
176 | "cell_type": "markdown",
177 | "metadata": {},
178 | "source": [
179 | "### Escopo\n",
180 | "Todo **escopo** em Python (funções, loops, condicionais, classes, etc...) usam *dois pontos (:)* e *identação*:\n",
181 | "Os **dois pontos (:)** servem para _\"abrir\"_ o escopo, e _cada instrução_ dentro do escopo devem ser **identadas** à direita.\n",
182 | "\n",
183 | "Convenciona-se usar *espaços* ao invés de *tabs* para a **identação**. Todas as instruções do escopo **devem ter a mesma identação** (p. ex, a mesma quantidade de espaços)."
184 | ]
185 | },
186 | {
187 | "cell_type": "markdown",
188 | "metadata": {},
189 | "source": [
190 | "\n",
191 | "def functionName(param1, param2, param3=val):\n",
192 | " instruction 01 # 4 espaços de identação\n",
193 | " instruction 02 # 4 espaços de identação\n",
194 | " return X # 4 espaços de identação\n",
195 | ""
196 | ]
197 | },
198 | {
199 | "cell_type": "markdown",
200 | "metadata": {},
201 | "source": [
202 | "### Funções com parâmetros default (opcionais)"
203 | ]
204 | },
205 | {
206 | "cell_type": "markdown",
207 | "metadata": {},
208 | "source": [
209 | "Os parâmetros opcionais (ou seja, com valores _default_) devem sempre serem **os últimos parâmetros da função**."
210 | ]
211 | },
212 | {
213 | "cell_type": "code",
214 | "execution_count": 16,
215 | "metadata": {},
216 | "outputs": [],
217 | "source": [
218 | "def cadastrar_usuario(sistema, login='user', senha='123'):\n",
219 | " print(f'Cadastro de usuários no sistema {sistema}')\n",
220 | " print(f'login: {login}')\n",
221 | " print(f'senha: {senha}')"
222 | ]
223 | },
224 | {
225 | "cell_type": "code",
226 | "execution_count": 17,
227 | "metadata": {},
228 | "outputs": [
229 | {
230 | "name": "stdout",
231 | "output_type": "stream",
232 | "text": [
233 | "Cadastro de usuários no sistema Google\n",
234 | "login: samuka\n",
235 | "senha: python_essencial_senha\n"
236 | ]
237 | }
238 | ],
239 | "source": [
240 | "sistema_1 = 'Google'\n",
241 | "login_1 = 'samuka'\n",
242 | "senha_1 = 'python_essencial_senha'\n",
243 | "\n",
244 | "cadastrar_usuario(sistema_1, login_1, senha_1)"
245 | ]
246 | },
247 | {
248 | "cell_type": "markdown",
249 | "metadata": {},
250 | "source": [
251 | "
\n",
252 | "Caso o parâmetro não seja chamado, seu valor default é usado."
253 | ]
254 | },
255 | {
256 | "cell_type": "code",
257 | "execution_count": 18,
258 | "metadata": {},
259 | "outputs": [
260 | {
261 | "name": "stdout",
262 | "output_type": "stream",
263 | "text": [
264 | "Cadastro de usuários no sistema Facebook\n",
265 | "login: ze\n",
266 | "senha: 123\n"
267 | ]
268 | }
269 | ],
270 | "source": [
271 | "sistema_2 = 'Facebook'\n",
272 | "login_2 = 'ze'\n",
273 | "\n",
274 | "cadastrar_usuario(sistema_2, login_2)"
275 | ]
276 | },
277 | {
278 | "cell_type": "code",
279 | "execution_count": 19,
280 | "metadata": {},
281 | "outputs": [
282 | {
283 | "name": "stdout",
284 | "output_type": "stream",
285 | "text": [
286 | "Cadastro de usuários no sistema GitHub\n",
287 | "login: user\n",
288 | "senha: 123\n"
289 | ]
290 | }
291 | ],
292 | "source": [
293 | "cadastrar_usuario('GitHub')"
294 | ]
295 | },
296 | {
297 | "cell_type": "code",
298 | "execution_count": 22,
299 | "metadata": {},
300 | "outputs": [
301 | {
302 | "ename": "SyntaxError",
303 | "evalue": "non-default argument follows default argument (, line 3)",
304 | "output_type": "error",
305 | "traceback": [
306 | "\u001b[0;36m File \u001b[0;32m\"\"\u001b[0;36m, line \u001b[0;32m3\u001b[0m\n\u001b[0;31m def login_no_sistema(login='user', senha):\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m non-default argument follows default argument\n"
307 | ]
308 | }
309 | ],
310 | "source": [
311 | "#### NÃO FUNCIONA pq o argumento/parâmetro com valor default (padrão), login, não está\n",
312 | "# no final dos argumentos da função\n",
313 | "def login_no_sistema(login='user', senha):\n",
314 | " print(f'login: {login}')\n",
315 | " print(f'senha: {senha}')"
316 | ]
317 | },
318 | {
319 | "cell_type": "markdown",
320 | "metadata": {},
321 | "source": [
322 | "### Parâmetros Nomeados\n",
323 | "Ao chamar uma função, podemos passar seus parâmetros em qualquer ordem. Basta que informemos o nome do argumento/parâmetro da função."
324 | ]
325 | },
326 | {
327 | "cell_type": "code",
328 | "execution_count": 23,
329 | "metadata": {},
330 | "outputs": [
331 | {
332 | "name": "stdout",
333 | "output_type": "stream",
334 | "text": [
335 | "Cadastro de usuários no sistema YouTube\n",
336 | "login: user\n",
337 | "senha: abcdef\n"
338 | ]
339 | }
340 | ],
341 | "source": [
342 | "cadastrar_usuario(senha='abcdef', sistema='YouTube')"
343 | ]
344 | },
345 | {
346 | "cell_type": "markdown",
347 | "metadata": {},
348 | "source": [
349 | "### Function Annotations (PEP 3107)\n",
350 | "Há a possibilidade de **indicar** o tipo de parâmetros e o tipo de retorno de funções em Python.
\n",
351 | "Isso se chama _function annotation_.\n",
352 | "\n",
353 | "Os tipos indicados **apenas** servem como indicativo ao programador dos tipos de dados esperados.
\n",
354 | "Algumas bibliotecas externas também podem interpretar tais \"metas anotações\" para algum propósito.\n",
355 | "\n",
356 | "Portanto, o interpretador python **NÃO** leva essas anotações de tipos em consideração durante sua execução."
357 | ]
358 | },
359 | {
360 | "cell_type": "code",
361 | "execution_count": 24,
362 | "metadata": {},
363 | "outputs": [],
364 | "source": [
365 | "def soma_de_inteiros(x: int, y: int) -> int:\n",
366 | " return x + y"
367 | ]
368 | },
369 | {
370 | "cell_type": "code",
371 | "execution_count": 25,
372 | "metadata": {},
373 | "outputs": [
374 | {
375 | "data": {
376 | "text/plain": [
377 | "30"
378 | ]
379 | },
380 | "execution_count": 25,
381 | "metadata": {},
382 | "output_type": "execute_result"
383 | }
384 | ],
385 | "source": [
386 | "soma_de_inteiros(10, 20)"
387 | ]
388 | },
389 | {
390 | "cell_type": "markdown",
391 | "metadata": {},
392 | "source": [
393 | "Parâmetros de outros tipos são aceitos e processados normalmente."
394 | ]
395 | },
396 | {
397 | "cell_type": "code",
398 | "execution_count": 27,
399 | "metadata": {},
400 | "outputs": [
401 | {
402 | "data": {
403 | "text/plain": [
404 | "4.5"
405 | ]
406 | },
407 | "execution_count": 27,
408 | "metadata": {},
409 | "output_type": "execute_result"
410 | }
411 | ],
412 | "source": [
413 | "soma_de_inteiros(1.5, 3)"
414 | ]
415 | },
416 | {
417 | "cell_type": "markdown",
418 | "metadata": {},
419 | "source": [
420 | "### Comentários e Docstring\n",
421 | "Em Python, comentários são definidos de duas maneiras:\n",
422 | "\n",
423 | "1. Utilizando # (comentário de uma linha só)"
424 | ]
425 | },
426 | {
427 | "cell_type": "code",
428 | "execution_count": 10,
429 | "metadata": {},
430 | "outputs": [],
431 | "source": [
432 | "# este é um comentário de uma linha só"
433 | ]
434 | },
435 | {
436 | "cell_type": "markdown",
437 | "metadata": {},
438 | "source": [
439 | "2. Usando _Docstrings_ (múltiplas linhas)"
440 | ]
441 | },
442 | {
443 | "cell_type": "code",
444 | "execution_count": 11,
445 | "metadata": {},
446 | "outputs": [
447 | {
448 | "data": {
449 | "text/plain": [
450 | "'Este é um comentário\\nde múltiplas\\nlinhas'"
451 | ]
452 | },
453 | "execution_count": 11,
454 | "metadata": {},
455 | "output_type": "execute_result"
456 | }
457 | ],
458 | "source": [
459 | "'''Este é um comentário\n",
460 | "de múltiplas\n",
461 | "linhas'''\n"
462 | ]
463 | },
464 | {
465 | "cell_type": "code",
466 | "execution_count": 12,
467 | "metadata": {},
468 | "outputs": [
469 | {
470 | "data": {
471 | "text/plain": [
472 | "'Este é outro comentário\\nde múltiplas\\nlinhas'"
473 | ]
474 | },
475 | "execution_count": 12,
476 | "metadata": {},
477 | "output_type": "execute_result"
478 | }
479 | ],
480 | "source": [
481 | "\"\"\"Este é outro comentário\n",
482 | "de múltiplas\n",
483 | "linhas\"\"\""
484 | ]
485 | },
486 | {
487 | "cell_type": "markdown",
488 | "metadata": {},
489 | "source": [
490 | "
\n",
491 | "Docstrings podem ser usados para documentar funções:"
492 | ]
493 | },
494 | {
495 | "cell_type": "code",
496 | "execution_count": 28,
497 | "metadata": {},
498 | "outputs": [
499 | {
500 | "name": "stdout",
501 | "output_type": "stream",
502 | "text": [
503 | "Help on class type in module builtins:\n",
504 | "\n",
505 | "class type(object)\n",
506 | " | type(object_or_name, bases, dict)\n",
507 | " | type(object) -> the object's type\n",
508 | " | type(name, bases, dict) -> a new type\n",
509 | " | \n",
510 | " | Methods defined here:\n",
511 | " | \n",
512 | " | __call__(self, /, *args, **kwargs)\n",
513 | " | Call self as a function.\n",
514 | " | \n",
515 | " | __delattr__(self, name, /)\n",
516 | " | Implement delattr(self, name).\n",
517 | " | \n",
518 | " | __dir__(self, /)\n",
519 | " | Specialized __dir__ implementation for types.\n",
520 | " | \n",
521 | " | __getattribute__(self, name, /)\n",
522 | " | Return getattr(self, name).\n",
523 | " | \n",
524 | " | __init__(self, /, *args, **kwargs)\n",
525 | " | Initialize self. See help(type(self)) for accurate signature.\n",
526 | " | \n",
527 | " | __instancecheck__(self, instance, /)\n",
528 | " | Check if an object is an instance.\n",
529 | " | \n",
530 | " | __repr__(self, /)\n",
531 | " | Return repr(self).\n",
532 | " | \n",
533 | " | __setattr__(self, name, value, /)\n",
534 | " | Implement setattr(self, name, value).\n",
535 | " | \n",
536 | " | __sizeof__(self, /)\n",
537 | " | Return memory consumption of the type object.\n",
538 | " | \n",
539 | " | __subclasscheck__(self, subclass, /)\n",
540 | " | Check if a class is a subclass.\n",
541 | " | \n",
542 | " | __subclasses__(self, /)\n",
543 | " | Return a list of immediate subclasses.\n",
544 | " | \n",
545 | " | mro(self, /)\n",
546 | " | Return a type's method resolution order.\n",
547 | " | \n",
548 | " | ----------------------------------------------------------------------\n",
549 | " | Class methods defined here:\n",
550 | " | \n",
551 | " | __prepare__(...)\n",
552 | " | __prepare__() -> dict\n",
553 | " | used to create the namespace for the class statement\n",
554 | " | \n",
555 | " | ----------------------------------------------------------------------\n",
556 | " | Static methods defined here:\n",
557 | " | \n",
558 | " | __new__(*args, **kwargs)\n",
559 | " | Create and return a new object. See help(type) for accurate signature.\n",
560 | " | \n",
561 | " | ----------------------------------------------------------------------\n",
562 | " | Data descriptors defined here:\n",
563 | " | \n",
564 | " | __abstractmethods__\n",
565 | " | \n",
566 | " | __dict__\n",
567 | " | \n",
568 | " | __text_signature__\n",
569 | " | \n",
570 | " | ----------------------------------------------------------------------\n",
571 | " | Data and other attributes defined here:\n",
572 | " | \n",
573 | " | __base__ = \n",
574 | " | The base class of the class hierarchy.\n",
575 | " | \n",
576 | " | When called, it accepts no arguments and returns a new featureless\n",
577 | " | instance that has no instance attributes and cannot be given any.\n",
578 | " | \n",
579 | " | __bases__ = (,)\n",
580 | " | \n",
581 | " | __basicsize__ = 880\n",
582 | " | \n",
583 | " | __dictoffset__ = 264\n",
584 | " | \n",
585 | " | __flags__ = 2148291584\n",
586 | " | \n",
587 | " | __itemsize__ = 40\n",
588 | " | \n",
589 | " | __mro__ = (, )\n",
590 | " | \n",
591 | " | __weakrefoffset__ = 368\n",
592 | "\n"
593 | ]
594 | }
595 | ],
596 | "source": [
597 | "help(type)"
598 | ]
599 | },
600 | {
601 | "cell_type": "code",
602 | "execution_count": 29,
603 | "metadata": {},
604 | "outputs": [],
605 | "source": [
606 | "def soma(x, y):\n",
607 | " r\n",
608 | " return x + y"
609 | ]
610 | },
611 | {
612 | "cell_type": "markdown",
613 | "metadata": {},
614 | "source": [
615 | "
\n",
616 | "Quando uma função (ou classe) está documentada usando _docstring_, é possível usar a função **help()** para ler a documentação:"
617 | ]
618 | },
619 | {
620 | "cell_type": "code",
621 | "execution_count": 30,
622 | "metadata": {},
623 | "outputs": [
624 | {
625 | "name": "stdout",
626 | "output_type": "stream",
627 | "text": [
628 | "Help on function soma in module __main__:\n",
629 | "\n",
630 | "soma(x, y)\n",
631 | " Esta função soma dois números inteiros.\n",
632 | " \n",
633 | " Parameters:\n",
634 | " x (int): Primeiro número inteiro.\n",
635 | " y (int): Segundo número inteiro.\n",
636 | " \n",
637 | " Returns:\n",
638 | " int: Soma resultante\n",
639 | "\n"
640 | ]
641 | }
642 | ],
643 | "source": [
644 | "help(soma)"
645 | ]
646 | }
647 | ],
648 | "metadata": {
649 | "kernelspec": {
650 | "display_name": "Python 3",
651 | "language": "python",
652 | "name": "python3"
653 | },
654 | "language_info": {
655 | "codemirror_mode": {
656 | "name": "ipython",
657 | "version": 3
658 | },
659 | "file_extension": ".py",
660 | "mimetype": "text/x-python",
661 | "name": "python",
662 | "nbconvert_exporter": "python",
663 | "pygments_lexer": "ipython3",
664 | "version": "3.8.5"
665 | }
666 | },
667 | "nbformat": 4,
668 | "nbformat_minor": 4
669 | }
670 |
--------------------------------------------------------------------------------
/03_condicionais.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "## **Python Essencial para Data Science**\n",
8 | "**Prof. Dr. Samuel Martins (@hisamuka @xavecoding)**
\n",
9 | "xavecoding: https://youtube.com/c/xavecoding
\n",
10 | "\n",
11 | "
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License."
12 | ]
13 | },
14 | {
15 | "cell_type": "markdown",
16 | "metadata": {},
17 | "source": [
18 | "## Condicionais\n",
19 | "\n",
20 | "### Estrutura básica de um IF:\n",
21 | "\n",
22 | "if condition 01:\n",
23 | " Instruction 01\n",
24 | " Instruction 02\n",
25 | "else:\n",
26 | " Instruction 03\n",
27 | " Instruction 04\n",
28 | ""
29 | ]
30 | },
31 | {
32 | "cell_type": "markdown",
33 | "metadata": {},
34 | "source": [
35 | "Note que as **identações** definem o _escopo_ de cada opção resultante do IF.\n",
36 | "\n",
37 | "As condições devem resultar um valor boolean (True ou False)."
38 | ]
39 | },
40 | {
41 | "cell_type": "markdown",
42 | "metadata": {},
43 | "source": [
44 | "\n",
45 | "if condition 01:\n",
46 | " Instruction 01\n",
47 | " Instruction 02\n",
48 | "elif (condition 02):\n",
49 | " Instruction 03\n",
50 | " Instruction 04\n",
51 | "else:\n",
52 | " Instruction 05\n",
53 | " Instruction 06\n",
54 | ""
55 | ]
56 | },
57 | {
58 | "cell_type": "markdown",
59 | "metadata": {},
60 | "source": [
61 | "### Operadores de Comparação\n",
62 | "\n",
63 | "| Operação | Descrição || Operação | Descrição |\n",
64 | "|---------------|-------------------------------------||---------------|-------------------------------------|\n",
65 | "| ``a == b`` | ``a`` igual a ``b`` || ``a != b`` | ``a`` diferente de ``b`` |\n",
66 | "| ``a < b`` | ``a`` menor do que ``b`` || ``a > b`` | ``a`` maior do que ``b`` |\n",
67 | "| ``a <= b`` | ``a`` menor do que ou igual a ``b`` || ``a >= b`` | ``a`` maior do que ou igual a ``b`` |"
68 | ]
69 | },
70 | {
71 | "cell_type": "code",
72 | "execution_count": 2,
73 | "metadata": {},
74 | "outputs": [
75 | {
76 | "name": "stdout",
77 | "output_type": "stream",
78 | "text": [
79 | "Menor de idade\n"
80 | ]
81 | }
82 | ],
83 | "source": [
84 | "idade = 16\n",
85 | "\n",
86 | "if idade < 18:\n",
87 | " print('Menor de idade')\n",
88 | "else:\n",
89 | " print('Maior de idade')"
90 | ]
91 | },
92 | {
93 | "cell_type": "code",
94 | "execution_count": 4,
95 | "metadata": {},
96 | "outputs": [
97 | {
98 | "name": "stdout",
99 | "output_type": "stream",
100 | "text": [
101 | "Em recuperação\n"
102 | ]
103 | }
104 | ],
105 | "source": [
106 | "# reprovado < 4.0\n",
107 | "# em recuperação: [4.0, 6.0)\n",
108 | "# aprovado >= 6.0\n",
109 | "\n",
110 | "media_final = 5.0\n",
111 | "\n",
112 | "if media_final < 4.0:\n",
113 | " print('Reprovado')\n",
114 | "elif media_final < 6.0:\n",
115 | " print('Em recuperação')\n",
116 | "else:\n",
117 | " print('Aprovado')"
118 | ]
119 | },
120 | {
121 | "cell_type": "markdown",
122 | "metadata": {},
123 | "source": [
124 | "Opcionalmente, podemos usar _parênteses_ nas condições."
125 | ]
126 | },
127 | {
128 | "cell_type": "code",
129 | "execution_count": 5,
130 | "metadata": {},
131 | "outputs": [
132 | {
133 | "name": "stdout",
134 | "output_type": "stream",
135 | "text": [
136 | "Em recuperação\n"
137 | ]
138 | }
139 | ],
140 | "source": [
141 | "# reprovado < 4.0\n",
142 | "# em recuperação: [4.0, 6.0)\n",
143 | "# aprovado >= 6.0\n",
144 | "\n",
145 | "media_final = 5.0\n",
146 | "\n",
147 | "if (media_final < 4.0):\n",
148 | " print('Reprovado')\n",
149 | "elif (media_final < 6.0):\n",
150 | " print('Em recuperação')\n",
151 | "else:\n",
152 | " print('Aprovado')"
153 | ]
154 | },
155 | {
156 | "cell_type": "markdown",
157 | "metadata": {},
158 | "source": [
159 | "### Comparando Booleans"
160 | ]
161 | },
162 | {
163 | "cell_type": "code",
164 | "execution_count": 6,
165 | "metadata": {},
166 | "outputs": [
167 | {
168 | "data": {
169 | "text/plain": [
170 | "(True, False)"
171 | ]
172 | },
173 | "execution_count": 6,
174 | "metadata": {},
175 | "output_type": "execute_result"
176 | }
177 | ],
178 | "source": [
179 | "True, False"
180 | ]
181 | },
182 | {
183 | "cell_type": "code",
184 | "execution_count": 7,
185 | "metadata": {},
186 | "outputs": [
187 | {
188 | "data": {
189 | "text/plain": [
190 | "bool"
191 | ]
192 | },
193 | "execution_count": 7,
194 | "metadata": {},
195 | "output_type": "execute_result"
196 | }
197 | ],
198 | "source": [
199 | "type(True)"
200 | ]
201 | },
202 | {
203 | "cell_type": "code",
204 | "execution_count": 8,
205 | "metadata": {},
206 | "outputs": [
207 | {
208 | "name": "stdout",
209 | "output_type": "stream",
210 | "text": [
211 | "Aluno esta matriculado\n"
212 | ]
213 | }
214 | ],
215 | "source": [
216 | "aluno_esta_matriculado = True\n",
217 | "\n",
218 | "if aluno_esta_matriculado is True:\n",
219 | " print('Aluno esta matriculado')"
220 | ]
221 | },
222 | {
223 | "cell_type": "code",
224 | "execution_count": 9,
225 | "metadata": {},
226 | "outputs": [
227 | {
228 | "name": "stdout",
229 | "output_type": "stream",
230 | "text": [
231 | "Aluno esta matriculado\n"
232 | ]
233 | }
234 | ],
235 | "source": [
236 | "if aluno_esta_matriculado:\n",
237 | " print('Aluno esta matriculado')"
238 | ]
239 | },
240 | {
241 | "cell_type": "code",
242 | "execution_count": 10,
243 | "metadata": {},
244 | "outputs": [
245 | {
246 | "name": "stdout",
247 | "output_type": "stream",
248 | "text": [
249 | "Aluno não é um Jedi\n"
250 | ]
251 | }
252 | ],
253 | "source": [
254 | "aluno_eh_jedi = False\n",
255 | "\n",
256 | "if aluno_eh_jedi is False:\n",
257 | " print('Aluno não é um Jedi')"
258 | ]
259 | },
260 | {
261 | "cell_type": "code",
262 | "execution_count": 12,
263 | "metadata": {},
264 | "outputs": [
265 | {
266 | "name": "stdout",
267 | "output_type": "stream",
268 | "text": [
269 | "Aluno não é um Jedi\n"
270 | ]
271 | }
272 | ],
273 | "source": [
274 | "if not aluno_eh_jedi:\n",
275 | " print('Aluno não é um Jedi')"
276 | ]
277 | },
278 | {
279 | "cell_type": "markdown",
280 | "metadata": {},
281 | "source": [
282 | "### Combinando condições com `and` e`or`"
283 | ]
284 | },
285 | {
286 | "cell_type": "code",
287 | "execution_count": 13,
288 | "metadata": {},
289 | "outputs": [],
290 | "source": [
291 | "## se vc veio da linguagem C/C++, Java, entre outras, você conhece esta notaçãO\n",
292 | "# and ==> &&\n",
293 | "# or ==> ||\n",
294 | "# not ==> !"
295 | ]
296 | },
297 | {
298 | "cell_type": "code",
299 | "execution_count": 14,
300 | "metadata": {},
301 | "outputs": [
302 | {
303 | "data": {
304 | "text/plain": [
305 | "5.0"
306 | ]
307 | },
308 | "execution_count": 14,
309 | "metadata": {},
310 | "output_type": "execute_result"
311 | }
312 | ],
313 | "source": [
314 | "media_final"
315 | ]
316 | },
317 | {
318 | "cell_type": "code",
319 | "execution_count": 17,
320 | "metadata": {},
321 | "outputs": [
322 | {
323 | "name": "stdout",
324 | "output_type": "stream",
325 | "text": [
326 | "Em recuperação\n",
327 | "Em recuperação\n",
328 | "Em recuperação\n"
329 | ]
330 | }
331 | ],
332 | "source": [
333 | "if media_final >= 4.0 and media_final < 6.0:\n",
334 | " print('Em recuperação')\n",
335 | " \n",
336 | "if (media_final >= 4.0) and (media_final < 6.0):\n",
337 | " print('Em recuperação')\n",
338 | " \n",
339 | "if ((media_final >= 4.0) and (media_final < 6.0)):\n",
340 | " print('Em recuperação')"
341 | ]
342 | },
343 | {
344 | "cell_type": "code",
345 | "execution_count": 18,
346 | "metadata": {},
347 | "outputs": [
348 | {
349 | "name": "stdout",
350 | "output_type": "stream",
351 | "text": [
352 | "Não foi para recuperação\n"
353 | ]
354 | }
355 | ],
356 | "source": [
357 | "media_final = 3.0\n",
358 | "\n",
359 | "if media_final < 4.0 or media_final >= 6.0:\n",
360 | " print('Não foi para recuperação')"
361 | ]
362 | },
363 | {
364 | "cell_type": "code",
365 | "execution_count": 19,
366 | "metadata": {},
367 | "outputs": [
368 | {
369 | "name": "stdout",
370 | "output_type": "stream",
371 | "text": [
372 | "Um jedi foi reprovado direto!\n"
373 | ]
374 | }
375 | ],
376 | "source": [
377 | "media_final = 3.0\n",
378 | "aluno_eh_jedi = True\n",
379 | "\n",
380 | "if media_final < 4.0 and aluno_eh_jedi:\n",
381 | " print('Um jedi foi reprovado direto!')"
382 | ]
383 | },
384 | {
385 | "cell_type": "markdown",
386 | "metadata": {},
387 | "source": [
388 | "### Armazenando booleans resultantes de condicionais"
389 | ]
390 | },
391 | {
392 | "cell_type": "code",
393 | "execution_count": 23,
394 | "metadata": {},
395 | "outputs": [
396 | {
397 | "name": "stdout",
398 | "output_type": "stream",
399 | "text": [
400 | "Foi aprovado? True\n"
401 | ]
402 | }
403 | ],
404 | "source": [
405 | "media_final = 7.0\n",
406 | "\n",
407 | "foi_aprovado = media_final >= 6.0\n",
408 | "# foi_aprovado = (media_final >= 6.0) # alternativamente, podemos usar parênteses\n",
409 | "\n",
410 | "print(f'Foi aprovado? {foi_aprovado}')"
411 | ]
412 | },
413 | {
414 | "cell_type": "code",
415 | "execution_count": 25,
416 | "metadata": {},
417 | "outputs": [
418 | {
419 | "name": "stdout",
420 | "output_type": "stream",
421 | "text": [
422 | "Foi pra recuperação? True\n"
423 | ]
424 | }
425 | ],
426 | "source": [
427 | "media_final = 5.0\n",
428 | "\n",
429 | "foi_pra_recuperacao = media_final >= 4.0 or media_final < 6\n",
430 | "# foi_pra_recuperacao = (media_final >= 4.0) or (media_final < 6) # alternativamente, podemos usar parênteses\n",
431 | "\n",
432 | "print(f'Foi pra recuperação? {foi_pra_recuperacao}')"
433 | ]
434 | },
435 | {
436 | "cell_type": "markdown",
437 | "metadata": {},
438 | "source": [
439 | "### Condicionais em uma única linha"
440 | ]
441 | },
442 | {
443 | "cell_type": "code",
444 | "execution_count": 29,
445 | "metadata": {},
446 | "outputs": [
447 | {
448 | "name": "stdout",
449 | "output_type": "stream",
450 | "text": [
451 | "status = Reprovado\n"
452 | ]
453 | }
454 | ],
455 | "source": [
456 | "# reprovado < 6.0\n",
457 | "# aprovado >= 6.0\n",
458 | "\n",
459 | "media_final = 3.0\n",
460 | "\n",
461 | "status = 'Reprovado' if media_final < 6.0 else 'Aprovado'\n",
462 | "\n",
463 | "## eh o mesmo que este trecho abaixo\n",
464 | "# if media_final < 6.0:\n",
465 | "# status = 'Reprovado'\n",
466 | "# else:\n",
467 | "# status = 'Aprovado'\n",
468 | "\n",
469 | "print(f'status = {status}')"
470 | ]
471 | }
472 | ],
473 | "metadata": {
474 | "kernelspec": {
475 | "display_name": "Python 3",
476 | "language": "python",
477 | "name": "python3"
478 | },
479 | "language_info": {
480 | "codemirror_mode": {
481 | "name": "ipython",
482 | "version": 3
483 | },
484 | "file_extension": ".py",
485 | "mimetype": "text/x-python",
486 | "name": "python",
487 | "nbconvert_exporter": "python",
488 | "pygments_lexer": "ipython3",
489 | "version": "3.8.5"
490 | }
491 | },
492 | "nbformat": 4,
493 | "nbformat_minor": 4
494 | }
495 |
--------------------------------------------------------------------------------
/04_loops.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "## **Python Essencial para Data Science**\n",
8 | "**Prof. Dr. Samuel Martins (@hisamuka @xavecoding)**
\n",
9 | "xavecoding: https://youtube.com/c/xavecoding
\n",
10 | "\n",
11 | "
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License."
12 | ]
13 | },
14 | {
15 | "cell_type": "markdown",
16 | "metadata": {},
17 | "source": [
18 | "## Loops\n",
19 | "Antes de definirmos os *laços de repetição em Python (loops)*, vamos ver como definimos intervalos no Python:"
20 | ]
21 | },
22 | {
23 | "cell_type": "markdown",
24 | "metadata": {},
25 | "source": [
26 | "### Gerando intervalos com a função `range()`\n",
27 | "Um dos exemplos mais comuns de loops é iterar para um dado **intervalo de valores**.\n",
28 | "\n",
29 | "Suponha que desejamos codificar um loop que itere de 0 até n-1, onde o parâmetro *n* é definido pelo usuário.
\n",
30 | "Em linguagem C, teríamos algo como:\n",
31 | "\n",
32 | "for (int i = 0; i < n; i++) {\n",
33 | " ...\n",
34 | "}\n",
35 | "\n",
36 | " \n",
37 | "Em *Python*, podemos gerar intervalos de valores muito mais fácil, apenas utilizando o comando `range()`, que possui a assinatura:
\n",
38 | "`range(start, end, step)`."
39 | ]
40 | },
41 | {
42 | "cell_type": "markdown",
43 | "metadata": {},
44 | "source": [
45 | "#### Entendendo os índices de um Intervalo\n",
46 | "Um intervalo em python sempre **inclui** o número passado como **limite inferior** e *exclui* o número do *limite superior* do intervalo.\n",
47 | "\n",
48 | "P. ex., o intervalo definido pelos números `10 15` corresponde, na verdade, ao intervalo [10, 15), ou seja, [10, 11, 12, 13, 14]"
49 | ]
50 | },
51 | {
52 | "cell_type": "markdown",
53 | "metadata": {},
54 | "source": [
55 | "#### Gerando um intervalo de 0..n-1\n",
56 | "Se passarmos apenas **um valor/parâmetro** para a função `range()`, a mesma retorna um intervalor de 0 até o valor -1."
57 | ]
58 | },
59 | {
60 | "cell_type": "code",
61 | "execution_count": 1,
62 | "metadata": {},
63 | "outputs": [
64 | {
65 | "data": {
66 | "text/plain": [
67 | "range(0, 10)"
68 | ]
69 | },
70 | "execution_count": 1,
71 | "metadata": {},
72 | "output_type": "execute_result"
73 | }
74 | ],
75 | "source": [
76 | "# gera um intervalo [0, 10), com step=1, onde o 10 não está incluso na lista de valores do intervalo\n",
77 | "# ou seja, teremos os números de 0 a 9\n",
78 | "range(10)"
79 | ]
80 | },
81 | {
82 | "cell_type": "code",
83 | "execution_count": 2,
84 | "metadata": {},
85 | "outputs": [
86 | {
87 | "data": {
88 | "text/plain": [
89 | "range"
90 | ]
91 | },
92 | "execution_count": 2,
93 | "metadata": {},
94 | "output_type": "execute_result"
95 | }
96 | ],
97 | "source": [
98 | "type(range(10))"
99 | ]
100 | },
101 | {
102 | "cell_type": "markdown",
103 | "metadata": {},
104 | "source": [
105 | "Note que o retorno é um `range(0, 10)`. Internamente, este tipo é uma _lista_ contendo todos os números do intervalo.
\n",
106 | "Para termos acesso a tal lista explicitamente, precisamos converter o range em uma **`list`**:"
107 | ]
108 | },
109 | {
110 | "cell_type": "code",
111 | "execution_count": 3,
112 | "metadata": {},
113 | "outputs": [
114 | {
115 | "data": {
116 | "text/plain": [
117 | "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
118 | ]
119 | },
120 | "execution_count": 3,
121 | "metadata": {},
122 | "output_type": "execute_result"
123 | }
124 | ],
125 | "source": [
126 | "# converte o intervalo range(0, 10) na lista de números do intervalo\n",
127 | "list(range(10))"
128 | ]
129 | },
130 | {
131 | "cell_type": "markdown",
132 | "metadata": {},
133 | "source": [
134 | "#### Gerando um intervalo de Inicio até Fim-1\n",
135 | "Podemos querer alterar o valor **inicial** do intervalo, que é 0 por padrão. Para isso, devemos passar 2 parâmetros para o `range()`, sendo o primeiro deles o limite inferior (incluso) do intervalo (_lower bound_) e o segundo é o limite superior (excluso) do intevarlo (_upper bound_):"
136 | ]
137 | },
138 | {
139 | "cell_type": "code",
140 | "execution_count": 4,
141 | "metadata": {},
142 | "outputs": [
143 | {
144 | "data": {
145 | "text/plain": [
146 | "range(11, 21)"
147 | ]
148 | },
149 | "execution_count": 4,
150 | "metadata": {},
151 | "output_type": "execute_result"
152 | }
153 | ],
154 | "source": [
155 | "range(11, 21) # gera o intervalo de números [11, 21) ==> números de 11 a 21"
156 | ]
157 | },
158 | {
159 | "cell_type": "code",
160 | "execution_count": 5,
161 | "metadata": {},
162 | "outputs": [
163 | {
164 | "data": {
165 | "text/plain": [
166 | "[11, 12, 13, 14, 15, 16, 17, 18, 19, 20]"
167 | ]
168 | },
169 | "execution_count": 5,
170 | "metadata": {},
171 | "output_type": "execute_result"
172 | }
173 | ],
174 | "source": [
175 | "list(range(11, 21))"
176 | ]
177 | },
178 | {
179 | "cell_type": "markdown",
180 | "metadata": {},
181 | "source": [
182 | "#### Especificando o passo do intervalo\n",
183 | "Por padrão, os intervalos fornecem números sequenciais, ou seja, com **passo/incremento** igual a 1.
\n",
184 | "Podemos alterar tal **passo**. Para isso, basta passarmos um terceiro parâmetro no `range()`"
185 | ]
186 | },
187 | {
188 | "cell_type": "code",
189 | "execution_count": 6,
190 | "metadata": {},
191 | "outputs": [
192 | {
193 | "data": {
194 | "text/plain": [
195 | "range(11, 21, 2)"
196 | ]
197 | },
198 | "execution_count": 6,
199 | "metadata": {},
200 | "output_type": "execute_result"
201 | }
202 | ],
203 | "source": [
204 | "range(11, 21, 2) # ==> for (int i = 11; i < 21; i += 2)"
205 | ]
206 | },
207 | {
208 | "cell_type": "code",
209 | "execution_count": 7,
210 | "metadata": {},
211 | "outputs": [
212 | {
213 | "data": {
214 | "text/plain": [
215 | "[11, 13, 15, 17, 19]"
216 | ]
217 | },
218 | "execution_count": 7,
219 | "metadata": {},
220 | "output_type": "execute_result"
221 | }
222 | ],
223 | "source": [
224 | "list(range(11, 21, 2))"
225 | ]
226 | },
227 | {
228 | "cell_type": "code",
229 | "execution_count": 8,
230 | "metadata": {},
231 | "outputs": [
232 | {
233 | "data": {
234 | "text/plain": [
235 | "[0, 2, 4, 6, 8]"
236 | ]
237 | },
238 | "execution_count": 8,
239 | "metadata": {},
240 | "output_type": "execute_result"
241 | }
242 | ],
243 | "source": [
244 | "# outro exemplo\n",
245 | "list(range(0, 10, 2))"
246 | ]
247 | },
248 | {
249 | "cell_type": "markdown",
250 | "metadata": {},
251 | "source": [
252 | "### `for`\n",
253 | "O esqueleto de um for-loop é:\n",
254 | "\n",
255 | "for i in collection:\n",
256 | " Instruction 01\n",
257 | " Instruction 02\n",
258 | " ...\n",
259 | "
\n",
260 | "\n",
261 | "onde _collection_ é uma coleção de valores que será iterado.
\n",
262 | "No esqueleto acima, a cada iteração, a variável `i` terá um valor da _collection_. \n",
263 | "\n",
264 | "A _collection_ pode ser, por exemplo, um `range()` ou uma `list`:"
265 | ]
266 | },
267 | {
268 | "cell_type": "code",
269 | "execution_count": 9,
270 | "metadata": {},
271 | "outputs": [
272 | {
273 | "name": "stdout",
274 | "output_type": "stream",
275 | "text": [
276 | "i = 0\n",
277 | "i = 1\n",
278 | "i = 2\n",
279 | "i = 3\n",
280 | "i = 4\n",
281 | "i = 5\n",
282 | "i = 6\n",
283 | "i = 7\n",
284 | "i = 8\n",
285 | "i = 9\n"
286 | ]
287 | }
288 | ],
289 | "source": [
290 | "# para cada i de 0 a 9\n",
291 | "for i in range(10):\n",
292 | " print(f'i = {i}')"
293 | ]
294 | },
295 | {
296 | "cell_type": "code",
297 | "execution_count": 10,
298 | "metadata": {},
299 | "outputs": [
300 | {
301 | "name": "stdout",
302 | "output_type": "stream",
303 | "text": [
304 | "num = 12\n",
305 | "num = 14\n",
306 | "num = 16\n",
307 | "num = 18\n",
308 | "num = 20\n"
309 | ]
310 | }
311 | ],
312 | "source": [
313 | "# para cada elemento par no intervalo de [12, 21)\n",
314 | "for num in range(12, 21, 2):\n",
315 | " print(f'num = {num}')"
316 | ]
317 | },
318 | {
319 | "cell_type": "code",
320 | "execution_count": 11,
321 | "metadata": {},
322 | "outputs": [
323 | {
324 | "data": {
325 | "text/plain": [
326 | "[12, 14, 16, 18, 20]"
327 | ]
328 | },
329 | "execution_count": 11,
330 | "metadata": {},
331 | "output_type": "execute_result"
332 | }
333 | ],
334 | "source": [
335 | "lista_de_pares = list(range(12, 21, 2))\n",
336 | "lista_de_pares"
337 | ]
338 | },
339 | {
340 | "cell_type": "code",
341 | "execution_count": 12,
342 | "metadata": {},
343 | "outputs": [
344 | {
345 | "name": "stdout",
346 | "output_type": "stream",
347 | "text": [
348 | "num = 12\n",
349 | "num = 14\n",
350 | "num = 16\n",
351 | "num = 18\n",
352 | "num = 20\n"
353 | ]
354 | }
355 | ],
356 | "source": [
357 | "# para cada elemento da lista `lista_de_pares`\n",
358 | "for num in lista_de_pares:\n",
359 | " print(f'num = {num}')"
360 | ]
361 | },
362 | {
363 | "cell_type": "markdown",
364 | "metadata": {},
365 | "source": [
366 | "### While\n",
367 | "\n",
368 | "while condition:\n",
369 | " Instruction 01\n",
370 | " Instruction 02\n",
371 | " ...\n",
372 | ""
373 | ]
374 | },
375 | {
376 | "cell_type": "code",
377 | "execution_count": 14,
378 | "metadata": {},
379 | "outputs": [
380 | {
381 | "name": "stdout",
382 | "output_type": "stream",
383 | "text": [
384 | "i = 0\n",
385 | "i = 1\n",
386 | "i = 2\n",
387 | "i = 3\n",
388 | "i = 4\n",
389 | "i = 5\n",
390 | "i = 6\n",
391 | "i = 7\n",
392 | "i = 8\n",
393 | "i = 9\n"
394 | ]
395 | }
396 | ],
397 | "source": [
398 | "i = 0\n",
399 | "\n",
400 | "while i < 10:\n",
401 | " print(f'i = {i}')\n",
402 | " i += 1"
403 | ]
404 | },
405 | {
406 | "cell_type": "code",
407 | "execution_count": 16,
408 | "metadata": {},
409 | "outputs": [
410 | {
411 | "name": "stdout",
412 | "output_type": "stream",
413 | "text": [
414 | "i = 0\n",
415 | "j = 0\n",
416 | "i = 1\n",
417 | "j = 1\n",
418 | "i = 2\n",
419 | "j = 2\n",
420 | "i = 3\n",
421 | "j = 3\n",
422 | "i = 4\n",
423 | "j = 4\n"
424 | ]
425 | }
426 | ],
427 | "source": [
428 | "i = 0\n",
429 | "j = 0\n",
430 | "\n",
431 | "while i < 10 and j < 5:\n",
432 | " print(f'i = {i}')\n",
433 | " print(f'j = {j}')\n",
434 | " i += 1\n",
435 | " j += 1"
436 | ]
437 | }
438 | ],
439 | "metadata": {
440 | "kernelspec": {
441 | "display_name": "Python 3",
442 | "language": "python",
443 | "name": "python3"
444 | },
445 | "language_info": {
446 | "codemirror_mode": {
447 | "name": "ipython",
448 | "version": 3
449 | },
450 | "file_extension": ".py",
451 | "mimetype": "text/x-python",
452 | "name": "python",
453 | "nbconvert_exporter": "python",
454 | "pygments_lexer": "ipython3",
455 | "version": "3.8.5"
456 | }
457 | },
458 | "nbformat": 4,
459 | "nbformat_minor": 4
460 | }
461 |
--------------------------------------------------------------------------------
/06_strings.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "## **Python Essencial para Data Science**\n",
8 | "**Prof. Dr. Samuel Martins (@hisamuka @xavecoding)**
\n",
9 | "xavecoding: https://youtube.com/c/xavecoding
\n",
10 | "\n",
11 | "
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License."
12 | ]
13 | },
14 | {
15 | "cell_type": "markdown",
16 | "metadata": {},
17 | "source": [
18 | "## Strings"
19 | ]
20 | },
21 | {
22 | "cell_type": "markdown",
23 | "metadata": {},
24 | "source": [
25 | "#### Strings são também sequências"
26 | ]
27 | },
28 | {
29 | "cell_type": "code",
30 | "execution_count": 1,
31 | "metadata": {},
32 | "outputs": [
33 | {
34 | "name": "stdout",
35 | "output_type": "stream",
36 | "text": [
37 | "Luke skywalker\n",
38 | "Darth Vader\n"
39 | ]
40 | }
41 | ],
42 | "source": [
43 | "nome_1 = 'Luke skywalker' # essa é a convenção da comunidade do Python\n",
44 | "nome_2 = \"Darth Vader\"\n",
45 | "\n",
46 | "print(nome_1)\n",
47 | "print(nome_2)"
48 | ]
49 | },
50 | {
51 | "cell_type": "code",
52 | "execution_count": 2,
53 | "metadata": {},
54 | "outputs": [
55 | {
56 | "data": {
57 | "text/plain": [
58 | "'L'"
59 | ]
60 | },
61 | "execution_count": 2,
62 | "metadata": {},
63 | "output_type": "execute_result"
64 | }
65 | ],
66 | "source": [
67 | "nome_1[0]"
68 | ]
69 | },
70 | {
71 | "cell_type": "code",
72 | "execution_count": 6,
73 | "metadata": {},
74 | "outputs": [
75 | {
76 | "data": {
77 | "text/plain": [
78 | "'k'"
79 | ]
80 | },
81 | "execution_count": 6,
82 | "metadata": {},
83 | "output_type": "execute_result"
84 | }
85 | ],
86 | "source": [
87 | "nome_1[6]"
88 | ]
89 | },
90 | {
91 | "cell_type": "code",
92 | "execution_count": 7,
93 | "metadata": {},
94 | "outputs": [
95 | {
96 | "data": {
97 | "text/plain": [
98 | "'e'"
99 | ]
100 | },
101 | "execution_count": 7,
102 | "metadata": {},
103 | "output_type": "execute_result"
104 | }
105 | ],
106 | "source": [
107 | "nome_1[-2] # retorna o penúltimo caracter"
108 | ]
109 | },
110 | {
111 | "cell_type": "code",
112 | "execution_count": 4,
113 | "metadata": {},
114 | "outputs": [
115 | {
116 | "data": {
117 | "text/plain": [
118 | "'Luke'"
119 | ]
120 | },
121 | "execution_count": 4,
122 | "metadata": {},
123 | "output_type": "execute_result"
124 | }
125 | ],
126 | "source": [
127 | "nome_1[:4]"
128 | ]
129 | },
130 | {
131 | "cell_type": "code",
132 | "execution_count": 5,
133 | "metadata": {},
134 | "outputs": [
135 | {
136 | "data": {
137 | "text/plain": [
138 | "14"
139 | ]
140 | },
141 | "execution_count": 5,
142 | "metadata": {},
143 | "output_type": "execute_result"
144 | }
145 | ],
146 | "source": [
147 | "# quantos caracteres possui a string? Qual o tamanho da string?\n",
148 | "len(nome_1)"
149 | ]
150 | },
151 | {
152 | "cell_type": "markdown",
153 | "metadata": {},
154 | "source": [
155 | "#### Strings são imutáveis"
156 | ]
157 | },
158 | {
159 | "cell_type": "code",
160 | "execution_count": 8,
161 | "metadata": {},
162 | "outputs": [],
163 | "source": [
164 | "nome = 'Luke skywalker'"
165 | ]
166 | },
167 | {
168 | "cell_type": "code",
169 | "execution_count": 9,
170 | "metadata": {},
171 | "outputs": [
172 | {
173 | "data": {
174 | "text/plain": [
175 | "'s'"
176 | ]
177 | },
178 | "execution_count": 9,
179 | "metadata": {},
180 | "output_type": "execute_result"
181 | }
182 | ],
183 | "source": [
184 | "nome[5]"
185 | ]
186 | },
187 | {
188 | "cell_type": "code",
189 | "execution_count": 10,
190 | "metadata": {},
191 | "outputs": [
192 | {
193 | "ename": "TypeError",
194 | "evalue": "'str' object does not support item assignment",
195 | "output_type": "error",
196 | "traceback": [
197 | "\u001b[0;31m---------------------------------------------------------------------\u001b[0m",
198 | "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
199 | "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnome\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'S'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
200 | "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
201 | ]
202 | }
203 | ],
204 | "source": [
205 | "nome[5] = 'S'"
206 | ]
207 | },
208 | {
209 | "cell_type": "markdown",
210 | "metadata": {},
211 | "source": [
212 | "Para fazer a substituição de um caracter em uma posição específica, precisaremos fazer uma \"gambiarra\" que veremos jajá."
213 | ]
214 | },
215 | {
216 | "cell_type": "markdown",
217 | "metadata": {},
218 | "source": [
219 | "### Métodos de Strings"
220 | ]
221 | },
222 | {
223 | "cell_type": "markdown",
224 | "metadata": {},
225 | "source": [
226 | "`.upper()` retorna a string com todas as letras maiúscula"
227 | ]
228 | },
229 | {
230 | "cell_type": "code",
231 | "execution_count": 13,
232 | "metadata": {},
233 | "outputs": [
234 | {
235 | "data": {
236 | "text/plain": [
237 | "'LUKE SKYWALKER'"
238 | ]
239 | },
240 | "execution_count": 13,
241 | "metadata": {},
242 | "output_type": "execute_result"
243 | }
244 | ],
245 | "source": [
246 | "nome.upper() # retorna uma cópia"
247 | ]
248 | },
249 | {
250 | "cell_type": "code",
251 | "execution_count": 14,
252 | "metadata": {},
253 | "outputs": [
254 | {
255 | "data": {
256 | "text/plain": [
257 | "'Luke skywalker'"
258 | ]
259 | },
260 | "execution_count": 14,
261 | "metadata": {},
262 | "output_type": "execute_result"
263 | }
264 | ],
265 | "source": [
266 | "nome"
267 | ]
268 | },
269 | {
270 | "cell_type": "code",
271 | "execution_count": 15,
272 | "metadata": {},
273 | "outputs": [
274 | {
275 | "name": "stdout",
276 | "output_type": "stream",
277 | "text": [
278 | "Luke skywalker\n",
279 | "LUKE SKYWALKER\n"
280 | ]
281 | }
282 | ],
283 | "source": [
284 | "nome_maiscula = nome.upper()\n",
285 | "print(nome)\n",
286 | "print(nome_maiscula)"
287 | ]
288 | },
289 | {
290 | "cell_type": "markdown",
291 | "metadata": {},
292 | "source": [
293 | "`.lower()` retorna a string com todas as letras minúsculas"
294 | ]
295 | },
296 | {
297 | "cell_type": "code",
298 | "execution_count": 17,
299 | "metadata": {},
300 | "outputs": [
301 | {
302 | "name": "stdout",
303 | "output_type": "stream",
304 | "text": [
305 | "Luke skywalker\n",
306 | "luke skywalker\n"
307 | ]
308 | }
309 | ],
310 | "source": [
311 | "nome_minuscula = nome.lower()\n",
312 | "print(nome)\n",
313 | "print(nome_minuscula)"
314 | ]
315 | },
316 | {
317 | "cell_type": "code",
318 | "execution_count": 18,
319 | "metadata": {},
320 | "outputs": [
321 | {
322 | "name": "stdout",
323 | "output_type": "stream",
324 | "text": [
325 | "LUKE SKYWALKER\n",
326 | "luke skywalker\n"
327 | ]
328 | }
329 | ],
330 | "source": [
331 | "nome_de_maiscula_para_minuscula = nome_maiscula.lower()\n",
332 | "print(nome_maiscula)\n",
333 | "print(nome_de_maiscula_para_minuscula)"
334 | ]
335 | },
336 | {
337 | "cell_type": "markdown",
338 | "metadata": {},
339 | "source": [
340 | "`str.startswith(substring)` checa se a string `str` começa com a substring `substring`. "
341 | ]
342 | },
343 | {
344 | "cell_type": "code",
345 | "execution_count": 20,
346 | "metadata": {},
347 | "outputs": [
348 | {
349 | "name": "stdout",
350 | "output_type": "stream",
351 | "text": [
352 | "Luke skywalker\n",
353 | "LUKE SKYWALKER\n",
354 | "luke skywalker\n"
355 | ]
356 | }
357 | ],
358 | "source": [
359 | "print(nome)\n",
360 | "print(nome_maiscula)\n",
361 | "print(nome_minuscula)"
362 | ]
363 | },
364 | {
365 | "cell_type": "code",
366 | "execution_count": 21,
367 | "metadata": {},
368 | "outputs": [
369 | {
370 | "data": {
371 | "text/plain": [
372 | "True"
373 | ]
374 | },
375 | "execution_count": 21,
376 | "metadata": {},
377 | "output_type": "execute_result"
378 | }
379 | ],
380 | "source": [
381 | "nome.startswith('Luke')"
382 | ]
383 | },
384 | {
385 | "cell_type": "code",
386 | "execution_count": 22,
387 | "metadata": {},
388 | "outputs": [
389 | {
390 | "data": {
391 | "text/plain": [
392 | "False"
393 | ]
394 | },
395 | "execution_count": 22,
396 | "metadata": {},
397 | "output_type": "execute_result"
398 | }
399 | ],
400 | "source": [
401 | "nome.startswith('LUKE')"
402 | ]
403 | },
404 | {
405 | "cell_type": "code",
406 | "execution_count": 23,
407 | "metadata": {},
408 | "outputs": [
409 | {
410 | "data": {
411 | "text/plain": [
412 | "True"
413 | ]
414 | },
415 | "execution_count": 23,
416 | "metadata": {},
417 | "output_type": "execute_result"
418 | }
419 | ],
420 | "source": [
421 | "nome_maiscula.startswith('LUKE')"
422 | ]
423 | },
424 | {
425 | "cell_type": "markdown",
426 | "metadata": {},
427 | "source": [
428 | "`str.endswith(substring)` checa se a string `str` termina com a substring `substring`. "
429 | ]
430 | },
431 | {
432 | "cell_type": "code",
433 | "execution_count": 24,
434 | "metadata": {},
435 | "outputs": [
436 | {
437 | "name": "stdout",
438 | "output_type": "stream",
439 | "text": [
440 | "Luke skywalker\n",
441 | "LUKE SKYWALKER\n",
442 | "luke skywalker\n"
443 | ]
444 | }
445 | ],
446 | "source": [
447 | "print(nome)\n",
448 | "print(nome_maiscula)\n",
449 | "print(nome_minuscula)"
450 | ]
451 | },
452 | {
453 | "cell_type": "code",
454 | "execution_count": 25,
455 | "metadata": {},
456 | "outputs": [
457 | {
458 | "data": {
459 | "text/plain": [
460 | "True"
461 | ]
462 | },
463 | "execution_count": 25,
464 | "metadata": {},
465 | "output_type": "execute_result"
466 | }
467 | ],
468 | "source": [
469 | "nome.endswith('r')"
470 | ]
471 | },
472 | {
473 | "cell_type": "code",
474 | "execution_count": 26,
475 | "metadata": {},
476 | "outputs": [
477 | {
478 | "data": {
479 | "text/plain": [
480 | "True"
481 | ]
482 | },
483 | "execution_count": 26,
484 | "metadata": {},
485 | "output_type": "execute_result"
486 | }
487 | ],
488 | "source": [
489 | "nome.endswith('walker')"
490 | ]
491 | },
492 | {
493 | "cell_type": "code",
494 | "execution_count": 27,
495 | "metadata": {},
496 | "outputs": [
497 | {
498 | "data": {
499 | "text/plain": [
500 | "False"
501 | ]
502 | },
503 | "execution_count": 27,
504 | "metadata": {},
505 | "output_type": "execute_result"
506 | }
507 | ],
508 | "source": [
509 | "nome.endswith('WALKER')"
510 | ]
511 | },
512 | {
513 | "cell_type": "code",
514 | "execution_count": 29,
515 | "metadata": {},
516 | "outputs": [
517 | {
518 | "data": {
519 | "text/plain": [
520 | "True"
521 | ]
522 | },
523 | "execution_count": 29,
524 | "metadata": {},
525 | "output_type": "execute_result"
526 | }
527 | ],
528 | "source": [
529 | "nome_maiscula.endswith('WALKER')"
530 | ]
531 | },
532 | {
533 | "cell_type": "code",
534 | "execution_count": 30,
535 | "metadata": {},
536 | "outputs": [
537 | {
538 | "name": "stdout",
539 | "output_type": "stream",
540 | "text": [
541 | "É uma imagem png\n"
542 | ]
543 | }
544 | ],
545 | "source": [
546 | "arquivo = 'imagem.png'\n",
547 | "\n",
548 | "# checar se a extensão do arquivo é .png\n",
549 | "if arquivo.endswith('.png'):\n",
550 | " print('É uma imagem png')\n",
551 | "else:\n",
552 | " print('O arquivo não é PNG')"
553 | ]
554 | },
555 | {
556 | "cell_type": "code",
557 | "execution_count": 34,
558 | "metadata": {},
559 | "outputs": [
560 | {
561 | "name": "stdout",
562 | "output_type": "stream",
563 | "text": [
564 | "É uma imagem png\n"
565 | ]
566 | }
567 | ],
568 | "source": [
569 | "arquivo = 'imagem.PNG'\n",
570 | "\n",
571 | "# checar se a extensão do arquivo é .png\n",
572 | "# if arquivo.endswith('.png') or arquivo.endswith('.PNG'):\n",
573 | "if arquivo.upper().endswith('.PNG'):\n",
574 | " print('É uma imagem png')\n",
575 | "else:\n",
576 | " print('O arquivo não é PNG')"
577 | ]
578 | },
579 | {
580 | "cell_type": "code",
581 | "execution_count": 35,
582 | "metadata": {},
583 | "outputs": [
584 | {
585 | "name": "stdout",
586 | "output_type": "stream",
587 | "text": [
588 | "É uma imagem png\n"
589 | ]
590 | }
591 | ],
592 | "source": [
593 | "arquivo = 'imagem.png'\n",
594 | "\n",
595 | "# checar se a extensão do arquivo é .png\n",
596 | "# if arquivo.endswith('.png') or arquivo.endswith('.PNG'):\n",
597 | "if arquivo.upper().endswith('.PNG'):\n",
598 | " print('É uma imagem png')\n",
599 | "else:\n",
600 | " print('O arquivo não é PNG')"
601 | ]
602 | },
603 | {
604 | "cell_type": "markdown",
605 | "metadata": {},
606 | "source": [
607 | "`string.split(substring)` divide uma string, a partir de uma substring passada, retorna uma lista com as divisões."
608 | ]
609 | },
610 | {
611 | "cell_type": "code",
612 | "execution_count": 36,
613 | "metadata": {},
614 | "outputs": [
615 | {
616 | "name": "stdout",
617 | "output_type": "stream",
618 | "text": [
619 | "['~', 'documentos', 'arquivos']\n"
620 | ]
621 | }
622 | ],
623 | "source": [
624 | "diretorio = '~/documentos/arquivos'\n",
625 | "\n",
626 | "subdiretorios = diretorio.split('/')\n",
627 | "print(subdiretorios)"
628 | ]
629 | },
630 | {
631 | "cell_type": "code",
632 | "execution_count": 38,
633 | "metadata": {},
634 | "outputs": [
635 | {
636 | "data": {
637 | "text/plain": [
638 | "'imagem'"
639 | ]
640 | },
641 | "execution_count": 38,
642 | "metadata": {},
643 | "output_type": "execute_result"
644 | }
645 | ],
646 | "source": [
647 | "arquivo = 'imagem.png'\n",
648 | "filename_sem_extensao = arquivo.split('.png')[0]\n",
649 | "filename_sem_extensao"
650 | ]
651 | },
652 | {
653 | "cell_type": "code",
654 | "execution_count": 39,
655 | "metadata": {},
656 | "outputs": [
657 | {
658 | "data": {
659 | "text/plain": [
660 | "['imagem.png']"
661 | ]
662 | },
663 | "execution_count": 39,
664 | "metadata": {},
665 | "output_type": "execute_result"
666 | }
667 | ],
668 | "source": [
669 | "arquivo.split('.jpeg')"
670 | ]
671 | },
672 | {
673 | "cell_type": "markdown",
674 | "metadata": {},
675 | "source": [
676 | "`join` junta uma lista de strings, a partir de uma substring. "
677 | ]
678 | },
679 | {
680 | "cell_type": "code",
681 | "execution_count": 45,
682 | "metadata": {},
683 | "outputs": [
684 | {
685 | "name": "stdout",
686 | "output_type": "stream",
687 | "text": [
688 | "['~', 'documentos', 'arquivos']\n",
689 | "~/documentos/arquivos\n"
690 | ]
691 | }
692 | ],
693 | "source": [
694 | "print(subdiretorios)\n",
695 | "diretorio_completo = '/'.join(subdiretorios)\n",
696 | "print(diretorio_completo)"
697 | ]
698 | },
699 | {
700 | "cell_type": "code",
701 | "execution_count": 46,
702 | "metadata": {},
703 | "outputs": [
704 | {
705 | "name": "stdout",
706 | "output_type": "stream",
707 | "text": [
708 | "Luke skywalker\n"
709 | ]
710 | }
711 | ],
712 | "source": [
713 | "# gambiarra para alterar um único caracter de um dado index de uma string\n",
714 | "nome = 'Luke skywalker'\n",
715 | "print(nome)"
716 | ]
717 | },
718 | {
719 | "cell_type": "code",
720 | "execution_count": 49,
721 | "metadata": {},
722 | "outputs": [
723 | {
724 | "ename": "TypeError",
725 | "evalue": "'str' object does not support item assignment",
726 | "output_type": "error",
727 | "traceback": [
728 | "\u001b[0;31m---------------------------------------------------------------------\u001b[0m",
729 | "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
730 | "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnome\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'S'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
731 | "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
732 | ]
733 | }
734 | ],
735 | "source": [
736 | "nome[5] = 'S'"
737 | ]
738 | },
739 | {
740 | "cell_type": "code",
741 | "execution_count": 51,
742 | "metadata": {},
743 | "outputs": [
744 | {
745 | "data": {
746 | "text/plain": [
747 | "['L', 'u', 'k', 'e', ' ', 's', 'k', 'y', 'w', 'a', 'l', 'k', 'e', 'r']"
748 | ]
749 | },
750 | "execution_count": 51,
751 | "metadata": {},
752 | "output_type": "execute_result"
753 | }
754 | ],
755 | "source": [
756 | "nome_como_lista = list(nome)\n",
757 | "nome_como_lista"
758 | ]
759 | },
760 | {
761 | "cell_type": "code",
762 | "execution_count": 53,
763 | "metadata": {},
764 | "outputs": [
765 | {
766 | "data": {
767 | "text/plain": [
768 | "['L', 'u', 'k', 'e', ' ', 'S', 'k', 'y', 'w', 'a', 'l', 'k', 'e', 'r']"
769 | ]
770 | },
771 | "execution_count": 53,
772 | "metadata": {},
773 | "output_type": "execute_result"
774 | }
775 | ],
776 | "source": [
777 | "nome_como_lista[5] = 'S'\n",
778 | "nome_como_lista"
779 | ]
780 | },
781 | {
782 | "cell_type": "code",
783 | "execution_count": 58,
784 | "metadata": {},
785 | "outputs": [
786 | {
787 | "data": {
788 | "text/plain": [
789 | "'Luke Skywalker'"
790 | ]
791 | },
792 | "execution_count": 58,
793 | "metadata": {},
794 | "output_type": "execute_result"
795 | }
796 | ],
797 | "source": [
798 | "''.join(nome_como_lista)"
799 | ]
800 | },
801 | {
802 | "cell_type": "markdown",
803 | "metadata": {},
804 | "source": [
805 | "`replace` substitui uma (sub)string específica com outra (sub)string específica."
806 | ]
807 | },
808 | {
809 | "cell_type": "code",
810 | "execution_count": 60,
811 | "metadata": {},
812 | "outputs": [
813 | {
814 | "name": "stdout",
815 | "output_type": "stream",
816 | "text": [
817 | "I like bananas\n"
818 | ]
819 | }
820 | ],
821 | "source": [
822 | "txt = \"I like bananas\"\n",
823 | "print(txt)"
824 | ]
825 | },
826 | {
827 | "cell_type": "code",
828 | "execution_count": 61,
829 | "metadata": {},
830 | "outputs": [
831 | {
832 | "name": "stdout",
833 | "output_type": "stream",
834 | "text": [
835 | "I like bananas\n",
836 | "I like apples\n"
837 | ]
838 | }
839 | ],
840 | "source": [
841 | "novo_txt = txt.replace(\"bananas\", \"apples\")\n",
842 | "print(txt)\n",
843 | "print(novo_txt)"
844 | ]
845 | },
846 | {
847 | "cell_type": "markdown",
848 | "metadata": {},
849 | "source": [
850 | "#### Concatenando strings"
851 | ]
852 | },
853 | {
854 | "cell_type": "code",
855 | "execution_count": 62,
856 | "metadata": {},
857 | "outputs": [
858 | {
859 | "name": "stdout",
860 | "output_type": "stream",
861 | "text": [
862 | "~/documentos/arquivos\n",
863 | "imagem.png\n"
864 | ]
865 | }
866 | ],
867 | "source": [
868 | "print(diretorio)\n",
869 | "print(arquivo)"
870 | ]
871 | },
872 | {
873 | "cell_type": "code",
874 | "execution_count": 63,
875 | "metadata": {},
876 | "outputs": [
877 | {
878 | "name": "stdout",
879 | "output_type": "stream",
880 | "text": [
881 | "~/documentos/arquivos/imagem.png\n"
882 | ]
883 | }
884 | ],
885 | "source": [
886 | "# no caso específico de manipulação de filenames,\n",
887 | "# o python fornece o módulo os.path para isso\n",
888 | "caminho_completo = diretorio + '/' + arquivo\n",
889 | "print(caminho_completo)"
890 | ]
891 | },
892 | {
893 | "cell_type": "code",
894 | "execution_count": 67,
895 | "metadata": {},
896 | "outputs": [
897 | {
898 | "name": "stdout",
899 | "output_type": "stream",
900 | "text": [
901 | "I like bananas\n"
902 | ]
903 | },
904 | {
905 | "data": {
906 | "text/plain": [
907 | "'I like apples'"
908 | ]
909 | },
910 | "execution_count": 67,
911 | "metadata": {},
912 | "output_type": "execute_result"
913 | }
914 | ],
915 | "source": [
916 | "# outras gambiarras\n",
917 | "print(txt)\n",
918 | "txt[:7] + 'apples'"
919 | ]
920 | }
921 | ],
922 | "metadata": {
923 | "kernelspec": {
924 | "display_name": "Python 3",
925 | "language": "python",
926 | "name": "python3"
927 | },
928 | "language_info": {
929 | "codemirror_mode": {
930 | "name": "ipython",
931 | "version": 3
932 | },
933 | "file_extension": ".py",
934 | "mimetype": "text/x-python",
935 | "name": "python",
936 | "nbconvert_exporter": "python",
937 | "pygments_lexer": "ipython3",
938 | "version": "3.8.5"
939 | }
940 | },
941 | "nbformat": 4,
942 | "nbformat_minor": 4
943 | }
944 |
--------------------------------------------------------------------------------
/07_tuplas.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "## **Python Essencial para Data Science**\n",
8 | "**Prof. Dr. Samuel Martins (@hisamuka @xavecoding)**
\n",
9 | "xavecoding: https://youtube.com/c/xavecoding
\n",
10 | "\n",
11 | "
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License."
12 | ]
13 | },
14 | {
15 | "cell_type": "markdown",
16 | "metadata": {},
17 | "source": [
18 | "## Tuplas\n",
19 | "Tuplas são estruturas muito semelhantes às listas. Elas diferem de duas maneiras:"
20 | ]
21 | },
22 | {
23 | "cell_type": "markdown",
24 | "metadata": {},
25 | "source": [
26 | "1. Elas usam _parênteses_ ao invés de _colchetes_:"
27 | ]
28 | },
29 | {
30 | "cell_type": "code",
31 | "execution_count": 1,
32 | "metadata": {},
33 | "outputs": [
34 | {
35 | "data": {
36 | "text/plain": [
37 | "(1, 2, 3)"
38 | ]
39 | },
40 | "execution_count": 1,
41 | "metadata": {},
42 | "output_type": "execute_result"
43 | }
44 | ],
45 | "source": [
46 | "tupla_1 = (1, 2, 3)\n",
47 | "tupla_1"
48 | ]
49 | },
50 | {
51 | "cell_type": "code",
52 | "execution_count": 4,
53 | "metadata": {},
54 | "outputs": [
55 | {
56 | "name": "stdout",
57 | "output_type": "stream",
58 | "text": [
59 | "\n"
60 | ]
61 | }
62 | ],
63 | "source": [
64 | "print(type(tupla_1))"
65 | ]
66 | },
67 | {
68 | "cell_type": "code",
69 | "execution_count": 5,
70 | "metadata": {},
71 | "outputs": [],
72 | "source": [
73 | "tupla_2 = 1, 2, 3"
74 | ]
75 | },
76 | {
77 | "cell_type": "code",
78 | "execution_count": 7,
79 | "metadata": {},
80 | "outputs": [
81 | {
82 | "name": "stdout",
83 | "output_type": "stream",
84 | "text": [
85 | "(1, 2, 3)\n",
86 | "\n"
87 | ]
88 | }
89 | ],
90 | "source": [
91 | "print(tupla_2)\n",
92 | "print(type(tupla_2))"
93 | ]
94 | },
95 | {
96 | "cell_type": "code",
97 | "execution_count": 8,
98 | "metadata": {},
99 | "outputs": [
100 | {
101 | "name": "stdout",
102 | "output_type": "stream",
103 | "text": [
104 | "1\n",
105 | "2\n",
106 | "3\n"
107 | ]
108 | }
109 | ],
110 | "source": [
111 | "# relembrando atribuição múltiplca\n",
112 | "x, y, z = 1, 2, 3\n",
113 | "print(x)\n",
114 | "print(y)\n",
115 | "print(z)"
116 | ]
117 | },
118 | {
119 | "cell_type": "code",
120 | "execution_count": 9,
121 | "metadata": {},
122 | "outputs": [
123 | {
124 | "name": "stdout",
125 | "output_type": "stream",
126 | "text": [
127 | "1\n",
128 | "2\n",
129 | "3\n"
130 | ]
131 | }
132 | ],
133 | "source": [
134 | "a, b, c = tupla_1 # \"desempacota\" os elementos da tupla `tupla_1` nas variávels a, b, c\n",
135 | "print(a)\n",
136 | "print(b)\n",
137 | "print(c)"
138 | ]
139 | },
140 | {
141 | "cell_type": "markdown",
142 | "metadata": {},
143 | "source": [
144 | "2. Elas **não** podem ser modificadas (**imutáveis**)"
145 | ]
146 | },
147 | {
148 | "cell_type": "code",
149 | "execution_count": 10,
150 | "metadata": {},
151 | "outputs": [
152 | {
153 | "data": {
154 | "text/plain": [
155 | "(1, 2, 3)"
156 | ]
157 | },
158 | "execution_count": 10,
159 | "metadata": {},
160 | "output_type": "execute_result"
161 | }
162 | ],
163 | "source": [
164 | "tupla_1"
165 | ]
166 | },
167 | {
168 | "cell_type": "code",
169 | "execution_count": 11,
170 | "metadata": {},
171 | "outputs": [
172 | {
173 | "ename": "TypeError",
174 | "evalue": "'tuple' object does not support item assignment",
175 | "output_type": "error",
176 | "traceback": [
177 | "\u001b[0;31m---------------------------------------------------------------------\u001b[0m",
178 | "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
179 | "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtupla_1\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
180 | "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
181 | ]
182 | }
183 | ],
184 | "source": [
185 | "tupla_1[0] = 10"
186 | ]
187 | },
188 | {
189 | "cell_type": "markdown",
190 | "metadata": {},
191 | "source": [
192 | "#### Convertendo uma lista em tuplas e vice-versa"
193 | ]
194 | },
195 | {
196 | "cell_type": "code",
197 | "execution_count": 12,
198 | "metadata": {},
199 | "outputs": [
200 | {
201 | "name": "stdout",
202 | "output_type": "stream",
203 | "text": [
204 | "['Mercúrio', 'Vênus', 'Terra', 'Marte', 'Júpiter', 'Saturno', 'Urano', 'Netuno']\n",
205 | "\n"
206 | ]
207 | }
208 | ],
209 | "source": [
210 | "planetas = ['Mercúrio', 'Vênus', 'Terra', 'Marte', 'Júpiter', 'Saturno', 'Urano', 'Netuno']\n",
211 | "print(planetas)\n",
212 | "print(type(planetas))"
213 | ]
214 | },
215 | {
216 | "cell_type": "code",
217 | "execution_count": 13,
218 | "metadata": {},
219 | "outputs": [
220 | {
221 | "name": "stdout",
222 | "output_type": "stream",
223 | "text": [
224 | "('Mercúrio', 'Vênus', 'Terra', 'Marte', 'Júpiter', 'Saturno', 'Urano', 'Netuno')\n",
225 | "\n"
226 | ]
227 | }
228 | ],
229 | "source": [
230 | "planetas_tupla = tuple(planetas)\n",
231 | "print(planetas_tupla)\n",
232 | "print(type(planetas_tupla))"
233 | ]
234 | },
235 | {
236 | "cell_type": "code",
237 | "execution_count": 15,
238 | "metadata": {},
239 | "outputs": [
240 | {
241 | "name": "stdout",
242 | "output_type": "stream",
243 | "text": [
244 | "['MERCÚRIO', 'Vênus', 'Terra', 'Marte', 'Júpiter', 'Saturno', 'Urano', 'Netuno']\n",
245 | "('Mercúrio', 'Vênus', 'Terra', 'Marte', 'Júpiter', 'Saturno', 'Urano', 'Netuno')\n"
246 | ]
247 | }
248 | ],
249 | "source": [
250 | "planetas[0] = planetas[0].upper()\n",
251 | "print(planetas)\n",
252 | "print(planetas_tupla)"
253 | ]
254 | },
255 | {
256 | "cell_type": "code",
257 | "execution_count": 17,
258 | "metadata": {},
259 | "outputs": [
260 | {
261 | "ename": "TypeError",
262 | "evalue": "'tuple' object does not support item assignment",
263 | "output_type": "error",
264 | "traceback": [
265 | "\u001b[0;31m---------------------------------------------------------------------\u001b[0m",
266 | "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
267 | "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mplanetas_tupla\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mplanetas_tupla\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\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[0mplanetas\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mplanetas_tupla\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
268 | "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
269 | ]
270 | }
271 | ],
272 | "source": [
273 | "planetas_tupla[0] = planetas_tupla[0].upper()\n",
274 | "print(planetas)\n",
275 | "print(planetas_tupla)"
276 | ]
277 | },
278 | {
279 | "cell_type": "code",
280 | "execution_count": 22,
281 | "metadata": {},
282 | "outputs": [
283 | {
284 | "name": "stdout",
285 | "output_type": "stream",
286 | "text": [
287 | "[1, 2, 3]\n",
288 | "(1, 2, 3)\n"
289 | ]
290 | }
291 | ],
292 | "source": [
293 | "# converter uma tupla para uma lista\n",
294 | "lista_1 = list(tupla_1)\n",
295 | "print(lista_1)\n",
296 | "print(tupla_1)"
297 | ]
298 | },
299 | {
300 | "cell_type": "markdown",
301 | "metadata": {},
302 | "source": [
303 | "### Descompactando tuplas"
304 | ]
305 | },
306 | {
307 | "cell_type": "code",
308 | "execution_count": 25,
309 | "metadata": {},
310 | "outputs": [
311 | {
312 | "name": "stdout",
313 | "output_type": "stream",
314 | "text": [
315 | "(5.0, 10, 2)\n",
316 | "5.0\n",
317 | "10\n",
318 | "2\n",
319 | "(5.0, 10, 2)\n",
320 | "6.0\n",
321 | "10\n",
322 | "2\n"
323 | ]
324 | }
325 | ],
326 | "source": [
327 | "notas_do_semestre = (5.0, 10, 2)\n",
328 | "prova_1, prova_2, projeto = notas_do_semestre\n",
329 | "\n",
330 | "print(notas_do_semestre)\n",
331 | "print(prova_1)\n",
332 | "print(prova_2)\n",
333 | "print(projeto)\n",
334 | "\n",
335 | "prova_1 += 1\n",
336 | "\n",
337 | "print(notas_do_semestre)\n",
338 | "print(prova_1)\n",
339 | "print(prova_2)\n",
340 | "print(projeto)"
341 | ]
342 | },
343 | {
344 | "cell_type": "markdown",
345 | "metadata": {},
346 | "source": [
347 | "### Zip: Compactando listas"
348 | ]
349 | },
350 | {
351 | "cell_type": "code",
352 | "execution_count": 26,
353 | "metadata": {},
354 | "outputs": [
355 | {
356 | "name": "stdout",
357 | "output_type": "stream",
358 | "text": [
359 | "['Ônix', 'Gol', 'Uno']\n",
360 | "[50000, 30000, 20000]\n"
361 | ]
362 | }
363 | ],
364 | "source": [
365 | "carros = ['Ônix', 'Gol', 'Uno']\n",
366 | "precos = [50000, 30000, 20000]\n",
367 | "\n",
368 | "print(carros)\n",
369 | "print(precos)"
370 | ]
371 | },
372 | {
373 | "cell_type": "code",
374 | "execution_count": 27,
375 | "metadata": {},
376 | "outputs": [
377 | {
378 | "data": {
379 | "text/plain": [
380 | ""
381 | ]
382 | },
383 | "execution_count": 27,
384 | "metadata": {},
385 | "output_type": "execute_result"
386 | }
387 | ],
388 | "source": [
389 | "carros_com_precos_zip = zip(carros, precos)\n",
390 | "carros_com_precos_zip"
391 | ]
392 | },
393 | {
394 | "cell_type": "code",
395 | "execution_count": 28,
396 | "metadata": {},
397 | "outputs": [
398 | {
399 | "data": {
400 | "text/plain": [
401 | "[('Ônix', 50000), ('Gol', 30000), ('Uno', 20000)]"
402 | ]
403 | },
404 | "execution_count": 28,
405 | "metadata": {},
406 | "output_type": "execute_result"
407 | }
408 | ],
409 | "source": [
410 | "carros_com_precos = list(carros_com_precos_zip)\n",
411 | "carros_com_precos"
412 | ]
413 | },
414 | {
415 | "cell_type": "code",
416 | "execution_count": 29,
417 | "metadata": {},
418 | "outputs": [
419 | {
420 | "name": "stdout",
421 | "output_type": "stream",
422 | "text": [
423 | "('Ônix', 50000)\n",
424 | "('Gol', 30000)\n",
425 | "('Uno', 20000)\n"
426 | ]
427 | }
428 | ],
429 | "source": [
430 | "for x in carros_com_precos:\n",
431 | " print(x)"
432 | ]
433 | },
434 | {
435 | "cell_type": "code",
436 | "execution_count": 30,
437 | "metadata": {},
438 | "outputs": [
439 | {
440 | "name": "stdout",
441 | "output_type": "stream",
442 | "text": [
443 | "Ônix\n",
444 | "50000\n",
445 | "Gol\n",
446 | "30000\n",
447 | "Uno\n",
448 | "20000\n"
449 | ]
450 | }
451 | ],
452 | "source": [
453 | "for nome, preco in carros_com_precos:\n",
454 | " print(nome)\n",
455 | " print(preco)"
456 | ]
457 | },
458 | {
459 | "cell_type": "code",
460 | "execution_count": 36,
461 | "metadata": {},
462 | "outputs": [
463 | {
464 | "name": "stdout",
465 | "output_type": "stream",
466 | "text": [
467 | "Ônix\n",
468 | "50000\n",
469 | "Gol\n",
470 | "30000\n",
471 | "Uno\n",
472 | "20000\n"
473 | ]
474 | }
475 | ],
476 | "source": [
477 | "for nome, preco in zip(carros, precos):\n",
478 | " print(nome)\n",
479 | " print(preco)"
480 | ]
481 | }
482 | ],
483 | "metadata": {
484 | "kernelspec": {
485 | "display_name": "Python 3",
486 | "language": "python",
487 | "name": "python3"
488 | },
489 | "language_info": {
490 | "codemirror_mode": {
491 | "name": "ipython",
492 | "version": 3
493 | },
494 | "file_extension": ".py",
495 | "mimetype": "text/x-python",
496 | "name": "python",
497 | "nbconvert_exporter": "python",
498 | "pygments_lexer": "ipython3",
499 | "version": "3.8.5"
500 | }
501 | },
502 | "nbformat": 4,
503 | "nbformat_minor": 4
504 | }
505 |
--------------------------------------------------------------------------------
/08_dicionarios.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "## **Python Essencial para Data Science**\n",
8 | "**Prof. Dr. Samuel Martins (@hisamuka @xavecoding)**
\n",
9 | "xavecoding: https://youtube.com/c/xavecoding
\n",
10 | "\n",
11 | "
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License."
12 | ]
13 | },
14 | {
15 | "cell_type": "markdown",
16 | "metadata": {},
17 | "source": [
18 | "## Dicionários (tabelas hash)\n",
19 | "Dicionários são tabelas hash: estruturas que mapeiams _chaves_ à _valores_.
\n",
20 | "Muito utilizado quando queremos **acesso rápido** (_O(1)_) a elementos/valores associados a uma dada chave."
21 | ]
22 | },
23 | {
24 | "cell_type": "code",
25 | "execution_count": 1,
26 | "metadata": {},
27 | "outputs": [],
28 | "source": [
29 | "# ALTERNATIVA 1 ==> VALORES EM VARIÁVEIS SOLTAS\n",
30 | "nome = 'Luke Skywalker'\n",
31 | "idade = 16\n",
32 | "peso = 60.0"
33 | ]
34 | },
35 | {
36 | "cell_type": "code",
37 | "execution_count": 2,
38 | "metadata": {},
39 | "outputs": [],
40 | "source": [
41 | "# ALTERNATIVA 2 (usando listas ou tuplas) ==> você precisa decorar quais são os índices que\n",
42 | "# guardam cada um dos elementos\n",
43 | "luke_lista = ['Luke Skywalker', 16, 60.0]"
44 | ]
45 | },
46 | {
47 | "cell_type": "code",
48 | "execution_count": 3,
49 | "metadata": {},
50 | "outputs": [],
51 | "source": [
52 | "# ALTERNATIVA 3 (dicionários)\n",
53 | "luke = {'nome': 'Luke Skywalker', 'idade': 16, 'peso': 60.0}"
54 | ]
55 | },
56 | {
57 | "cell_type": "markdown",
58 | "metadata": {},
59 | "source": [
60 | "Neste caso, 'nome', 'idade' e 'peso' sãos as chaves com os respectivos valores 'Luke Skywalker', 16, 60.0."
61 | ]
62 | },
63 | {
64 | "cell_type": "markdown",
65 | "metadata": {},
66 | "source": [
67 | "Um dado _valor_ é acessado passando a _chave_ via **colchetes**:"
68 | ]
69 | },
70 | {
71 | "cell_type": "code",
72 | "execution_count": 4,
73 | "metadata": {},
74 | "outputs": [
75 | {
76 | "data": {
77 | "text/plain": [
78 | "'Luke Skywalker'"
79 | ]
80 | },
81 | "execution_count": 4,
82 | "metadata": {},
83 | "output_type": "execute_result"
84 | }
85 | ],
86 | "source": [
87 | "luke['nome']"
88 | ]
89 | },
90 | {
91 | "cell_type": "code",
92 | "execution_count": 5,
93 | "metadata": {},
94 | "outputs": [
95 | {
96 | "data": {
97 | "text/plain": [
98 | "16"
99 | ]
100 | },
101 | "execution_count": 5,
102 | "metadata": {},
103 | "output_type": "execute_result"
104 | }
105 | ],
106 | "source": [
107 | "luke['idade']"
108 | ]
109 | },
110 | {
111 | "cell_type": "code",
112 | "execution_count": 6,
113 | "metadata": {},
114 | "outputs": [
115 | {
116 | "data": {
117 | "text/plain": [
118 | "60.0"
119 | ]
120 | },
121 | "execution_count": 6,
122 | "metadata": {},
123 | "output_type": "execute_result"
124 | }
125 | ],
126 | "source": [
127 | "luke['peso']"
128 | ]
129 | },
130 | {
131 | "cell_type": "markdown",
132 | "metadata": {},
133 | "source": [
134 | "Podemos alterar um valor acessando da mesma maneira:"
135 | ]
136 | },
137 | {
138 | "cell_type": "code",
139 | "execution_count": 7,
140 | "metadata": {},
141 | "outputs": [
142 | {
143 | "name": "stdout",
144 | "output_type": "stream",
145 | "text": [
146 | "{'nome': 'Luke Skywalker', 'idade': 16, 'peso': 70}\n"
147 | ]
148 | }
149 | ],
150 | "source": [
151 | "luke['peso'] = 70\n",
152 | "print(luke)"
153 | ]
154 | },
155 | {
156 | "cell_type": "markdown",
157 | "metadata": {},
158 | "source": [
159 | "Podemos **adicionar** um novo elemento, apenas informando o novo _par de chaves e valor_:"
160 | ]
161 | },
162 | {
163 | "cell_type": "code",
164 | "execution_count": 8,
165 | "metadata": {},
166 | "outputs": [
167 | {
168 | "name": "stdout",
169 | "output_type": "stream",
170 | "text": [
171 | "{'nome': 'Luke Skywalker', 'idade': 16, 'peso': 70, 'eh_jedi': True}\n"
172 | ]
173 | }
174 | ],
175 | "source": [
176 | "luke['eh_jedi'] = True\n",
177 | "print(luke)"
178 | ]
179 | },
180 | {
181 | "cell_type": "code",
182 | "execution_count": 9,
183 | "metadata": {},
184 | "outputs": [
185 | {
186 | "name": "stdout",
187 | "output_type": "stream",
188 | "text": [
189 | "{'nome': 'Luke Skywalker', 'idade': 16, 'peso': 70, 'eh_jedi': True, 'notas': [10.0, 5.0, 2.2]}\n"
190 | ]
191 | }
192 | ],
193 | "source": [
194 | "luke['notas'] = [10.0, 5.0, 2.2]\n",
195 | "print(luke)"
196 | ]
197 | },
198 | {
199 | "cell_type": "markdown",
200 | "metadata": {},
201 | "source": [
202 | "Note que usamos **diversos tipos** de _valores_ no mesmo dicionário. Podemos também usar **mais de um tipo de chaves**, apesar que, geralmente, isso não é muito usado."
203 | ]
204 | },
205 | {
206 | "cell_type": "code",
207 | "execution_count": 10,
208 | "metadata": {},
209 | "outputs": [
210 | {
211 | "name": "stdout",
212 | "output_type": "stream",
213 | "text": [
214 | "{'nome': 'Luke Skywalker', 'idade': 16, 'peso': 70, 'eh_jedi': True, 'notas': [10.0, 5.0, 2.2], 1: 'Um'}\n"
215 | ]
216 | }
217 | ],
218 | "source": [
219 | "luke[1] = 'Um'\n",
220 | "print(luke)"
221 | ]
222 | },
223 | {
224 | "cell_type": "markdown",
225 | "metadata": {},
226 | "source": [
227 | "Para copiar um dicionário:"
228 | ]
229 | },
230 | {
231 | "cell_type": "code",
232 | "execution_count": 11,
233 | "metadata": {},
234 | "outputs": [
235 | {
236 | "name": "stdout",
237 | "output_type": "stream",
238 | "text": [
239 | "{'nome': 'Luke Skywalker', 'idade': 16, 'peso': 70, 'eh_jedi': True, 'notas': [10.0, 5.0, 2.2]}\n",
240 | "{'nome': 'Luke Skywalker', 'idade': 16, 'peso': 70, 'eh_jedi': True, 'notas': [10.0, 5.0, 2.2], 1: 'Um'}\n"
241 | ]
242 | }
243 | ],
244 | "source": [
245 | "luke_copia = dict(luke) # retorna uma cópia do dicionário `luke`\n",
246 | "luke.pop(1, None) # remove a chave 1 do dicionário\n",
247 | "\n",
248 | "print(luke)\n",
249 | "print(luke_copia)"
250 | ]
251 | },
252 | {
253 | "cell_type": "markdown",
254 | "metadata": {},
255 | "source": [
256 | "#### Checando se um dicionário possui uma dada chave"
257 | ]
258 | },
259 | {
260 | "cell_type": "code",
261 | "execution_count": 12,
262 | "metadata": {},
263 | "outputs": [
264 | {
265 | "data": {
266 | "text/plain": [
267 | "{'nome': 'Luke Skywalker',\n",
268 | " 'idade': 16,\n",
269 | " 'peso': 70,\n",
270 | " 'eh_jedi': True,\n",
271 | " 'notas': [10.0, 5.0, 2.2]}"
272 | ]
273 | },
274 | "execution_count": 12,
275 | "metadata": {},
276 | "output_type": "execute_result"
277 | }
278 | ],
279 | "source": [
280 | "luke"
281 | ]
282 | },
283 | {
284 | "cell_type": "code",
285 | "execution_count": 13,
286 | "metadata": {},
287 | "outputs": [
288 | {
289 | "data": {
290 | "text/plain": [
291 | "True"
292 | ]
293 | },
294 | "execution_count": 13,
295 | "metadata": {},
296 | "output_type": "execute_result"
297 | }
298 | ],
299 | "source": [
300 | "'nome' in luke"
301 | ]
302 | },
303 | {
304 | "cell_type": "code",
305 | "execution_count": 14,
306 | "metadata": {},
307 | "outputs": [
308 | {
309 | "data": {
310 | "text/plain": [
311 | "False"
312 | ]
313 | },
314 | "execution_count": 14,
315 | "metadata": {},
316 | "output_type": "execute_result"
317 | }
318 | ],
319 | "source": [
320 | "'profissisao' in luke"
321 | ]
322 | },
323 | {
324 | "cell_type": "code",
325 | "execution_count": 15,
326 | "metadata": {},
327 | "outputs": [
328 | {
329 | "data": {
330 | "text/plain": [
331 | "True"
332 | ]
333 | },
334 | "execution_count": 15,
335 | "metadata": {},
336 | "output_type": "execute_result"
337 | }
338 | ],
339 | "source": [
340 | "'profissisao' not in luke"
341 | ]
342 | },
343 | {
344 | "cell_type": "markdown",
345 | "metadata": {},
346 | "source": [
347 | "#### For-each em Dicionários"
348 | ]
349 | },
350 | {
351 | "cell_type": "code",
352 | "execution_count": 17,
353 | "metadata": {},
354 | "outputs": [
355 | {
356 | "name": "stdout",
357 | "output_type": "stream",
358 | "text": [
359 | "luke['nome'] = Luke Skywalker\n",
360 | "luke['idade'] = 16\n",
361 | "luke['peso'] = 70\n",
362 | "luke['eh_jedi'] = True\n",
363 | "luke['notas'] = [10.0, 5.0, 2.2]\n"
364 | ]
365 | }
366 | ],
367 | "source": [
368 | "for chave in luke:\n",
369 | " print(f'luke[\\'{chave}\\'] = {luke[chave]}')"
370 | ]
371 | },
372 | {
373 | "cell_type": "code",
374 | "execution_count": 18,
375 | "metadata": {},
376 | "outputs": [
377 | {
378 | "data": {
379 | "text/plain": [
380 | "dict_keys(['nome', 'idade', 'peso', 'eh_jedi', 'notas'])"
381 | ]
382 | },
383 | "execution_count": 18,
384 | "metadata": {},
385 | "output_type": "execute_result"
386 | }
387 | ],
388 | "source": [
389 | "luke.keys() # retorna uma lista com todas as chaves do dicionário"
390 | ]
391 | },
392 | {
393 | "cell_type": "code",
394 | "execution_count": 19,
395 | "metadata": {},
396 | "outputs": [
397 | {
398 | "name": "stdout",
399 | "output_type": "stream",
400 | "text": [
401 | "luke['nome'] = Luke Skywalker\n",
402 | "luke['idade'] = 16\n",
403 | "luke['peso'] = 70\n",
404 | "luke['eh_jedi'] = True\n",
405 | "luke['notas'] = [10.0, 5.0, 2.2]\n"
406 | ]
407 | }
408 | ],
409 | "source": [
410 | "for chave in luke.keys():\n",
411 | " print(f'luke[\\'{chave}\\'] = {luke[chave]}')"
412 | ]
413 | },
414 | {
415 | "cell_type": "code",
416 | "execution_count": 20,
417 | "metadata": {},
418 | "outputs": [
419 | {
420 | "data": {
421 | "text/plain": [
422 | "dict_values(['Luke Skywalker', 16, 70, True, [10.0, 5.0, 2.2]])"
423 | ]
424 | },
425 | "execution_count": 20,
426 | "metadata": {},
427 | "output_type": "execute_result"
428 | }
429 | ],
430 | "source": [
431 | "luke.values() # retorna uma lista com todos os valores do dicionário"
432 | ]
433 | },
434 | {
435 | "cell_type": "code",
436 | "execution_count": 21,
437 | "metadata": {},
438 | "outputs": [
439 | {
440 | "name": "stdout",
441 | "output_type": "stream",
442 | "text": [
443 | "Luke Skywalker\n",
444 | "16\n",
445 | "70\n",
446 | "True\n",
447 | "[10.0, 5.0, 2.2]\n"
448 | ]
449 | }
450 | ],
451 | "source": [
452 | "for valor in luke.values():\n",
453 | " print(f'{valor}')"
454 | ]
455 | },
456 | {
457 | "cell_type": "code",
458 | "execution_count": 22,
459 | "metadata": {},
460 | "outputs": [
461 | {
462 | "data": {
463 | "text/plain": [
464 | "dict_items([('nome', 'Luke Skywalker'), ('idade', 16), ('peso', 70), ('eh_jedi', True), ('notas', [10.0, 5.0, 2.2])])"
465 | ]
466 | },
467 | "execution_count": 22,
468 | "metadata": {},
469 | "output_type": "execute_result"
470 | }
471 | ],
472 | "source": [
473 | "luke.items() # retorna uma lista de tuplas, onde cada tupla representa um pair chave e valor do dicionário"
474 | ]
475 | },
476 | {
477 | "cell_type": "code",
478 | "execution_count": 24,
479 | "metadata": {},
480 | "outputs": [
481 | {
482 | "name": "stdout",
483 | "output_type": "stream",
484 | "text": [
485 | "luke['nome'] = Luke Skywalker\n",
486 | "luke['idade'] = 16\n",
487 | "luke['peso'] = 70\n",
488 | "luke['eh_jedi'] = True\n",
489 | "luke['notas'] = [10.0, 5.0, 2.2]\n"
490 | ]
491 | }
492 | ],
493 | "source": [
494 | "for chave, valor in luke.items():\n",
495 | " print(f'luke[\\'{chave}\\'] = {valor}')"
496 | ]
497 | },
498 | {
499 | "cell_type": "markdown",
500 | "metadata": {},
501 | "source": [
502 | "#### Dictionary Comprehensions"
503 | ]
504 | },
505 | {
506 | "cell_type": "code",
507 | "execution_count": 25,
508 | "metadata": {},
509 | "outputs": [
510 | {
511 | "name": "stdout",
512 | "output_type": "stream",
513 | "text": [
514 | "['Mercúrio', 'Vênus', 'Terra', 'Marte', 'Júpiter', 'Saturno', 'Urano', 'Netuno']\n"
515 | ]
516 | }
517 | ],
518 | "source": [
519 | "planetas = ['Mercúrio', 'Vênus', 'Terra', 'Marte', 'Júpiter', 'Saturno', 'Urano', 'Netuno']\n",
520 | "print(planetas)"
521 | ]
522 | },
523 | {
524 | "cell_type": "code",
525 | "execution_count": 27,
526 | "metadata": {},
527 | "outputs": [
528 | {
529 | "data": {
530 | "text/plain": [
531 | "{'Mercúrio': 'M',\n",
532 | " 'Vênus': 'V',\n",
533 | " 'Terra': 'T',\n",
534 | " 'Marte': 'M',\n",
535 | " 'Júpiter': 'J',\n",
536 | " 'Saturno': 'S',\n",
537 | " 'Urano': 'U',\n",
538 | " 'Netuno': 'N'}"
539 | ]
540 | },
541 | "execution_count": 27,
542 | "metadata": {},
543 | "output_type": "execute_result"
544 | }
545 | ],
546 | "source": [
547 | "# queremos construir um dicionário, onde cada chave é o nome do planeta, e seu respectivo valor é a inicial do planeta\n",
548 | "iniciais_dos_planetas = {plan: plan[0] for plan in planetas} # para cada planeta da nossa lista\n",
549 | "iniciais_dos_planetas"
550 | ]
551 | },
552 | {
553 | "cell_type": "code",
554 | "execution_count": null,
555 | "metadata": {},
556 | "outputs": [],
557 | "source": []
558 | }
559 | ],
560 | "metadata": {
561 | "kernelspec": {
562 | "display_name": "Python 3",
563 | "language": "python",
564 | "name": "python3"
565 | },
566 | "language_info": {
567 | "codemirror_mode": {
568 | "name": "ipython",
569 | "version": 3
570 | },
571 | "file_extension": ".py",
572 | "mimetype": "text/x-python",
573 | "name": "python",
574 | "nbconvert_exporter": "python",
575 | "pygments_lexer": "ipython3",
576 | "version": "3.8.5"
577 | }
578 | },
579 | "nbformat": 4,
580 | "nbformat_minor": 4
581 | }
582 |
--------------------------------------------------------------------------------
/09_bibliotecas_externas.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "## **Python Essencial para Data Science**\n",
8 | "**Prof. Dr. Samuel Martins (@hisamuka @xavecoding)**
\n",
9 | "xavecoding: https://youtube.com/c/xavecoding
\n",
10 | "\n",
11 | "
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License."
12 | ]
13 | },
14 | {
15 | "cell_type": "markdown",
16 | "metadata": {},
17 | "source": [
18 | "## Módulos internos/externos"
19 | ]
20 | },
21 | {
22 | "cell_type": "markdown",
23 | "metadata": {},
24 | "source": [
25 | "#### Importando um módulo (biblioteca)"
26 | ]
27 | },
28 | {
29 | "cell_type": "code",
30 | "execution_count": 1,
31 | "metadata": {},
32 | "outputs": [],
33 | "source": [
34 | "import math"
35 | ]
36 | },
37 | {
38 | "cell_type": "code",
39 | "execution_count": 3,
40 | "metadata": {},
41 | "outputs": [
42 | {
43 | "data": {
44 | "text/plain": [
45 | "1024.0"
46 | ]
47 | },
48 | "execution_count": 3,
49 | "metadata": {},
50 | "output_type": "execute_result"
51 | }
52 | ],
53 | "source": [
54 | "math.pow(2, 10)"
55 | ]
56 | },
57 | {
58 | "cell_type": "markdown",
59 | "metadata": {},
60 | "source": [
61 | "#### Atribuindo um nome diferente (alias) a um modulo importado"
62 | ]
63 | },
64 | {
65 | "cell_type": "code",
66 | "execution_count": 4,
67 | "metadata": {},
68 | "outputs": [],
69 | "source": [
70 | "import random as ran"
71 | ]
72 | },
73 | {
74 | "cell_type": "code",
75 | "execution_count": 9,
76 | "metadata": {},
77 | "outputs": [
78 | {
79 | "data": {
80 | "text/plain": [
81 | "4"
82 | ]
83 | },
84 | "execution_count": 9,
85 | "metadata": {},
86 | "output_type": "execute_result"
87 | }
88 | ],
89 | "source": [
90 | "ran.randint(0, 10)"
91 | ]
92 | },
93 | {
94 | "cell_type": "code",
95 | "execution_count": 11,
96 | "metadata": {},
97 | "outputs": [
98 | {
99 | "name": "stdout",
100 | "output_type": "stream",
101 | "text": [
102 | "Help on method randint in module random:\n",
103 | "\n",
104 | "randint(a, b) method of random.Random instance\n",
105 | " Return random integer in range [a, b], including both end points.\n",
106 | "\n"
107 | ]
108 | }
109 | ],
110 | "source": [
111 | "help(ran.randint)"
112 | ]
113 | },
114 | {
115 | "cell_type": "code",
116 | "execution_count": 13,
117 | "metadata": {},
118 | "outputs": [],
119 | "source": [
120 | "import numpy as np"
121 | ]
122 | },
123 | {
124 | "cell_type": "code",
125 | "execution_count": 14,
126 | "metadata": {},
127 | "outputs": [
128 | {
129 | "data": {
130 | "text/plain": [
131 | "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
132 | ]
133 | },
134 | "execution_count": 14,
135 | "metadata": {},
136 | "output_type": "execute_result"
137 | }
138 | ],
139 | "source": [
140 | "np.arange(10)"
141 | ]
142 | },
143 | {
144 | "cell_type": "markdown",
145 | "metadata": {},
146 | "source": [
147 | "#### Importando apenas algumas \"coisas\" (funções, atributos, constantes, ...) de um módulo\n",
148 | "Deixa todas as \"coisas\" acessíveis sem a necessidade de chamar `modulo.coisa`"
149 | ]
150 | },
151 | {
152 | "cell_type": "code",
153 | "execution_count": 21,
154 | "metadata": {},
155 | "outputs": [],
156 | "source": [
157 | "from math import log2, pi, sqrt"
158 | ]
159 | },
160 | {
161 | "cell_type": "code",
162 | "execution_count": 22,
163 | "metadata": {},
164 | "outputs": [
165 | {
166 | "name": "stdout",
167 | "output_type": "stream",
168 | "text": [
169 | "1.4142135623730951\n",
170 | "4.0\n",
171 | "3.141592653589793\n"
172 | ]
173 | }
174 | ],
175 | "source": [
176 | "print(sqrt(2))\n",
177 | "print(log2(16))\n",
178 | "print(pi)"
179 | ]
180 | },
181 | {
182 | "cell_type": "markdown",
183 | "metadata": {},
184 | "source": [
185 | "#### Importando todas as \"coisas\" (funções, atributos, constantes, ...) de um módulo"
186 | ]
187 | },
188 | {
189 | "cell_type": "code",
190 | "execution_count": 24,
191 | "metadata": {},
192 | "outputs": [
193 | {
194 | "data": {
195 | "text/plain": [
196 | "2.0"
197 | ]
198 | },
199 | "execution_count": 24,
200 | "metadata": {},
201 | "output_type": "execute_result"
202 | }
203 | ],
204 | "source": [
205 | "from math import *\n",
206 | "\n",
207 | "log10(100)"
208 | ]
209 | },
210 | {
211 | "cell_type": "markdown",
212 | "metadata": {},
213 | "source": [
214 | "Apesar de se possível, tal prática **não é indicada**, uma vez que (1) \"coisas\", p. ex., de módulos diferentes mas de mesmo nome podem ser importadas, e (2) pode não haver necessidade de ter acesso a todas as \"coisas\" do módulo."
215 | ]
216 | },
217 | {
218 | "cell_type": "markdown",
219 | "metadata": {},
220 | "source": [
221 | "### Submódulos\n",
222 | "Alguns módulos podem possuir **submódulos**:"
223 | ]
224 | },
225 | {
226 | "cell_type": "code",
227 | "execution_count": 25,
228 | "metadata": {},
229 | "outputs": [],
230 | "source": [
231 | "import numpy as np"
232 | ]
233 | },
234 | {
235 | "cell_type": "code",
236 | "execution_count": 27,
237 | "metadata": {},
238 | "outputs": [
239 | {
240 | "data": {
241 | "text/plain": [
242 | ""
243 | ]
244 | },
245 | "execution_count": 27,
246 | "metadata": {},
247 | "output_type": "execute_result"
248 | }
249 | ],
250 | "source": [
251 | "np.random"
252 | ]
253 | },
254 | {
255 | "cell_type": "code",
256 | "execution_count": 28,
257 | "metadata": {},
258 | "outputs": [
259 | {
260 | "data": {
261 | "text/plain": [
262 | "9"
263 | ]
264 | },
265 | "execution_count": 28,
266 | "metadata": {},
267 | "output_type": "execute_result"
268 | }
269 | ],
270 | "source": [
271 | "from numpy import random\n",
272 | "random.randint(0, 10)"
273 | ]
274 | },
275 | {
276 | "cell_type": "markdown",
277 | "metadata": {},
278 | "source": [
279 | "### Módulos Uteis"
280 | ]
281 | },
282 | {
283 | "cell_type": "markdown",
284 | "metadata": {},
285 | "source": [
286 | "- `os`: funções do sistema operacional\n",
287 | "- `glob`: funções para criar listas a partir de diretórios do sistema\n",
288 | "- `shutil`: funções para gerenciar arquivos e diretórios\n",
289 | "- `math`: funções matemáticas\n",
290 | "- `random`: geradores de números aleatórios\n",
291 | "- `pickle`: protocolos para (de-)serialização de dados de entrada e saída"
292 | ]
293 | },
294 | {
295 | "cell_type": "markdown",
296 | "metadata": {},
297 | "source": [
298 | "### Outros Tópicos"
299 | ]
300 | },
301 | {
302 | "cell_type": "markdown",
303 | "metadata": {},
304 | "source": [
305 | "- Manipulação de arquivos\n",
306 | "- Orientação a objetos\n",
307 | " - Classes\n",
308 | " - Objetos\n",
309 | " - Métodos, métodos estáticos\n",
310 | " - Herança\n",
311 | "- Básico da biblioteca `numpy`\n",
312 | "- Básico da biblioteca `matplotlib`"
313 | ]
314 | }
315 | ],
316 | "metadata": {
317 | "kernelspec": {
318 | "display_name": "Python 3",
319 | "language": "python",
320 | "name": "python3"
321 | },
322 | "language_info": {
323 | "codemirror_mode": {
324 | "name": "ipython",
325 | "version": 3
326 | },
327 | "file_extension": ".py",
328 | "mimetype": "text/x-python",
329 | "name": "python",
330 | "nbconvert_exporter": "python",
331 | "pygments_lexer": "ipython3",
332 | "version": "3.8.5"
333 | }
334 | },
335 | "nbformat": 4,
336 | "nbformat_minor": 4
337 | }
338 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | ## Python Essencial para Data Science
2 |
3 | Este material apresenta os códigos do curso **[Python Essencial para Data Science](https://www.youtube.com/playlist?list=PL3ZslI15yo2qCEmnYOa2sq6VQOzQ2CFhj)**.
4 |
5 | **Professor:** [Samuel Martins (Samuka)](http://hisamuka.github.io/) - [@hisamuka](https://hisamuka.github.io)
6 |
7 | A pasta `codigos_base` contém todos os arquivos com os códigos base utilizados nos vídeos. Utilize-os para acompanhar os vídeos a partir do mesmo ponto de partida dos vídeos.
8 |
9 | ### Materiais de cada vídeo
10 | - **Conceitos básicos:**
11 | - [#1 - Primeiro Script: Hello world!](https://github.com/xavecoding/python-essencial-para-data-science/blob/main/hello_world.py)
12 | - [#2 - Variáveis e tipos](https://github.com/xavecoding/python-essencial-para-data-science/blob/main/01_variaveis_e_tipos.ipynb)
13 | - [#3 - Atribuição múltipla e casting](https://github.com/xavecoding/python-essencial-para-data-science/blob/main/01_variaveis_e_tipos.ipynb)
14 | - [#4 - Operadores aritméticos e print](https://github.com/xavecoding/python-essencial-para-data-science/blob/main/01_variaveis_e_tipos.ipynb)
15 | - **Funções:**
16 | - [#5 - Funções](https://github.com/xavecoding/python-essencial-para-data-science/blob/main/02_funcoes.ipynb)
17 | - [#6 - Escopo e argumentos default](https://github.com/xavecoding/python-essencial-para-data-science/blob/main/02_funcoes.ipynb)
18 | - [#7 - Parâmetros nomeados e function annotation](https://github.com/xavecoding/python-essencial-para-data-science/blob/main/02_funcoes.ipynb)
19 | - **Condicionais:**
20 | - [#8 - Condicionais: Parte 1](https://github.com/xavecoding/python-essencial-para-data-science/blob/main/03_condicionais.ipynb)
21 | - [#9 - Condicionais: Parte 2](https://github.com/xavecoding/python-essencial-para-data-science/blob/main/03_condicionais.ipynb)
22 | - **Repetições:**
23 | - [#10 - Intervalos](https://github.com/xavecoding/python-essencial-para-data-science/blob/main/04_loops.ipynb)
24 | - [#11 - Repetições](https://github.com/xavecoding/python-essencial-para-data-science/blob/main/04_loops.ipynb)
25 | - **List**
26 | - [#12 - Listas: Conceitos Básicos](https://github.com/xavecoding/python-essencial-para-data-science/blob/main/05_lists.ipynb)
27 | - [#13 - Listas: Indexação](https://github.com/xavecoding/python-essencial-para-data-science/blob/main/05_lists.ipynb)
28 | - [#14 - Listas: Slicing](https://github.com/xavecoding/python-essencial-para-data-science/blob/main/05_lists.ipynb)
29 | - [#15 - For-each com Listas](https://github.com/xavecoding/python-essencial-para-data-science/blob/main/05_lists.ipynb)
30 | - [#16 - Listas: Funções e métodos](https://github.com/xavecoding/python-essencial-para-data-science/blob/main/05_lists.ipynb)
31 | - [#17 - Listas: Mais e métodos](https://github.com/xavecoding/python-essencial-para-data-science/blob/main/05_lists.ipynb)
32 | - [#18 - List comprehensions](https://github.com/xavecoding/python-essencial-para-data-science/blob/main/05_lists.ipynb)
33 | - **Strings**
34 | - [#19 - Strings: Parte 1](https://github.com/xavecoding/python-essencial-para-data-science/blob/main/06_strings.ipynb)
35 | - [#20 - Strings: Parte 2](https://github.com/xavecoding/python-essencial-para-data-science/blob/main/06_strings.ipynb)
36 | - **Tuple**
37 | - [#21 - Tuplas](https://github.com/xavecoding/python-essencial-para-data-science/blob/main/07_tuplas.ipynb)
38 | - **Dict (Dicionários)**
39 | - [#22 - Dicionários: Parte 1](https://github.com/xavecoding/python-essencial-para-data-science/blob/main/08_dicionarios.ipynb)
40 | - [#23 - Dicionários: Parte 2](https://github.com/xavecoding/python-essencial-para-data-science/blob/main/08_dicionarios.ipynb)
41 | - **Outros assuntos**
42 | - [#24 - Bibliotecas Externas](https://github.com/xavecoding/python-essencial-para-data-science/blob/main/09_bibliotecas_externas.ipynb)
43 |
44 |
45 |
46 |
47 | 
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.
48 |
--------------------------------------------------------------------------------
/codigos_base/01_variaveis_e_tipos.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "## **Python Essencial para Data Science**\n",
8 | "**Prof. Dr. Samuel Martins (@hisamuka @xavecoding)**
\n",
9 | "xavecoding: https://youtube.com/c/xavecoding
\n",
10 | "\n",
11 | "Neste tutorial, vamos aprender os conceitos básicos para desenvolvermos nossos primeiros programas em Python!
\n",
12 | "Boa parte dos exemplos deste tutorial é inspirado no [curso de Python do Kaggle](https://www.kaggle.com/learn/python).
\n",
13 | "\n",
14 | "
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License."
15 | ]
16 | },
17 | {
18 | "cell_type": "code",
19 | "execution_count": 1,
20 | "metadata": {},
21 | "outputs": [
22 | {
23 | "data": {
24 | "text/html": [
25 | "\n"
28 | ],
29 | "text/plain": [
30 | ""
31 | ]
32 | },
33 | "metadata": {},
34 | "output_type": "display_data"
35 | }
36 | ],
37 | "source": [
38 | "%%html\n",
39 | ""
42 | ]
43 | },
44 | {
45 | "cell_type": "markdown",
46 | "metadata": {},
47 | "source": [
48 | "## Variáveis\n",
49 | "\n",
50 | "### Tipos\n",
51 | "Python tem diferentes tipos de dados, mas no fundo, *tudo é um objeto*.
\n",
52 | "Variáveis podem ser definidas em qualquer lugar.\n",
53 | "\n",
54 | "Veja alguns tipos:\n",
55 | "\n",
56 | "| Tipo | Exemplo |\n",
57 | "|---------|-------------------|\n",
58 | "| Integer | 1 10 -4 |\n",
59 | "| Float | 1.0 -0.223 3.1415 |\n",
60 | "| String | \"Hello world\" |"
61 | ]
62 | },
63 | {
64 | "cell_type": "markdown",
65 | "metadata": {},
66 | "source": [
67 | "## Instanciando variáveis"
68 | ]
69 | },
70 | {
71 | "cell_type": "code",
72 | "execution_count": 18,
73 | "metadata": {},
74 | "outputs": [],
75 | "source": []
76 | },
77 | {
78 | "cell_type": "markdown",
79 | "metadata": {},
80 | "source": [
81 | "### Type()\n",
82 | "Use a função type() para descobrir o tipo de uma variável."
83 | ]
84 | },
85 | {
86 | "cell_type": "code",
87 | "execution_count": null,
88 | "metadata": {},
89 | "outputs": [],
90 | "source": []
91 | },
92 | {
93 | "cell_type": "markdown",
94 | "metadata": {},
95 | "source": [
96 | "### Dir()\n",
97 | "Use a função dir() para descobrir **todos os métodos** associados a um objeto:"
98 | ]
99 | },
100 | {
101 | "cell_type": "code",
102 | "execution_count": null,
103 | "metadata": {},
104 | "outputs": [],
105 | "source": []
106 | },
107 | {
108 | "cell_type": "markdown",
109 | "metadata": {},
110 | "source": [
111 | "### Usando métodos\n",
112 | "Métodos podem ser acessados usando: objeto.metodo"
113 | ]
114 | },
115 | {
116 | "cell_type": "code",
117 | "execution_count": null,
118 | "metadata": {},
119 | "outputs": [],
120 | "source": []
121 | },
122 | {
123 | "cell_type": "markdown",
124 | "metadata": {},
125 | "source": [
126 | "### Atribuição Múltipla"
127 | ]
128 | },
129 | {
130 | "cell_type": "code",
131 | "execution_count": 34,
132 | "metadata": {},
133 | "outputs": [],
134 | "source": []
135 | },
136 | {
137 | "cell_type": "markdown",
138 | "metadata": {},
139 | "source": [
140 | "### Python é uma linguagem *case-sensitive*"
141 | ]
142 | },
143 | {
144 | "cell_type": "code",
145 | "execution_count": null,
146 | "metadata": {},
147 | "outputs": [],
148 | "source": []
149 | },
150 | {
151 | "cell_type": "markdown",
152 | "metadata": {},
153 | "source": [
154 | "### Dinamicamente e Fortemente tipada\n",
155 | "\n",
156 | "**Dinamicamente:** o tipo é definido no momento da atribuição\n",
157 | "**Fortemente:** o interpretador não muda o tipo de uma variável inesperadamente"
158 | ]
159 | },
160 | {
161 | "cell_type": "code",
162 | "execution_count": null,
163 | "metadata": {},
164 | "outputs": [],
165 | "source": []
166 | },
167 | {
168 | "cell_type": "markdown",
169 | "metadata": {},
170 | "source": [
171 | "### Conversão de Tipos (*Casting*)"
172 | ]
173 | },
174 | {
175 | "cell_type": "code",
176 | "execution_count": null,
177 | "metadata": {},
178 | "outputs": [],
179 | "source": []
180 | },
181 | {
182 | "cell_type": "markdown",
183 | "metadata": {},
184 | "source": [
185 | "### Operadores Aritméticos\n",
186 | "\n",
187 | "| Operador | Nome | Descrição |\n",
188 | "|--------------|----------------------|--------------------------------------------------------------------------------------|\n",
189 | "| ``a + b`` | Adição | Soma de ``a`` e ``b`` |\n",
190 | "| ``a - b`` | Subtração | Diferença de ``a`` e ``b`` |\n",
191 | "| ``a * b`` | Multiplicação | Produto de ``a`` e ``b`` |\n",
192 | "| ``a / b`` | Divisão 'verdadeira' | Quociente de ``a`` e ``b`` |\n",
193 | "| ``a // b`` | Piso da Divisão | Quociente de ``a`` e ``b``, removendo partes fracionadas (arredondamento para baixo) |\n",
194 | "| ``a % b`` | Módulo | Resto da divisão de a ``a`` por ``b`` |\n",
195 | "| ``a ** b`` | Exponenciação | ``a`` elevado a ``b`` |\n",
196 | "| ``-a`` | Negação | Negativo de ``a`` |"
197 | ]
198 | },
199 | {
200 | "cell_type": "code",
201 | "execution_count": null,
202 | "metadata": {},
203 | "outputs": [],
204 | "source": []
205 | },
206 | {
207 | "cell_type": "code",
208 | "execution_count": null,
209 | "metadata": {},
210 | "outputs": [],
211 | "source": []
212 | },
213 | {
214 | "cell_type": "markdown",
215 | "metadata": {},
216 | "source": [
217 | "### A função print()\n",
218 | "A função _print()_ imprime uma string na tela/console.
\n",
219 | "Uma string pode ser definida com **aspas simples ''** ou **aspas duplas \"\"**.\n",
220 | "\n",
221 | "Por convenção, a comunidade usa **aspas simples ''**"
222 | ]
223 | },
224 | {
225 | "cell_type": "code",
226 | "execution_count": null,
227 | "metadata": {},
228 | "outputs": [],
229 | "source": []
230 | },
231 | {
232 | "cell_type": "markdown",
233 | "metadata": {},
234 | "source": [
235 | "
Para imprimir valores de _variáveis_ junto com uma _string/texto_, utilize a letra **_f_** antes das primeiras aspas, e coloque a variável entre **_{}_** (Python 3.6+):"
236 | ]
237 | },
238 | {
239 | "cell_type": "code",
240 | "execution_count": null,
241 | "metadata": {},
242 | "outputs": [],
243 | "source": []
244 | },
245 | {
246 | "cell_type": "markdown",
247 | "metadata": {},
248 | "source": [
249 | "
\n",
250 | "Alternativa, temos outras formas de impressão vindas de versões mais antigas do Python, porém ainda válidas:"
251 | ]
252 | },
253 | {
254 | "cell_type": "code",
255 | "execution_count": null,
256 | "metadata": {},
257 | "outputs": [],
258 | "source": []
259 | },
260 | {
261 | "cell_type": "code",
262 | "execution_count": null,
263 | "metadata": {},
264 | "outputs": [],
265 | "source": []
266 | },
267 | {
268 | "cell_type": "code",
269 | "execution_count": null,
270 | "metadata": {},
271 | "outputs": [],
272 | "source": []
273 | }
274 | ],
275 | "metadata": {
276 | "kernelspec": {
277 | "display_name": "Python 3",
278 | "language": "python",
279 | "name": "python3"
280 | },
281 | "language_info": {
282 | "codemirror_mode": {
283 | "name": "ipython",
284 | "version": 3
285 | },
286 | "file_extension": ".py",
287 | "mimetype": "text/x-python",
288 | "name": "python",
289 | "nbconvert_exporter": "python",
290 | "pygments_lexer": "ipython3",
291 | "version": "3.9.0"
292 | }
293 | },
294 | "nbformat": 4,
295 | "nbformat_minor": 4
296 | }
297 |
--------------------------------------------------------------------------------
/codigos_base/02_funcoes.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "## **Python Essencial para Data Science**\n",
8 | "**Prof. Dr. Samuel Martins (@hisamuka @xavecoding)**
\n",
9 | "xavecoding: https://youtube.com/c/xavecoding
\n",
10 | "\n",
11 | "
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License."
12 | ]
13 | },
14 | {
15 | "cell_type": "markdown",
16 | "metadata": {},
17 | "source": [
18 | "## Funções\n",
19 | "\n",
20 | "### Esqueleto de uma função em python:\n",
21 | "\n",
22 | "def functionName(param1, param2, param3=val):\n",
23 | " instruction 01\n",
24 | " instruction 02\n",
25 | " return X\n",
26 | ""
27 | ]
28 | },
29 | {
30 | "cell_type": "markdown",
31 | "metadata": {},
32 | "source": [
33 | "### Funções podem NÃO ter retorno"
34 | ]
35 | },
36 | {
37 | "cell_type": "code",
38 | "execution_count": null,
39 | "metadata": {},
40 | "outputs": [],
41 | "source": []
42 | },
43 | {
44 | "cell_type": "markdown",
45 | "metadata": {},
46 | "source": [
47 | "### Funções podem ter retorno"
48 | ]
49 | },
50 | {
51 | "cell_type": "code",
52 | "execution_count": null,
53 | "metadata": {},
54 | "outputs": [],
55 | "source": []
56 | },
57 | {
58 | "cell_type": "markdown",
59 | "metadata": {},
60 | "source": [
61 | "### Funções podem ter múltiplos retornos"
62 | ]
63 | },
64 | {
65 | "cell_type": "code",
66 | "execution_count": null,
67 | "metadata": {},
68 | "outputs": [],
69 | "source": []
70 | },
71 | {
72 | "cell_type": "markdown",
73 | "metadata": {},
74 | "source": [
75 | "### Escopo\n",
76 | "Todo **escopo** em Python (funções, loops, condicionais, classes, etc...) usam *dois pontos (:)* e *identação*:\n",
77 | "Os **dois pontos (:)** servem para _\"abrir\"_ o escopo, e _cada instrução_ dentro do escopo devem ser **identadas** à direita.\n",
78 | "\n",
79 | "Convenciona-se usar *espaços* ao invés de *tabs* para a **identação**. Todas as instruções do escopo **devem ter a mesma identação** (p. ex, a mesma quantidade de espaços)."
80 | ]
81 | },
82 | {
83 | "cell_type": "markdown",
84 | "metadata": {},
85 | "source": [
86 | "\n",
87 | "def functionName(param1, param2, param3=val):\n",
88 | " instruction 01 # 4 espaços de identação\n",
89 | " instruction 02 # 4 espaços de identação\n",
90 | " return X # 4 espaços de identação\n",
91 | ""
92 | ]
93 | },
94 | {
95 | "cell_type": "markdown",
96 | "metadata": {},
97 | "source": [
98 | "### Funções com parâmetros default (opcionais)"
99 | ]
100 | },
101 | {
102 | "cell_type": "markdown",
103 | "metadata": {},
104 | "source": [
105 | "Os parâmetros opcionais (ou seja, com valores _default_) devem sempre serem **os últimos parâmetros da função**."
106 | ]
107 | },
108 | {
109 | "cell_type": "code",
110 | "execution_count": null,
111 | "metadata": {},
112 | "outputs": [],
113 | "source": []
114 | },
115 | {
116 | "cell_type": "markdown",
117 | "metadata": {},
118 | "source": [
119 | "
\n",
120 | "Caso o parâmetro não seja chamado, seu valor default é usado."
121 | ]
122 | },
123 | {
124 | "cell_type": "code",
125 | "execution_count": null,
126 | "metadata": {},
127 | "outputs": [],
128 | "source": []
129 | },
130 | {
131 | "cell_type": "markdown",
132 | "metadata": {},
133 | "source": [
134 | "### Parâmetros Nomeados\n",
135 | "Ao chamar uma função, podemos passar seus parâmetros em qualquer ordem. Basta que informemos o nome do argumento/variável da função."
136 | ]
137 | },
138 | {
139 | "cell_type": "code",
140 | "execution_count": null,
141 | "metadata": {},
142 | "outputs": [],
143 | "source": []
144 | },
145 | {
146 | "cell_type": "markdown",
147 | "metadata": {},
148 | "source": [
149 | "### Function Annotations (PEP 3107)\n",
150 | "Há a possibilidade de indicar o tipo de parâmetros e retorno de funções em Python.
\n",
151 | "Isso se chama _function annotation_.\n",
152 | "\n",
153 | "Os tipos definidos **apenas** servem como indicativo ao programador dos tipos de dados esperados.
\n",
154 | "Algumas bibliotecas externas também podem interpretar tais \"metas anotações\" para algum propósito.\n",
155 | "\n",
156 | "Portanto, o interpretador python **NÃO** leva essas anotações de tipos em consideração durante sua execução."
157 | ]
158 | },
159 | {
160 | "cell_type": "code",
161 | "execution_count": null,
162 | "metadata": {},
163 | "outputs": [],
164 | "source": []
165 | },
166 | {
167 | "cell_type": "markdown",
168 | "metadata": {},
169 | "source": [
170 | "Parâmetros de outros tipos são aceitos e processados normalmente."
171 | ]
172 | },
173 | {
174 | "cell_type": "code",
175 | "execution_count": null,
176 | "metadata": {},
177 | "outputs": [],
178 | "source": []
179 | },
180 | {
181 | "cell_type": "markdown",
182 | "metadata": {},
183 | "source": [
184 | "### Comentários e Docstring\n",
185 | "Em Python, comentários são definidos de duas maneiras:\n",
186 | "\n",
187 | "1. Utilizando # (comentário de uma linha só)"
188 | ]
189 | },
190 | {
191 | "cell_type": "code",
192 | "execution_count": 10,
193 | "metadata": {},
194 | "outputs": [],
195 | "source": [
196 | "# este é um comentário de uma linha só"
197 | ]
198 | },
199 | {
200 | "cell_type": "markdown",
201 | "metadata": {},
202 | "source": [
203 | "2. Usando _Docstrings_ (múltiplas linhas)"
204 | ]
205 | },
206 | {
207 | "cell_type": "code",
208 | "execution_count": 11,
209 | "metadata": {},
210 | "outputs": [
211 | {
212 | "data": {
213 | "text/plain": [
214 | "'Este é um comentário\\nde múltiplas\\nlinhas'"
215 | ]
216 | },
217 | "execution_count": 11,
218 | "metadata": {},
219 | "output_type": "execute_result"
220 | }
221 | ],
222 | "source": [
223 | "'''Este é um comentário\n",
224 | "de múltiplas\n",
225 | "linhas'''\n"
226 | ]
227 | },
228 | {
229 | "cell_type": "code",
230 | "execution_count": 12,
231 | "metadata": {},
232 | "outputs": [
233 | {
234 | "data": {
235 | "text/plain": [
236 | "'Este é outro comentário\\nde múltiplas\\nlinhas'"
237 | ]
238 | },
239 | "execution_count": 12,
240 | "metadata": {},
241 | "output_type": "execute_result"
242 | }
243 | ],
244 | "source": [
245 | "\"\"\"Este é outro comentário\n",
246 | "de múltiplas\n",
247 | "linhas\"\"\""
248 | ]
249 | },
250 | {
251 | "cell_type": "markdown",
252 | "metadata": {},
253 | "source": [
254 | "
\n",
255 | "Docstrings podem ser usados para documentar funções:"
256 | ]
257 | },
258 | {
259 | "cell_type": "code",
260 | "execution_count": 23,
261 | "metadata": {},
262 | "outputs": [],
263 | "source": [
264 | "def soma(x, y):\n",
265 | " '''Esta função soma dois números inteiros.\n",
266 | "\n",
267 | " Parameters:\n",
268 | " x (int): Primeiro número inteiro.\n",
269 | " y (int): Segundo número inteiro.\n",
270 | "\n",
271 | " Returns:\n",
272 | " int: Soma resultante\n",
273 | " '''\n",
274 | " return x + y"
275 | ]
276 | },
277 | {
278 | "cell_type": "markdown",
279 | "metadata": {},
280 | "source": [
281 | "
\n",
282 | "Quando uma função (ou classe) está documentada usando _docstring_, é possível usar a função **help()** para ler a documentação:"
283 | ]
284 | },
285 | {
286 | "cell_type": "code",
287 | "execution_count": null,
288 | "metadata": {},
289 | "outputs": [],
290 | "source": []
291 | },
292 | {
293 | "cell_type": "code",
294 | "execution_count": null,
295 | "metadata": {},
296 | "outputs": [],
297 | "source": []
298 | }
299 | ],
300 | "metadata": {
301 | "kernelspec": {
302 | "display_name": "Python 3",
303 | "language": "python",
304 | "name": "python3"
305 | },
306 | "language_info": {
307 | "codemirror_mode": {
308 | "name": "ipython",
309 | "version": 3
310 | },
311 | "file_extension": ".py",
312 | "mimetype": "text/x-python",
313 | "name": "python",
314 | "nbconvert_exporter": "python",
315 | "pygments_lexer": "ipython3",
316 | "version": "3.9.0"
317 | }
318 | },
319 | "nbformat": 4,
320 | "nbformat_minor": 4
321 | }
322 |
--------------------------------------------------------------------------------
/codigos_base/03_condicionais.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "## **Python Essencial para Data Science**\n",
8 | "**Prof. Dr. Samuel Martins (@hisamuka @xavecoding)**
\n",
9 | "xavecoding: https://youtube.com/c/xavecoding
\n",
10 | "\n",
11 | "
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License."
12 | ]
13 | },
14 | {
15 | "cell_type": "markdown",
16 | "metadata": {},
17 | "source": [
18 | "## Condicionais\n",
19 | "\n",
20 | "### Estrutura básica de um IF:\n",
21 | "\n",
22 | "if condition 01:\n",
23 | " Instruction 01\n",
24 | " Instruction 02\n",
25 | "elif (condition 02):\n",
26 | " Instruction 03\n",
27 | " Instruction 04\n",
28 | "else:\n",
29 | " Instruction 05\n",
30 | " Instruction 06\n",
31 | "\n",
32 | " \n",
33 | "Note que as **identações** definem o _escopo_ de cada opção resultante do IF.\n",
34 | "\n",
35 | "As condições devem resultar um valor boolean (True ou False)."
36 | ]
37 | },
38 | {
39 | "cell_type": "markdown",
40 | "metadata": {},
41 | "source": [
42 | "### Operadores de Comparação\n",
43 | "\n",
44 | "| Operação | Descrição || Operação | Descrição |\n",
45 | "|---------------|-------------------------------------||---------------|-------------------------------------|\n",
46 | "| ``a == b`` | ``a`` igual a ``b`` || ``a != b`` | ``a`` diferente de ``b`` |\n",
47 | "| ``a < b`` | ``a`` menor do que ``b`` || ``a > b`` | ``a`` maior do que ``b`` |\n",
48 | "| ``a <= b`` | ``a`` menor do que ou igual a ``b`` || ``a >= b`` | ``a`` maior do que ou igual a ``b`` |"
49 | ]
50 | },
51 | {
52 | "cell_type": "code",
53 | "execution_count": null,
54 | "metadata": {},
55 | "outputs": [],
56 | "source": []
57 | },
58 | {
59 | "cell_type": "markdown",
60 | "metadata": {},
61 | "source": [
62 | "Opcionalmente, podemos usar _parênteses_ nas condições."
63 | ]
64 | },
65 | {
66 | "cell_type": "code",
67 | "execution_count": null,
68 | "metadata": {},
69 | "outputs": [],
70 | "source": []
71 | },
72 | {
73 | "cell_type": "markdown",
74 | "metadata": {},
75 | "source": [
76 | "### Comparando Booleans"
77 | ]
78 | },
79 | {
80 | "cell_type": "code",
81 | "execution_count": null,
82 | "metadata": {},
83 | "outputs": [],
84 | "source": []
85 | },
86 | {
87 | "cell_type": "markdown",
88 | "metadata": {},
89 | "source": [
90 | "### Combinando condições com `and` e`or`"
91 | ]
92 | },
93 | {
94 | "cell_type": "code",
95 | "execution_count": null,
96 | "metadata": {},
97 | "outputs": [],
98 | "source": []
99 | },
100 | {
101 | "cell_type": "markdown",
102 | "metadata": {},
103 | "source": [
104 | "### Armazenando booleans resultantes de condicionais"
105 | ]
106 | },
107 | {
108 | "cell_type": "code",
109 | "execution_count": null,
110 | "metadata": {},
111 | "outputs": [],
112 | "source": []
113 | },
114 | {
115 | "cell_type": "markdown",
116 | "metadata": {},
117 | "source": [
118 | "### Condicionais em uma única linha"
119 | ]
120 | },
121 | {
122 | "cell_type": "code",
123 | "execution_count": null,
124 | "metadata": {},
125 | "outputs": [],
126 | "source": []
127 | }
128 | ],
129 | "metadata": {
130 | "kernelspec": {
131 | "display_name": "Python 3",
132 | "language": "python",
133 | "name": "python3"
134 | },
135 | "language_info": {
136 | "codemirror_mode": {
137 | "name": "ipython",
138 | "version": 3
139 | },
140 | "file_extension": ".py",
141 | "mimetype": "text/x-python",
142 | "name": "python",
143 | "nbconvert_exporter": "python",
144 | "pygments_lexer": "ipython3",
145 | "version": "3.9.0"
146 | }
147 | },
148 | "nbformat": 4,
149 | "nbformat_minor": 4
150 | }
151 |
--------------------------------------------------------------------------------
/codigos_base/04_loops.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "## **Python Essencial para Data Science**\n",
8 | "**Prof. Dr. Samuel Martins (@hisamuka @xavecoding)**
\n",
9 | "xavecoding: https://youtube.com/c/xavecoding
\n",
10 | "\n",
11 | "
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License."
12 | ]
13 | },
14 | {
15 | "cell_type": "markdown",
16 | "metadata": {},
17 | "source": [
18 | "## Loops\n",
19 | "Antes de definirmos os *laços de repetição em Python (loops)*, vamos ver como definimos intervalos no Python:"
20 | ]
21 | },
22 | {
23 | "cell_type": "markdown",
24 | "metadata": {},
25 | "source": [
26 | "### Gerando intervalos com `range()`\n",
27 | "Um dos exemplos mais comuns de loops é iterar para um dado **intervalo de valores**.\n",
28 | "\n",
29 | "Suponha que desejamos codificar um loop que itere de 0 até n-1, onde o parâmetro *n* é definido pelo usuários.
\n",
30 | "Em linguagem C, teríamos algo como:\n",
31 | "\n",
32 | "for (int i = 0; i < n; i++) {\n",
33 | " ...\n",
34 | "}\n",
35 | "\n",
36 | " \n",
37 | "Em *Python*, podemos gerar intervalos de valores muito mais fácil, apenas utilizando o comando `range()`, que possui a assinatura:
\n",
38 | "`range(start, end, step)`."
39 | ]
40 | },
41 | {
42 | "cell_type": "markdown",
43 | "metadata": {},
44 | "source": [
45 | "#### Entendendo os índices de um Intervalo\n",
46 | "Um intervalo em python sempre **inclui** o número passado como **limite inferior** e *exclui* o número do *limite superior* do intervalo.\n",
47 | "\n",
48 | "P. ex., o intervalo definido pelos números `10 15` corresponde, na verdade, ao intervalo [10, 15), ou seja, [10, 11, 12, 13, 14]"
49 | ]
50 | },
51 | {
52 | "cell_type": "markdown",
53 | "metadata": {},
54 | "source": [
55 | "#### Gerando um intervalo de 0..n-1\n",
56 | "Se passarmos apenas **um valor/parâmetro** para a função `range()`, a mesma retorna um intervalor de 0 até o valor -1."
57 | ]
58 | },
59 | {
60 | "cell_type": "code",
61 | "execution_count": null,
62 | "metadata": {},
63 | "outputs": [],
64 | "source": []
65 | },
66 | {
67 | "cell_type": "markdown",
68 | "metadata": {},
69 | "source": [
70 | "Note que o retorno é um `range(0, 10)`. Internamente, este tipo é uma _lista_ contendo todos os números do intervalo.
\n",
71 | "Para termos acesso a tal lista explicitamente, precisamos converter o range em uma **`list`**:"
72 | ]
73 | },
74 | {
75 | "cell_type": "code",
76 | "execution_count": null,
77 | "metadata": {},
78 | "outputs": [],
79 | "source": []
80 | },
81 | {
82 | "cell_type": "markdown",
83 | "metadata": {},
84 | "source": [
85 | "#### Gerando um intervalo de Inicio até Fim-1\n",
86 | "Podemos querer alterar o valor **inicial** do intervalo, que é 0 por padrão. Para isso, devemos passar 2 parâmetros para o `range()`, sendo o primeiro deles o limite inferior (incluso) do intervalo (_lower bound_) e o segundo é o limite superior (excluso) do intevarlo (_upper bound_):"
87 | ]
88 | },
89 | {
90 | "cell_type": "code",
91 | "execution_count": null,
92 | "metadata": {},
93 | "outputs": [],
94 | "source": []
95 | },
96 | {
97 | "cell_type": "code",
98 | "execution_count": null,
99 | "metadata": {},
100 | "outputs": [],
101 | "source": []
102 | },
103 | {
104 | "cell_type": "markdown",
105 | "metadata": {},
106 | "source": [
107 | "#### Especificando o passo do intervalo\n",
108 | "Por padrão, os intervalos fornecem números sequenciais, ou seja, com **passo/incremento** igual a 1.
\n",
109 | "Podemos alterar tal **passo**. Para isso, basta passarmos um terceiro parâmetro no `range()`"
110 | ]
111 | },
112 | {
113 | "cell_type": "code",
114 | "execution_count": null,
115 | "metadata": {},
116 | "outputs": [],
117 | "source": []
118 | },
119 | {
120 | "cell_type": "code",
121 | "execution_count": null,
122 | "metadata": {},
123 | "outputs": [],
124 | "source": []
125 | },
126 | {
127 | "cell_type": "markdown",
128 | "metadata": {},
129 | "source": [
130 | "### `for`\n",
131 | "O esqueleto de um for-loop é:\n",
132 | "\n",
133 | "for i in collection:\n",
134 | " Instruction 01\n",
135 | " Instruction 02\n",
136 | " ...\n",
137 | "
\n",
138 | "\n",
139 | "onde _collection_ é uma coleção de valores que será iterado.
\n",
140 | "No esqueleto acima, a cada iteração, a variável `i` terá um valor da _collection_. \n",
141 | "\n",
142 | "A _collection_ pode ser, por exemplo, um `range()` ou uma `list`:"
143 | ]
144 | },
145 | {
146 | "cell_type": "code",
147 | "execution_count": null,
148 | "metadata": {},
149 | "outputs": [],
150 | "source": []
151 | },
152 | {
153 | "cell_type": "code",
154 | "execution_count": null,
155 | "metadata": {},
156 | "outputs": [],
157 | "source": []
158 | },
159 | {
160 | "cell_type": "code",
161 | "execution_count": null,
162 | "metadata": {},
163 | "outputs": [],
164 | "source": []
165 | },
166 | {
167 | "cell_type": "code",
168 | "execution_count": null,
169 | "metadata": {},
170 | "outputs": [],
171 | "source": []
172 | },
173 | {
174 | "cell_type": "markdown",
175 | "metadata": {},
176 | "source": [
177 | "### While\n",
178 | "\n",
179 | "while condition:\n",
180 | " Instruction 01\n",
181 | " Instruction 02\n",
182 | " ...\n",
183 | ""
184 | ]
185 | },
186 | {
187 | "cell_type": "code",
188 | "execution_count": null,
189 | "metadata": {},
190 | "outputs": [],
191 | "source": []
192 | },
193 | {
194 | "cell_type": "code",
195 | "execution_count": null,
196 | "metadata": {},
197 | "outputs": [],
198 | "source": []
199 | }
200 | ],
201 | "metadata": {
202 | "kernelspec": {
203 | "display_name": "Python 3",
204 | "language": "python",
205 | "name": "python3"
206 | },
207 | "language_info": {
208 | "codemirror_mode": {
209 | "name": "ipython",
210 | "version": 3
211 | },
212 | "file_extension": ".py",
213 | "mimetype": "text/x-python",
214 | "name": "python",
215 | "nbconvert_exporter": "python",
216 | "pygments_lexer": "ipython3",
217 | "version": "3.9.0"
218 | }
219 | },
220 | "nbformat": 4,
221 | "nbformat_minor": 4
222 | }
223 |
--------------------------------------------------------------------------------
/codigos_base/05_lists.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "## **Python Essencial para Data Science**\n",
8 | "**Prof. Dr. Samuel Martins (@hisamuka @xavecoding)**
\n",
9 | "xavecoding: https://youtube.com/c/xavecoding
\n",
10 | "\n",
11 | "
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License."
12 | ]
13 | },
14 | {
15 | "cell_type": "markdown",
16 | "metadata": {},
17 | "source": [
18 | "## Lists\n",
19 | "Listas em Python representam uma **sequência de elementos _ordenados_**."
20 | ]
21 | },
22 | {
23 | "cell_type": "code",
24 | "execution_count": null,
25 | "metadata": {},
26 | "outputs": [],
27 | "source": []
28 | },
29 | {
30 | "cell_type": "markdown",
31 | "metadata": {},
32 | "source": [
33 | "A **ordenação** dos elementos refere-se a seus _posicionamentos_ na lista, ou seja, o primeiro elemento da lista é o 20, o segundo é o 11, e assim por diante.
\n",
34 | "A **ordem** dos valores/conteúdos é outra coisa."
35 | ]
36 | },
37 | {
38 | "cell_type": "code",
39 | "execution_count": null,
40 | "metadata": {},
41 | "outputs": [],
42 | "source": []
43 | },
44 | {
45 | "cell_type": "markdown",
46 | "metadata": {},
47 | "source": [
48 | "#### Listas vazias"
49 | ]
50 | },
51 | {
52 | "cell_type": "code",
53 | "execution_count": null,
54 | "metadata": {},
55 | "outputs": [],
56 | "source": []
57 | },
58 | {
59 | "cell_type": "code",
60 | "execution_count": null,
61 | "metadata": {},
62 | "outputs": [],
63 | "source": []
64 | },
65 | {
66 | "cell_type": "markdown",
67 | "metadata": {},
68 | "source": [
69 | "#### Listas podem ter elementos de _qualquer tipo_"
70 | ]
71 | },
72 | {
73 | "cell_type": "code",
74 | "execution_count": null,
75 | "metadata": {},
76 | "outputs": [],
77 | "source": []
78 | },
79 | {
80 | "cell_type": "markdown",
81 | "metadata": {},
82 | "source": [
83 | "#### Listas podem ter _tipos diferentes_ numa lista:"
84 | ]
85 | },
86 | {
87 | "cell_type": "code",
88 | "execution_count": null,
89 | "metadata": {},
90 | "outputs": [],
91 | "source": []
92 | },
93 | {
94 | "cell_type": "markdown",
95 | "metadata": {},
96 | "source": [
97 | "#### Podemos ter listas de listas"
98 | ]
99 | },
100 | {
101 | "cell_type": "code",
102 | "execution_count": null,
103 | "metadata": {},
104 | "outputs": [],
105 | "source": []
106 | },
107 | {
108 | "cell_type": "code",
109 | "execution_count": null,
110 | "metadata": {},
111 | "outputs": [],
112 | "source": []
113 | },
114 | {
115 | "cell_type": "code",
116 | "execution_count": null,
117 | "metadata": {},
118 | "outputs": [],
119 | "source": []
120 | },
121 | {
122 | "cell_type": "code",
123 | "execution_count": null,
124 | "metadata": {},
125 | "outputs": [],
126 | "source": []
127 | },
128 | {
129 | "cell_type": "code",
130 | "execution_count": null,
131 | "metadata": {},
132 | "outputs": [],
133 | "source": []
134 | },
135 | {
136 | "cell_type": "markdown",
137 | "metadata": {},
138 | "source": [
139 | "### Indexação\n",
140 | "\n",
141 | "Cada elemento de uma lista é indexado a uma posição.
\n",
142 | "Podemos acessar um elemento passando seu índice com []:"
143 | ]
144 | },
145 | {
146 | "cell_type": "code",
147 | "execution_count": null,
148 | "metadata": {},
149 | "outputs": [],
150 | "source": []
151 | },
152 | {
153 | "cell_type": "code",
154 | "execution_count": null,
155 | "metadata": {},
156 | "outputs": [],
157 | "source": []
158 | },
159 | {
160 | "cell_type": "code",
161 | "execution_count": null,
162 | "metadata": {},
163 | "outputs": [],
164 | "source": []
165 | },
166 | {
167 | "cell_type": "markdown",
168 | "metadata": {},
169 | "source": [
170 | "Listas em Python suporta **índices negativos**, cuja ordem de indexação é o contrário, começando do final para o início:"
171 | ]
172 | },
173 | {
174 | "cell_type": "code",
175 | "execution_count": null,
176 | "metadata": {},
177 | "outputs": [],
178 | "source": []
179 | },
180 | {
181 | "cell_type": "code",
182 | "execution_count": null,
183 | "metadata": {},
184 | "outputs": [],
185 | "source": []
186 | },
187 | {
188 | "cell_type": "markdown",
189 | "metadata": {},
190 | "source": [
191 | "Podemos também acessar o _último elemento_ da lista desta maneira:"
192 | ]
193 | },
194 | {
195 | "cell_type": "code",
196 | "execution_count": null,
197 | "metadata": {},
198 | "outputs": [],
199 | "source": []
200 | },
201 | {
202 | "cell_type": "markdown",
203 | "metadata": {},
204 | "source": [
205 | "Inline-style: \n",
206 | ""
207 | ]
208 | },
209 | {
210 | "cell_type": "markdown",
211 | "metadata": {},
212 | "source": [
213 | "### Slicing (fatiamento)\n",
214 | "Podemos retornar **uma cópia** dos elementos de um **intervalo contínuo** de uma lista. "
215 | ]
216 | },
217 | {
218 | "cell_type": "code",
219 | "execution_count": null,
220 | "metadata": {},
221 | "outputs": [],
222 | "source": []
223 | },
224 | {
225 | "cell_type": "markdown",
226 | "metadata": {},
227 | "source": [
228 | "`planetas[0:3]` é nosso jeito de consultar os elementos da lista `planetas` do índice 0 até o índice 3 (sem incluí-lo)."
229 | ]
230 | },
231 | {
232 | "cell_type": "markdown",
233 | "metadata": {},
234 | "source": [
235 | "#### Entendendo os índices de um Intervalo\n",
236 | "Um intervalo em python sempre **inclui** o número passado como **limite inferior** e *exclui* o número do *limite superior* do intervalo.\n",
237 | "\n",
238 | "`[10:15]` são os números do intervalo [10, 15), ou seja, [10, 11, 12, 13, 14]"
239 | ]
240 | },
241 | {
242 | "cell_type": "markdown",
243 | "metadata": {},
244 | "source": [
245 | "#### De volta ao slicing"
246 | ]
247 | },
248 | {
249 | "cell_type": "markdown",
250 | "metadata": {},
251 | "source": [
252 | "Os índices iniciais e finais do intervalo do _slicing_ são **opcionais**.\n",
253 | "\n",
254 | "Se não informarmos o _índice inicial_, o valor 0 é assumido:"
255 | ]
256 | },
257 | {
258 | "cell_type": "code",
259 | "execution_count": null,
260 | "metadata": {},
261 | "outputs": [],
262 | "source": []
263 | },
264 | {
265 | "cell_type": "code",
266 | "execution_count": null,
267 | "metadata": {},
268 | "outputs": [],
269 | "source": []
270 | },
271 | {
272 | "cell_type": "markdown",
273 | "metadata": {},
274 | "source": [
275 | "Se ignorarmos o _índice final_, é assumido o _tamanho da lista_ `len(lista)`:"
276 | ]
277 | },
278 | {
279 | "cell_type": "code",
280 | "execution_count": null,
281 | "metadata": {},
282 | "outputs": [],
283 | "source": []
284 | },
285 | {
286 | "cell_type": "markdown",
287 | "metadata": {},
288 | "source": [
289 | "Podemos também fazer o slicing com **índices negativos**:"
290 | ]
291 | },
292 | {
293 | "cell_type": "code",
294 | "execution_count": null,
295 | "metadata": {},
296 | "outputs": [],
297 | "source": []
298 | },
299 | {
300 | "cell_type": "markdown",
301 | "metadata": {},
302 | "source": [
303 | "`planetas[1:-1]` considera o intervalo que vai do índice [1], o **incluindo**, até o índice [-1] ou [len(planetas) - 1], no exemplo é o índice [7], o **excluindo**.
\n",
304 | "Portanto, o intervalo retornado contém os índices [1, 2, 3, 4, 5, 6]."
305 | ]
306 | },
307 | {
308 | "cell_type": "markdown",
309 | "metadata": {},
310 | "source": [
311 | "
"
312 | ]
313 | },
314 | {
315 | "cell_type": "markdown",
316 | "metadata": {},
317 | "source": [
318 | "Outro exemplo:"
319 | ]
320 | },
321 | {
322 | "cell_type": "code",
323 | "execution_count": null,
324 | "metadata": {},
325 | "outputs": [],
326 | "source": []
327 | },
328 | {
329 | "cell_type": "code",
330 | "execution_count": null,
331 | "metadata": {},
332 | "outputs": [],
333 | "source": []
334 | },
335 | {
336 | "cell_type": "markdown",
337 | "metadata": {},
338 | "source": [
339 | "Vamos entender o intervalo `[-3:]`.\n",
340 | "\n",
341 | "O índice `[-3]` corresponde ao índice `[len(planetas) - 3]`, ou seja, o índice `[5]`.
\n",
342 | "Portanto, `[-3:]` é sinônonimo de `[5:]`.\n",
343 | "\n",
344 | "Ao omitir o último índice do intervalo, consideramos por padrão `len(planetas)`, que é 8.
\n",
345 | "Logo, `[-3:]` é o mesmo que `[5:8]`, que resulta nos índices `[5, 6, 7]`, que são os índices dos 3 últimos elementos dessa lista."
346 | ]
347 | },
348 | {
349 | "cell_type": "markdown",
350 | "metadata": {},
351 | "source": [
352 | "#### Os elementos retornados pelo Slicing de Listas a uma variável são CÓPIAS"
353 | ]
354 | },
355 | {
356 | "cell_type": "code",
357 | "execution_count": null,
358 | "metadata": {},
359 | "outputs": [],
360 | "source": []
361 | },
362 | {
363 | "cell_type": "code",
364 | "execution_count": null,
365 | "metadata": {},
366 | "outputs": [],
367 | "source": []
368 | },
369 | {
370 | "cell_type": "markdown",
371 | "metadata": {},
372 | "source": [
373 | "#### Alteração de Múltiplos elementos de uma Lista via Slicing"
374 | ]
375 | },
376 | {
377 | "cell_type": "code",
378 | "execution_count": null,
379 | "metadata": {},
380 | "outputs": [],
381 | "source": []
382 | },
383 | {
384 | "cell_type": "markdown",
385 | "metadata": {},
386 | "source": [
387 | "
\n",
388 | "\n",
389 | "Se o **número de elementos atribuídos for DIFERENTE do número de elementos do slicing**, os elementos excedentos ou faltantes da lista são ignorados ===> TOME CUIDADO"
390 | ]
391 | },
392 | {
393 | "cell_type": "code",
394 | "execution_count": null,
395 | "metadata": {},
396 | "outputs": [],
397 | "source": []
398 | },
399 | {
400 | "cell_type": "markdown",
401 | "metadata": {},
402 | "source": [
403 | "### For-each em Listas\n",
404 | "Como mostrado no notebook anterior, podemos iterar elementos em uma lista:"
405 | ]
406 | },
407 | {
408 | "cell_type": "code",
409 | "execution_count": null,
410 | "metadata": {},
411 | "outputs": [],
412 | "source": []
413 | },
414 | {
415 | "cell_type": "code",
416 | "execution_count": null,
417 | "metadata": {},
418 | "outputs": [],
419 | "source": []
420 | },
421 | {
422 | "cell_type": "code",
423 | "execution_count": null,
424 | "metadata": {},
425 | "outputs": [],
426 | "source": []
427 | },
428 | {
429 | "cell_type": "markdown",
430 | "metadata": {},
431 | "source": [
432 | "No `for`, podemos também recuperar o **índice** e o *elemento* de uma lista, basta usarmos o comando `enumerate`:\n",
433 | "\n",
434 | "\n",
435 | " for i, elemento in enumerate(lista):\n",
436 | " intrução 01\n",
437 | " ....\n",
438 | ""
439 | ]
440 | },
441 | {
442 | "cell_type": "code",
443 | "execution_count": null,
444 | "metadata": {},
445 | "outputs": [],
446 | "source": []
447 | },
448 | {
449 | "cell_type": "code",
450 | "execution_count": null,
451 | "metadata": {},
452 | "outputs": [],
453 | "source": []
454 | },
455 | {
456 | "cell_type": "markdown",
457 | "metadata": {},
458 | "source": [
459 | "### Funções de Listas"
460 | ]
461 | },
462 | {
463 | "cell_type": "code",
464 | "execution_count": null,
465 | "metadata": {},
466 | "outputs": [],
467 | "source": []
468 | },
469 | {
470 | "cell_type": "markdown",
471 | "metadata": {},
472 | "source": [
473 | "`len` retorna o tamanho de uma lista (número de elements)"
474 | ]
475 | },
476 | {
477 | "cell_type": "code",
478 | "execution_count": null,
479 | "metadata": {},
480 | "outputs": [],
481 | "source": []
482 | },
483 | {
484 | "cell_type": "markdown",
485 | "metadata": {},
486 | "source": [
487 | "`min` retorna o menor elemento de uma lista"
488 | ]
489 | },
490 | {
491 | "cell_type": "code",
492 | "execution_count": null,
493 | "metadata": {},
494 | "outputs": [],
495 | "source": []
496 | },
497 | {
498 | "cell_type": "markdown",
499 | "metadata": {},
500 | "source": [
501 | "`max` retorna o maior elemento de uma lista"
502 | ]
503 | },
504 | {
505 | "cell_type": "code",
506 | "execution_count": null,
507 | "metadata": {},
508 | "outputs": [],
509 | "source": []
510 | },
511 | {
512 | "cell_type": "markdown",
513 | "metadata": {},
514 | "source": [
515 | "`sum` retorna a soma de elementos de uma lista"
516 | ]
517 | },
518 | {
519 | "cell_type": "code",
520 | "execution_count": null,
521 | "metadata": {},
522 | "outputs": [],
523 | "source": []
524 | },
525 | {
526 | "cell_type": "markdown",
527 | "metadata": {},
528 | "source": [
529 | "### Métodos de Listas"
530 | ]
531 | },
532 | {
533 | "cell_type": "markdown",
534 | "metadata": {},
535 | "source": [
536 | "`list.append` modifica uma lista adicionando um item (de qualquer tipo) no final."
537 | ]
538 | },
539 | {
540 | "cell_type": "code",
541 | "execution_count": null,
542 | "metadata": {},
543 | "outputs": [],
544 | "source": []
545 | },
546 | {
547 | "cell_type": "code",
548 | "execution_count": null,
549 | "metadata": {},
550 | "outputs": [],
551 | "source": []
552 | },
553 | {
554 | "cell_type": "markdown",
555 | "metadata": {},
556 | "source": [
557 | "`list.pop` remove e retorna o último elemento da lista:"
558 | ]
559 | },
560 | {
561 | "cell_type": "code",
562 | "execution_count": null,
563 | "metadata": {},
564 | "outputs": [],
565 | "source": []
566 | },
567 | {
568 | "cell_type": "code",
569 | "execution_count": null,
570 | "metadata": {},
571 | "outputs": [],
572 | "source": []
573 | },
574 | {
575 | "cell_type": "markdown",
576 | "metadata": {},
577 | "source": [
578 | "`reverse` reverte a ordem dos elementos da lista."
579 | ]
580 | },
581 | {
582 | "cell_type": "code",
583 | "execution_count": null,
584 | "metadata": {},
585 | "outputs": [],
586 | "source": []
587 | },
588 | {
589 | "cell_type": "code",
590 | "execution_count": null,
591 | "metadata": {},
592 | "outputs": [],
593 | "source": []
594 | },
595 | {
596 | "cell_type": "markdown",
597 | "metadata": {},
598 | "source": [
599 | "O possível problema é que a **própria lista** é revertida.
\n",
600 | "Caso você deseje ter uma **cópia revertida** da lista:"
601 | ]
602 | },
603 | {
604 | "cell_type": "code",
605 | "execution_count": null,
606 | "metadata": {},
607 | "outputs": [],
608 | "source": []
609 | },
610 | {
611 | "cell_type": "markdown",
612 | "metadata": {},
613 | "source": [
614 | "#### Ordenação de listas"
615 | ]
616 | },
617 | {
618 | "cell_type": "markdown",
619 | "metadata": {},
620 | "source": [
621 | "`sorted` retorna uma versão **ordernada (em ordem crescente)** de uma lista (NÃO ALTERA A LISTA ATUAL)"
622 | ]
623 | },
624 | {
625 | "cell_type": "code",
626 | "execution_count": null,
627 | "metadata": {},
628 | "outputs": [],
629 | "source": []
630 | },
631 | {
632 | "cell_type": "code",
633 | "execution_count": null,
634 | "metadata": {},
635 | "outputs": [],
636 | "source": []
637 | },
638 | {
639 | "cell_type": "markdown",
640 | "metadata": {},
641 | "source": [
642 | "##### Para ordernar em **ordem descrente**"
643 | ]
644 | },
645 | {
646 | "cell_type": "code",
647 | "execution_count": null,
648 | "metadata": {},
649 | "outputs": [],
650 | "source": []
651 | },
652 | {
653 | "cell_type": "code",
654 | "execution_count": null,
655 | "metadata": {},
656 | "outputs": [],
657 | "source": []
658 | },
659 | {
660 | "cell_type": "markdown",
661 | "metadata": {},
662 | "source": [
663 | "#### Buscando elementos em uma lista"
664 | ]
665 | },
666 | {
667 | "cell_type": "markdown",
668 | "metadata": {},
669 | "source": [
670 | "`list.index` retorna o índice de um dado elemento da lista, ou lança uma exception caso ele não esteja presente na lista."
671 | ]
672 | },
673 | {
674 | "cell_type": "code",
675 | "execution_count": null,
676 | "metadata": {},
677 | "outputs": [],
678 | "source": []
679 | },
680 | {
681 | "cell_type": "code",
682 | "execution_count": null,
683 | "metadata": {},
684 | "outputs": [],
685 | "source": []
686 | },
687 | {
688 | "cell_type": "code",
689 | "execution_count": null,
690 | "metadata": {},
691 | "outputs": [],
692 | "source": []
693 | },
694 | {
695 | "cell_type": "markdown",
696 | "metadata": {},
697 | "source": [
698 | "Outra alternativa melhor para saber se **uma lista contém ou não um dado elemento**, sem o lançamento de exception, é usar o `in`:"
699 | ]
700 | },
701 | {
702 | "cell_type": "code",
703 | "execution_count": null,
704 | "metadata": {},
705 | "outputs": [],
706 | "source": []
707 | },
708 | {
709 | "cell_type": "code",
710 | "execution_count": null,
711 | "metadata": {},
712 | "outputs": [],
713 | "source": []
714 | },
715 | {
716 | "cell_type": "markdown",
717 | "metadata": {},
718 | "source": [
719 | "Podemos ainda usar o `not in` para checar se a lista **não possui um dado elemento**:"
720 | ]
721 | },
722 | {
723 | "cell_type": "code",
724 | "execution_count": null,
725 | "metadata": {},
726 | "outputs": [],
727 | "source": []
728 | },
729 | {
730 | "cell_type": "markdown",
731 | "metadata": {},
732 | "source": [
733 | "#### Concatenando listas\n",
734 | "Suponha que desejamos juntar/concatenar duas listas em uma só.
\n",
735 | "Podemos tentar usar o método `append`, pois ele adiciona um dado elemento ao final da lista.\n",
736 | "Vejamos:"
737 | ]
738 | },
739 | {
740 | "cell_type": "code",
741 | "execution_count": null,
742 | "metadata": {},
743 | "outputs": [],
744 | "source": []
745 | },
746 | {
747 | "cell_type": "code",
748 | "execution_count": null,
749 | "metadata": {},
750 | "outputs": [],
751 | "source": []
752 | },
753 | {
754 | "cell_type": "code",
755 | "execution_count": null,
756 | "metadata": {},
757 | "outputs": [],
758 | "source": []
759 | },
760 | {
761 | "cell_type": "code",
762 | "execution_count": null,
763 | "metadata": {},
764 | "outputs": [],
765 | "source": []
766 | },
767 | {
768 | "cell_type": "markdown",
769 | "metadata": {},
770 | "source": [
771 | "Note que a a lista `cidades_estado_sp` tem agora alguns elementos que são _strings_, e o último elemento é uma _lista_.
\n",
772 | "O que queremos, na verdade, é ter uma lista **apenas com _strings_**.\n",
773 | "\n",
774 | "Para isso, podemo usar o método `lista.extend(lista_2)` que vai copiar todos os elementos dentro da lista `lista_2` e colocá-los no final da lista `lista`."
775 | ]
776 | },
777 | {
778 | "cell_type": "code",
779 | "execution_count": null,
780 | "metadata": {},
781 | "outputs": [],
782 | "source": []
783 | },
784 | {
785 | "cell_type": "code",
786 | "execution_count": null,
787 | "metadata": {},
788 | "outputs": [],
789 | "source": []
790 | },
791 | {
792 | "cell_type": "markdown",
793 | "metadata": {},
794 | "source": [
795 | "### List Comprehensions\n",
796 | "É uma forma curta de se criar listas."
797 | ]
798 | },
799 | {
800 | "cell_type": "markdown",
801 | "metadata": {},
802 | "source": [
803 | "**Ex 1)** Suponha que queremos criar uma lista cujo valor do índice [i] é i^2 (o índice ao quadrado).
\n",
804 | "Uma forma padrão seria:"
805 | ]
806 | },
807 | {
808 | "cell_type": "code",
809 | "execution_count": null,
810 | "metadata": {},
811 | "outputs": [],
812 | "source": []
813 | },
814 | {
815 | "cell_type": "markdown",
816 | "metadata": {},
817 | "source": [
818 | "Usando o **list comprehensions**:"
819 | ]
820 | },
821 | {
822 | "cell_type": "code",
823 | "execution_count": null,
824 | "metadata": {},
825 | "outputs": [],
826 | "source": []
827 | },
828 | {
829 | "cell_type": "markdown",
830 | "metadata": {},
831 | "source": [
832 | "**Ex 2)** Filtrando os elementos negativos de uma lista:"
833 | ]
834 | },
835 | {
836 | "cell_type": "code",
837 | "execution_count": null,
838 | "metadata": {},
839 | "outputs": [],
840 | "source": []
841 | },
842 | {
843 | "cell_type": "markdown",
844 | "metadata": {},
845 | "source": [
846 | "Outra maneira de aplicar funções a listas é usar **lambda functions**."
847 | ]
848 | },
849 | {
850 | "cell_type": "markdown",
851 | "metadata": {},
852 | "source": [
853 | "**Ex 3)** Lambda functions:"
854 | ]
855 | },
856 | {
857 | "cell_type": "code",
858 | "execution_count": null,
859 | "metadata": {},
860 | "outputs": [],
861 | "source": []
862 | }
863 | ],
864 | "metadata": {
865 | "kernelspec": {
866 | "display_name": "Python 3",
867 | "language": "python",
868 | "name": "python3"
869 | },
870 | "language_info": {
871 | "codemirror_mode": {
872 | "name": "ipython",
873 | "version": 3
874 | },
875 | "file_extension": ".py",
876 | "mimetype": "text/x-python",
877 | "name": "python",
878 | "nbconvert_exporter": "python",
879 | "pygments_lexer": "ipython3",
880 | "version": "3.9.0"
881 | }
882 | },
883 | "nbformat": 4,
884 | "nbformat_minor": 4
885 | }
886 |
--------------------------------------------------------------------------------
/codigos_base/06_strings.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "## **Python Essencial para Data Science**\n",
8 | "**Prof. Dr. Samuel Martins (@hisamuka @xavecoding)**
\n",
9 | "xavecoding: https://youtube.com/c/xavecoding
\n",
10 | "\n",
11 | "
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License."
12 | ]
13 | },
14 | {
15 | "cell_type": "markdown",
16 | "metadata": {},
17 | "source": [
18 | "## Strings"
19 | ]
20 | },
21 | {
22 | "cell_type": "markdown",
23 | "metadata": {},
24 | "source": [
25 | "#### Strings são também sequências"
26 | ]
27 | },
28 | {
29 | "cell_type": "code",
30 | "execution_count": null,
31 | "metadata": {},
32 | "outputs": [],
33 | "source": []
34 | },
35 | {
36 | "cell_type": "markdown",
37 | "metadata": {},
38 | "source": [
39 | "#### Strings são imutáveis"
40 | ]
41 | },
42 | {
43 | "cell_type": "code",
44 | "execution_count": null,
45 | "metadata": {},
46 | "outputs": [],
47 | "source": []
48 | },
49 | {
50 | "cell_type": "markdown",
51 | "metadata": {},
52 | "source": [
53 | "### Métodos de Strings"
54 | ]
55 | },
56 | {
57 | "cell_type": "markdown",
58 | "metadata": {},
59 | "source": [
60 | "`.upper()` retorna a string com todas as letras maiúscula"
61 | ]
62 | },
63 | {
64 | "cell_type": "code",
65 | "execution_count": null,
66 | "metadata": {},
67 | "outputs": [],
68 | "source": []
69 | },
70 | {
71 | "cell_type": "markdown",
72 | "metadata": {},
73 | "source": [
74 | "`.lower()` retorna a string com todas as letras minúsculas"
75 | ]
76 | },
77 | {
78 | "cell_type": "code",
79 | "execution_count": null,
80 | "metadata": {},
81 | "outputs": [],
82 | "source": []
83 | },
84 | {
85 | "cell_type": "markdown",
86 | "metadata": {},
87 | "source": [
88 | "`str.startswith(substring)` checa se a string `str` começa com a substring `substring`. "
89 | ]
90 | },
91 | {
92 | "cell_type": "code",
93 | "execution_count": null,
94 | "metadata": {},
95 | "outputs": [],
96 | "source": []
97 | },
98 | {
99 | "cell_type": "code",
100 | "execution_count": null,
101 | "metadata": {},
102 | "outputs": [],
103 | "source": []
104 | },
105 | {
106 | "cell_type": "markdown",
107 | "metadata": {},
108 | "source": [
109 | "`str.endswith(substring)` checa se a string `str` termina com a substring `substring`. "
110 | ]
111 | },
112 | {
113 | "cell_type": "code",
114 | "execution_count": null,
115 | "metadata": {},
116 | "outputs": [],
117 | "source": []
118 | },
119 | {
120 | "cell_type": "markdown",
121 | "metadata": {},
122 | "source": [
123 | "`string.split(substring)` divide uma string, a partir de uma substring passada, retorna uma lista com as divisões."
124 | ]
125 | },
126 | {
127 | "cell_type": "code",
128 | "execution_count": null,
129 | "metadata": {},
130 | "outputs": [],
131 | "source": []
132 | },
133 | {
134 | "cell_type": "code",
135 | "execution_count": null,
136 | "metadata": {},
137 | "outputs": [],
138 | "source": []
139 | },
140 | {
141 | "cell_type": "markdown",
142 | "metadata": {},
143 | "source": [
144 | "`join` junta uma lista de strings, a partir de uma substring. "
145 | ]
146 | },
147 | {
148 | "cell_type": "code",
149 | "execution_count": null,
150 | "metadata": {},
151 | "outputs": [],
152 | "source": []
153 | },
154 | {
155 | "cell_type": "markdown",
156 | "metadata": {},
157 | "source": [
158 | "#### Concatenando strings"
159 | ]
160 | },
161 | {
162 | "cell_type": "code",
163 | "execution_count": null,
164 | "metadata": {},
165 | "outputs": [],
166 | "source": []
167 | },
168 | {
169 | "cell_type": "code",
170 | "execution_count": null,
171 | "metadata": {},
172 | "outputs": [],
173 | "source": []
174 | }
175 | ],
176 | "metadata": {
177 | "kernelspec": {
178 | "display_name": "Python 3",
179 | "language": "python",
180 | "name": "python3"
181 | },
182 | "language_info": {
183 | "codemirror_mode": {
184 | "name": "ipython",
185 | "version": 3
186 | },
187 | "file_extension": ".py",
188 | "mimetype": "text/x-python",
189 | "name": "python",
190 | "nbconvert_exporter": "python",
191 | "pygments_lexer": "ipython3",
192 | "version": "3.9.0"
193 | }
194 | },
195 | "nbformat": 4,
196 | "nbformat_minor": 4
197 | }
198 |
--------------------------------------------------------------------------------
/codigos_base/07_tuplas.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "## **Python Essencial para Data Science**\n",
8 | "**Prof. Dr. Samuel Martins (@hisamuka @xavecoding)**
\n",
9 | "xavecoding: https://youtube.com/c/xavecoding
\n",
10 | "\n",
11 | "
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License."
12 | ]
13 | },
14 | {
15 | "cell_type": "markdown",
16 | "metadata": {},
17 | "source": [
18 | "## Tuplas\n",
19 | "Tuplas são estruturas muito semelhantes às listas. Eles diferem de duas maneiras:"
20 | ]
21 | },
22 | {
23 | "cell_type": "markdown",
24 | "metadata": {},
25 | "source": [
26 | "1. Elas usam _parênteses_ ao invés de _colchetes_:"
27 | ]
28 | },
29 | {
30 | "cell_type": "code",
31 | "execution_count": null,
32 | "metadata": {},
33 | "outputs": [],
34 | "source": []
35 | },
36 | {
37 | "cell_type": "markdown",
38 | "metadata": {},
39 | "source": [
40 | "2. Elas **não** podem ser modificadas (**imutáveis**)"
41 | ]
42 | },
43 | {
44 | "cell_type": "code",
45 | "execution_count": null,
46 | "metadata": {},
47 | "outputs": [],
48 | "source": []
49 | },
50 | {
51 | "cell_type": "markdown",
52 | "metadata": {},
53 | "source": [
54 | "#### Convertendo uma lista em tuplas e vice-versa"
55 | ]
56 | },
57 | {
58 | "cell_type": "code",
59 | "execution_count": null,
60 | "metadata": {},
61 | "outputs": [],
62 | "source": []
63 | },
64 | {
65 | "cell_type": "markdown",
66 | "metadata": {},
67 | "source": [
68 | "### Descompactando tuplas"
69 | ]
70 | },
71 | {
72 | "cell_type": "code",
73 | "execution_count": null,
74 | "metadata": {},
75 | "outputs": [],
76 | "source": []
77 | },
78 | {
79 | "cell_type": "markdown",
80 | "metadata": {},
81 | "source": [
82 | "### Zip: Compactando listas"
83 | ]
84 | },
85 | {
86 | "cell_type": "code",
87 | "execution_count": null,
88 | "metadata": {},
89 | "outputs": [],
90 | "source": []
91 | },
92 | {
93 | "cell_type": "code",
94 | "execution_count": null,
95 | "metadata": {},
96 | "outputs": [],
97 | "source": []
98 | },
99 | {
100 | "cell_type": "code",
101 | "execution_count": null,
102 | "metadata": {},
103 | "outputs": [],
104 | "source": []
105 | }
106 | ],
107 | "metadata": {
108 | "kernelspec": {
109 | "display_name": "Python 3",
110 | "language": "python",
111 | "name": "python3"
112 | },
113 | "language_info": {
114 | "codemirror_mode": {
115 | "name": "ipython",
116 | "version": 3
117 | },
118 | "file_extension": ".py",
119 | "mimetype": "text/x-python",
120 | "name": "python",
121 | "nbconvert_exporter": "python",
122 | "pygments_lexer": "ipython3",
123 | "version": "3.9.0"
124 | }
125 | },
126 | "nbformat": 4,
127 | "nbformat_minor": 4
128 | }
129 |
--------------------------------------------------------------------------------
/codigos_base/08_dicionarios.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "## **Python Essencial para Data Science**\n",
8 | "**Prof. Dr. Samuel Martins (@hisamuka @xavecoding)**
\n",
9 | "xavecoding: https://youtube.com/c/xavecoding
\n",
10 | "\n",
11 | "
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License."
12 | ]
13 | },
14 | {
15 | "cell_type": "markdown",
16 | "metadata": {},
17 | "source": [
18 | "## Dicionários (tabelas hash)\n",
19 | "Dicionários são tabelas hash: estruturas que mapeiams _chaves_ à _valores_.
\n",
20 | "Muito utilizado quando queremos **acesso rápido** (_O(1)_) a elementos/valores associados a uma dada chave."
21 | ]
22 | },
23 | {
24 | "cell_type": "code",
25 | "execution_count": null,
26 | "metadata": {},
27 | "outputs": [],
28 | "source": []
29 | },
30 | {
31 | "cell_type": "markdown",
32 | "metadata": {},
33 | "source": [
34 | "Neste caso, 'nome', 'idade' e 'peso' sãos as chaves com os respectivos valores 'Luke Skywalker', 16, 60.0."
35 | ]
36 | },
37 | {
38 | "cell_type": "markdown",
39 | "metadata": {},
40 | "source": [
41 | "Um dado _valor_ é acessado passando a _chave_ via **colchetes**:"
42 | ]
43 | },
44 | {
45 | "cell_type": "code",
46 | "execution_count": null,
47 | "metadata": {},
48 | "outputs": [],
49 | "source": []
50 | },
51 | {
52 | "cell_type": "markdown",
53 | "metadata": {},
54 | "source": [
55 | "Podemos alterar um valor acessando da mesma maneira:"
56 | ]
57 | },
58 | {
59 | "cell_type": "code",
60 | "execution_count": null,
61 | "metadata": {},
62 | "outputs": [],
63 | "source": []
64 | },
65 | {
66 | "cell_type": "markdown",
67 | "metadata": {},
68 | "source": [
69 | "Podemos **adicionar** um nome elemento, apenas informando o novo _par de chaves e valor_:"
70 | ]
71 | },
72 | {
73 | "cell_type": "code",
74 | "execution_count": null,
75 | "metadata": {},
76 | "outputs": [],
77 | "source": []
78 | },
79 | {
80 | "cell_type": "markdown",
81 | "metadata": {},
82 | "source": [
83 | "Note que usamos **diversos tipos** de _valores_ no mesmo dicionário. Podemos também usar **mais um tipo de chaves**, apesar que, geralmente, isso não é muito usado."
84 | ]
85 | },
86 | {
87 | "cell_type": "code",
88 | "execution_count": null,
89 | "metadata": {},
90 | "outputs": [],
91 | "source": []
92 | },
93 | {
94 | "cell_type": "markdown",
95 | "metadata": {},
96 | "source": [
97 | "Para copiar um dicionário:"
98 | ]
99 | },
100 | {
101 | "cell_type": "code",
102 | "execution_count": null,
103 | "metadata": {},
104 | "outputs": [],
105 | "source": []
106 | },
107 | {
108 | "cell_type": "markdown",
109 | "metadata": {},
110 | "source": [
111 | "#### Checando se um dicionário possui uma dada chave"
112 | ]
113 | },
114 | {
115 | "cell_type": "code",
116 | "execution_count": null,
117 | "metadata": {},
118 | "outputs": [],
119 | "source": []
120 | },
121 | {
122 | "cell_type": "markdown",
123 | "metadata": {},
124 | "source": [
125 | "#### For-each em Dicionários"
126 | ]
127 | },
128 | {
129 | "cell_type": "code",
130 | "execution_count": null,
131 | "metadata": {},
132 | "outputs": [],
133 | "source": []
134 | },
135 | {
136 | "cell_type": "code",
137 | "execution_count": null,
138 | "metadata": {},
139 | "outputs": [],
140 | "source": []
141 | },
142 | {
143 | "cell_type": "code",
144 | "execution_count": null,
145 | "metadata": {},
146 | "outputs": [],
147 | "source": []
148 | },
149 | {
150 | "cell_type": "code",
151 | "execution_count": null,
152 | "metadata": {},
153 | "outputs": [],
154 | "source": []
155 | },
156 | {
157 | "cell_type": "code",
158 | "execution_count": null,
159 | "metadata": {},
160 | "outputs": [],
161 | "source": []
162 | },
163 | {
164 | "cell_type": "code",
165 | "execution_count": null,
166 | "metadata": {},
167 | "outputs": [],
168 | "source": []
169 | },
170 | {
171 | "cell_type": "code",
172 | "execution_count": null,
173 | "metadata": {},
174 | "outputs": [],
175 | "source": []
176 | },
177 | {
178 | "cell_type": "markdown",
179 | "metadata": {},
180 | "source": [
181 | "#### Dictionary Comprehensions"
182 | ]
183 | },
184 | {
185 | "cell_type": "code",
186 | "execution_count": null,
187 | "metadata": {},
188 | "outputs": [],
189 | "source": []
190 | },
191 | {
192 | "cell_type": "code",
193 | "execution_count": null,
194 | "metadata": {},
195 | "outputs": [],
196 | "source": []
197 | }
198 | ],
199 | "metadata": {
200 | "kernelspec": {
201 | "display_name": "Python 3",
202 | "language": "python",
203 | "name": "python3"
204 | },
205 | "language_info": {
206 | "codemirror_mode": {
207 | "name": "ipython",
208 | "version": 3
209 | },
210 | "file_extension": ".py",
211 | "mimetype": "text/x-python",
212 | "name": "python",
213 | "nbconvert_exporter": "python",
214 | "pygments_lexer": "ipython3",
215 | "version": "3.9.0"
216 | }
217 | },
218 | "nbformat": 4,
219 | "nbformat_minor": 4
220 | }
221 |
--------------------------------------------------------------------------------
/codigos_base/09_bibliotecas_externas.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "## **Python Essencial para Data Science**\n",
8 | "**Prof. Dr. Samuel Martins (@hisamuka @xavecoding)**
\n",
9 | "xavecoding: https://youtube.com/c/xavecoding
\n",
10 | "\n",
11 | "
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License."
12 | ]
13 | },
14 | {
15 | "cell_type": "markdown",
16 | "metadata": {},
17 | "source": [
18 | "## Módulos externas"
19 | ]
20 | },
21 | {
22 | "cell_type": "markdown",
23 | "metadata": {},
24 | "source": [
25 | "#### Importando um módulo (biblioteca)"
26 | ]
27 | },
28 | {
29 | "cell_type": "code",
30 | "execution_count": null,
31 | "metadata": {},
32 | "outputs": [],
33 | "source": []
34 | },
35 | {
36 | "cell_type": "markdown",
37 | "metadata": {},
38 | "source": [
39 | "#### Atribuindo um nome diferente (alias) a um modulo importado"
40 | ]
41 | },
42 | {
43 | "cell_type": "code",
44 | "execution_count": null,
45 | "metadata": {},
46 | "outputs": [],
47 | "source": []
48 | },
49 | {
50 | "cell_type": "markdown",
51 | "metadata": {},
52 | "source": [
53 | "#### Importando apenas algumas \"coisas\" (funções, atributos, constantes, ...) de um módulo\n",
54 | "Deixa todas as \"coisas\" acessíveis sem a necessidade de chamar `modulo.coisa`"
55 | ]
56 | },
57 | {
58 | "cell_type": "code",
59 | "execution_count": null,
60 | "metadata": {},
61 | "outputs": [],
62 | "source": []
63 | },
64 | {
65 | "cell_type": "markdown",
66 | "metadata": {},
67 | "source": [
68 | "#### Importando todas as \"coisas\" (funções, atributos, constantes, ...) de um módulo"
69 | ]
70 | },
71 | {
72 | "cell_type": "code",
73 | "execution_count": null,
74 | "metadata": {},
75 | "outputs": [],
76 | "source": []
77 | },
78 | {
79 | "cell_type": "markdown",
80 | "metadata": {},
81 | "source": [
82 | "Apesar de possívels, tal prática **não é indicada**, uma vez que (1) \"coisas\", p. ex., de módulos diferentes mas de mesmo nome podem ser importadas, e (2) pode não haver necessidade de ter acesso a todas as \"coisas\" do módulo."
83 | ]
84 | },
85 | {
86 | "cell_type": "markdown",
87 | "metadata": {},
88 | "source": [
89 | "### Submódulos\n",
90 | "Alguns módulos podem possuir **submódulo**:"
91 | ]
92 | },
93 | {
94 | "cell_type": "code",
95 | "execution_count": null,
96 | "metadata": {},
97 | "outputs": [],
98 | "source": []
99 | },
100 | {
101 | "cell_type": "code",
102 | "execution_count": null,
103 | "metadata": {},
104 | "outputs": [],
105 | "source": []
106 | },
107 | {
108 | "cell_type": "markdown",
109 | "metadata": {},
110 | "source": [
111 | "### Módulos Uteis"
112 | ]
113 | },
114 | {
115 | "cell_type": "markdown",
116 | "metadata": {},
117 | "source": [
118 | "- `os`: funções do sistema operacional\n",
119 | "- `glob`: funções para criar listas a partir de diretórios do sistema\n",
120 | "- `shutil`: funções para gerenciar arquivos e diretórios\n",
121 | "- `math`: funções matemáticas\n",
122 | "- `random`: geradores de números aleatórios\n",
123 | "- `pickle`: protocolos para (de-)serialização de dados de entrada e saída"
124 | ]
125 | },
126 | {
127 | "cell_type": "markdown",
128 | "metadata": {},
129 | "source": [
130 | "### Outros Tópicos"
131 | ]
132 | },
133 | {
134 | "cell_type": "markdown",
135 | "metadata": {},
136 | "source": [
137 | "- Manipulação de arquivos\n",
138 | "- Orientação a objetos\n",
139 | " - Classes\n",
140 | " - Objetos\n",
141 | " - Métodos, métodos estáticos\n",
142 | " - Herança\n",
143 | "- Básico da biblioteca `numpy`\n",
144 | "- Básico da biblioteca `matplotlib`"
145 | ]
146 | },
147 | {
148 | "cell_type": "code",
149 | "execution_count": null,
150 | "metadata": {},
151 | "outputs": [],
152 | "source": []
153 | }
154 | ],
155 | "metadata": {
156 | "kernelspec": {
157 | "display_name": "Python 3",
158 | "language": "python",
159 | "name": "python3"
160 | },
161 | "language_info": {
162 | "codemirror_mode": {
163 | "name": "ipython",
164 | "version": 3
165 | },
166 | "file_extension": ".py",
167 | "mimetype": "text/x-python",
168 | "name": "python",
169 | "nbconvert_exporter": "python",
170 | "pygments_lexer": "ipython3",
171 | "version": "3.9.0"
172 | }
173 | },
174 | "nbformat": 4,
175 | "nbformat_minor": 4
176 | }
177 |
--------------------------------------------------------------------------------
/hello_world.py:
--------------------------------------------------------------------------------
1 | print('Hello world!')
2 |
--------------------------------------------------------------------------------
/imagens/exemplo_lista_indices.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/xavecoding/python-essencial-para-data-science/4286cdf28a99154b0c9289eed72ad3c5024834d2/imagens/exemplo_lista_indices.png
--------------------------------------------------------------------------------