├── txt
    ├── estrutura_de_dados
    │   ├── fila.txt
    │   ├── exemplos
    │   │   ├── Queue.py
    │   │   ├── Stack.py
    │   │   ├── Deque.py
    │   │   └── SQD.py
    │   └── pilha.txt
    ├── exemplos
    │   ├── test_pytest.py
    │   └── threading_stop.py
    ├── extras
    │   └── pygal_svg.py
    └── test
    │   ├── assert.txt
    │   ├── teste.py
    │   └── teste_unitario.txt
├── README.md
├── Makefile
├── source
    ├── index.rst
    ├── content
    │   ├── threads.rst
    │   ├── set_frozenset.rst
    │   ├── packages.rst
    │   ├── pytest.rst
    │   ├── closures.rst
    │   ├── data_types.rst
    │   ├── boolean.rst
    │   ├── exec_eval_execfile_compile.rst
    │   ├── tuple.rst
    │   ├── modules.rst
    │   ├── staticmethod_classmethod.rst
    │   ├── recursive.rst
    │   ├── decimal_module.rst
    │   ├── with.rst
    │   ├── if.rst
    │   ├── about.rst
    │   ├── loops.rst
    │   ├── date_time.rst
    │   ├── numeric_data_types.rst
    │   ├── decorators.rst
    │   ├── iter_gen.rst
    │   ├── sequences.rst
    │   ├── property.rst
    │   ├── scope.rst
    │   ├── dict.rst
    │   ├── list.rst
    │   ├── open.rst
    │   ├── language_particularities.rst
    │   ├── except.rst
    │   └── functions.rst
    └── conf.py
└── LICENSE


/txt/estrutura_de_dados/fila.txt:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Apostila de Python
2 | 
3 | Curso de programação em Python.<br />
4 | Teoria e prática.
5 | 


--------------------------------------------------------------------------------
/txt/estrutura_de_dados/exemplos/Queue.py:
--------------------------------------------------------------------------------
 1 | from SQD import SQD
 2 | 
 3 | 
 4 | class Queue(SQD):
 5 | 
 6 |     @SQD.pop
 7 |     def pop(self):
 8 |         return self.elements.pop(0)
 9 | 
10 |     @SQD.push
11 |     def push(self, x):
12 |         self.elements.append(x)
13 | 
14 | q = Queue()
15 | 
16 | q.push(1)
17 | q.push(2)
18 | q.push(3)
19 | 


--------------------------------------------------------------------------------
/txt/estrutura_de_dados/exemplos/Stack.py:
--------------------------------------------------------------------------------
 1 | from SQD import SQD
 2 | 
 3 | 
 4 | class Stack(SQD):
 5 | 
 6 |     @SQD.pop
 7 |     def pop(self):
 8 |         return self.elements.pop(-1)
 9 | 
10 |     @SQD.push
11 |     def push_last(self, x):
12 |         self.elements.append(x)
13 | 
14 | s = Stack()
15 | 
16 | s.push(1)
17 | s.push(2)
18 | s.push(3)
19 | 


--------------------------------------------------------------------------------
/txt/exemplos/test_pytest.py:
--------------------------------------------------------------------------------
 1 | '''
 2 | Use py.test test_pytest.py
 3 | '''
 4 | 
 5 | def fatorial(x):
 6 |     if x == 0:
 7 |         return 1
 8 |     return x * fatorial(x - 1)
 9 | 
10 | def e_par(x):
11 |     if x % 2 == 0:
12 |         return True
13 |     return False
14 | 
15 | def test_fatorial():
16 |     assert fatorial(0) == 1
17 | 
18 | def test_par():
19 |     assert e_par(8)
20 | 


--------------------------------------------------------------------------------
/txt/exemplos/threading_stop.py:
--------------------------------------------------------------------------------
 1 | import threading
 2 | import os
 3 | import time
 4 | 
 5 | class FileChecker(threading.Thread):
 6 |   def __init__(self, file_path):
 7 |     super(FileChecker, self).__init__()
 8 |     self._kill = False
 9 |     self._file_path = file_path
10 | 
11 |   def run(self):
12 |       while (not os.path.isfile(self._file_path)):
13 |           print("File {} not found!".format(self._file_path))
14 |           time.sleep(5)
15 |           if self._kill:
16 |             break
17 | 
18 |   def stop(self):
19 |     self._kill = True
20 |     self.join()
21 | 
22 | t = FileChecker('/tmp/teste.txt')
23 | t.start()
24 | 
25 | time.sleep(10)
26 | 
27 | t.stop()
28 | 
29 | print('fim')
30 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | # Minimal makefile for Sphinx documentation
 2 | #
 3 | 
 4 | # You can set these variables from the command line, and also
 5 | # from the environment for the first two.
 6 | SPHINXOPTS    ?=
 7 | SPHINXBUILD   ?= sphinx-build
 8 | SOURCEDIR     = source
 9 | BUILDDIR      = build
10 | 
11 | # Put it first so that "make" without argument is like "make help".
12 | help:
13 | 	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
14 | 
15 | .PHONY: help Makefile
16 | 
17 | # Catch-all target: route all unknown targets to Sphinx using the new
18 | # "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
19 | %: Makefile
20 | 	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
21 | 


--------------------------------------------------------------------------------
/txt/estrutura_de_dados/exemplos/Deque.py:
--------------------------------------------------------------------------------
 1 | # _*_ encoding: utf-8 _*_
 2 | 
 3 | from SQD import SQD
 4 | 
 5 | 
 6 | class Deque(SQD):
 7 | 
 8 |     @SQD.pop
 9 |     def pop_first(self):
10 |         return self.elements.pop(0)
11 | 
12 |     @SQD.pop
13 |     def pop_last(self):
14 |         return self.elements.pop(-1)
15 | 
16 |     @SQD.push
17 |     def push_first(self, x):
18 |         self.elements.insert(0, x)
19 | 
20 |     @SQD.push
21 |     def push_last(self, x):
22 |         self.elements.append(x)
23 | 
24 |     # Métodos herdados a serem anulados
25 | 
26 |     def pop(self):
27 |         print('Use pop_first ou pop_last')
28 | 
29 |     def push(self):
30 |         print('Use push_first ou push_last')
31 | 
32 | d = Deque()
33 | 
34 | for i in range(1, 10):
35 |     d.push_last(i)
36 | 


--------------------------------------------------------------------------------
/txt/extras/pygal_svg.py:
--------------------------------------------------------------------------------
 1 | #_*_ encoding: utf-8 _*_
 2 | import pygal
 3 | 
 4 | # http://blog.codeeval.com/codeevalblog/2014
 5 | # most popular coding languages according to @codeeval
 6 | # python for the win! w00t!
 7 | 
 8 | data = (
 9 |   ("Python", 77.7),
10 |   ("Java", 22.2),
11 |   ("C++", 13),
12 |   ("Ruby", 10.6),
13 |   ("Javascript", 5.2),
14 |   ("TCL", 0.03)
15 | )
16 |     
17 | 
18 | # Make a Pygal chart
19 | pie_chart = pygal.Pie()
20 | 
21 | # add a title
22 | pie_chart.title = "CodeEval Most Popular Coding Languages of 2014"
23 | 
24 | # add the data
25 | for label, data_points in data:
26 |     pie_chart.add(label, data_points)
27 | 
28 | # Render the chart    
29 | xml_string = pie_chart.render()
30 | 
31 | 
32 | f = raw_input('Digite o nome do arquivo que deseja criar:\n')
33 | 
34 | f = open(f, 'w+')
35 | 
36 | print >> f, xml_string
37 | 
38 | f.close()
39 | 


--------------------------------------------------------------------------------
/txt/test/assert.txt:
--------------------------------------------------------------------------------
 1 | assert
 2 | 
 3 | 	O comando assert auxilia a encontrar bugs.
 4 | 	Afirmações (assertions) é uma forma sistemática para verificar se o estado interno de uma aplicação  é como esperado pelo desenvolvedor, e então achar bugs.
 5 | 	Simplificando, uma afirmação é algo como "raise-if-not comando". Ou seja, se o comando retornar falso levante (raise) uma exceção.
 6 | 
 7 | 
 8 | 
 9 | Teste para valor verdadeiro:
10 | 
11 | >>> assert True, 'Se for falso'
12 | 
13 | 
14 | 
15 | Teste para valor falso:
16 | 
17 | >>> assert False, 'Se for falso'
18 | 
19 | Traceback (most recent call last):
20 |   File "<input>", line 1, in <module>
21 |     assert False, 'Se for falso'
22 | AssertionError: Se for falso
23 | 
24 | 
25 | 
26 | Testando se x é inteiro:
27 | 
28 | >>> x = 10
29 | >>> assert type(x)  is int, 'x não é um inteiro'
30 | >>> x = '10'
31 | >>> assert type(x)  is int, 'x não é um inteiro'
32 | 
33 | Traceback (most recent call last):
34 |   File "<input>", line 1, in <module>
35 |     assert type(x)  is int, 'x não é um inteiro'
36 | AssertionError: x não é um inteiro
37 | 


--------------------------------------------------------------------------------
/txt/test/teste.py:
--------------------------------------------------------------------------------
 1 | #_*_ encoding: utf-8 _*_
 2 | 
 3 | import time
 4 | 
 5 | ''' Fibonacci function '''
 6 | def fibo(n):
 7 |     if (n < 2): return n
 8 |     else:
 9 |         return fibo(n - 1) + fibo(n - 2)
10 | 
11 | 
12 | ''' Memoize function '''
13 | def memoize(f):
14 |     # dictionary
15 |     mem = {}
16 | 
17 |     ''' Helper function '''
18 |     def memoizer(*param):
19 |         key = repr(param)
20 |         if not key in mem:
21 |             mem[key] = f(*param)
22 |         return mem[key]
23 | 
24 |     return memoizer
25 | 
26 | # Start time
27 | t1 = time.time()
28 | 
29 | # Loop 
30 | for i in range(35):
31 |     print('fib(%s) = %s' % (i, fibo(i)))
32 | 
33 | # End time
34 | t2 = time.time()
35 | 
36 | # Total time
37 | print('Tempo de execução: %.3fs' % (t2 - t1))
38 | 
39 | # Take a pause
40 | raw_input('Pressione <ENTER> para continuar\n')
41 | 
42 | # Memoization of fibo (closure)
43 | fibo = memoize(fibo)
44 | 
45 | # Start time
46 | t1 = time.time()
47 | 
48 | # loop after memoization
49 | for i in range(40):
50 |     print('fib(%s) = %s' % (i, fibo(i)))
51 | 
52 | # End time
53 | t2 = time.time()
54 | 
55 | # Total time
56 | print('Tempo de execução: %.3fs' % (t2 - t1))
57 | 


--------------------------------------------------------------------------------
/source/index.rst:
--------------------------------------------------------------------------------
 1 | .. Curso de Python documentation master file, created by
 2 |    sphinx-quickstart on Wed Aug 28 14:04:06 2019.
 3 |    You can adapt this file completely to your liking, but it should at least
 4 |    contain the root `toctree` directive.
 5 | 
 6 | Curso de Python
 7 | ===========================================
 8 | 
 9 | .. toctree::
10 |    :maxdepth: 4
11 |    :numbered:
12 |    :caption: Contents:
13 | 
14 |    content/about
15 |    content/language_particularities
16 |    content/built-ins
17 |    content/data_types
18 |    content/str
19 |    content/numeric_data_types
20 |    content/boolean
21 |    content/decimal_module
22 |    content/date_time
23 |    content/sequences
24 |    content/list
25 |    content/tuple
26 |    content/set_frozenset
27 |    content/dict
28 |    content/operators
29 |    content/iter_gen
30 |    content/functions
31 |    content/oo
32 |    content/staticmethod_classmethod
33 |    content/property
34 |    content/scope
35 |    content/if
36 |    content/loops
37 |    content/open
38 |    content/with
39 |    content/modules
40 |    content/packages
41 |    content/except
42 |    content/closures
43 |    content/decorators
44 |    content/exec_eval_execfile_compile
45 |    content/recursive
46 |    content/threads
47 |    content/pytest
48 | 
49 | 
50 | 
51 | 
52 | 
53 | Indices and tables
54 | ==================
55 | 
56 | * :ref:`genindex`
57 | * :ref:`modindex`
58 | * :ref:`search`
59 | 


--------------------------------------------------------------------------------
/txt/estrutura_de_dados/exemplos/SQD.py:
--------------------------------------------------------------------------------
 1 | # _*_ encoding: utf-8 _*_
 2 | 
 3 | 
 4 | class SQD(object):
 5 | 
 6 |     __elements = []
 7 |     __length = 0
 8 | 
 9 |     @property
10 |     def first(self):
11 |         if not self.is_empty():
12 |             return self.elements[0]
13 |         return None
14 | 
15 |     @property
16 |     def last(self):
17 |         if not self.is_empty():
18 |             return self.elements[-1]
19 |         return None
20 | 
21 |     @property
22 |     def elements(self):
23 |         return self.__elements
24 | 
25 |     @property
26 |     def length(self):
27 |         return self.__length
28 | 
29 |     @length.setter
30 |     def length(self, x):
31 |         if (x < 0):
32 |             raise ValueError('Somente valores positivos ou zero')
33 |         self.__length = x
34 | 
35 |     def push(f):
36 |         def sub_push(self, x):
37 |             self.length += 1
38 |             f(self, x)
39 |         return sub_push
40 | 
41 |     def is_empty(self):
42 |         if (self.length == 0):
43 |             print('Aviso: Sem elementos na estrutura!')
44 |             return True
45 |         return False
46 | 
47 |     def pop(f):
48 |         def sub_pop(self):
49 |             if not self.is_empty():
50 |                 self.length -= 1
51 |                 return f(self)
52 |             return None
53 |         return sub_pop
54 | 
55 |     def erase(self):
56 |         self.elements.clear()
57 |         self.length = 0
58 | 


--------------------------------------------------------------------------------
/source/content/threads.rst:
--------------------------------------------------------------------------------
 1 | Threads
 2 | *******
 3 | 
 4 | 
 5 | 
 6 | .. code-block:: python
 7 | 
 8 |   import threading
 9 |   import time
10 | 
11 |   def funcao1():
12 |       linha = ('_' * 79)
13 |       while (True):
14 |           print(linha)
15 |           time.sleep(10)
16 | 
17 |   def funcao2(tempo):
18 |       while (True):
19 |           print('funcao2')
20 |           time.sleep(tempo)
21 | 
22 |   t1 = threading.Thread(target=funcao1, name='primeira_thread')
23 | 
24 |   t2 = threading.Thread(target=funcao2, name='segunda_thread', args=(3,))
25 | 
26 |   t1.start()
27 | 
28 |   t2.start()
29 | 
30 | .. code-block:: console
31 | 
32 |     funcao2
33 |     funcao2
34 |     funcao2
35 | 
36 | 
37 | .. code-block:: python
38 | 
39 |   t1.getName()
40 | 
41 | .. code-block:: console
42 | 
43 |     'primeira_thread'
44 | 
45 | 
46 | E se quisermos parar uma thread?
47 | 
48 | .. code-block:: python
49 | 
50 |   import threading
51 |   import os
52 |   import time
53 | 
54 |   class FileChecker(threading.Thread):
55 |     def __init__(self, file_path):
56 |       super(FileChecker, self).__init__()
57 |       self._kill = False
58 |       self._file_path = file_path
59 | 
60 |     def run(self):
61 |         while (not os.path.isfile(self._file_path)):
62 |             print("File {} not found!".format(self._file_path))
63 |             time.sleep(5)
64 |             if self._kill:
65 |               break
66 | 
67 |     def stop(self):
68 |       self._kill = True
69 |       self.join()
70 | 
71 |   t = FileChecker('/tmp/teste.txt')
72 |   t.start()
73 | 
74 |   time.sleep(10)
75 | 
76 |   t.stop()
77 | 
78 |   print('fim')


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | BSD 3-Clause License
 2 | 
 3 | Copyright (c) 2017, Juliano Atanazio
 4 | All rights reserved.
 5 | 
 6 | Redistribution and use in source and binary forms, with or without
 7 | modification, are permitted provided that the following conditions are met:
 8 | 
 9 | * Redistributions of source code must retain the above copyright notice, this
10 |   list of conditions and the following disclaimer.
11 | 
12 | * Redistributions in binary form must reproduce the above copyright notice,
13 |   this list of conditions and the following disclaimer in the documentation
14 |   and/or other materials provided with the distribution.
15 | 
16 | * Neither the name of the copyright holder nor the names of its
17 |   contributors may be used to endorse or promote products derived from
18 |   this software without specific prior written permission.
19 | 
20 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
23 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
24 | FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
26 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
27 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
28 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 | 


--------------------------------------------------------------------------------
/txt/estrutura_de_dados/pilha.txt:
--------------------------------------------------------------------------------
 1 | stack (Stack)
 2 | 
 3 | 	Sempre insere ao final.
 4 | 	Last In First First Out (LIFO) ou First In Last Out (FILO).
 5 | 
 6 | class Pilha(object):
 7 |     def __init__(self):
 8 |         self.stack = []
 9 |         self.len_stack = 0
10 | 
11 |     def push(self, x):
12 |         self.stack.append(x)
13 |         self.len_stack += 1
14 | 
15 |     def is_empty(self):
16 |         if (self.len_stack == 0):
17 |             print('Aviso: stack vazia!')
18 |             return True
19 |         return False
20 | 
21 |     def pop(self):
22 |         if not self.is_empty():
23 |             self.len_stack -= 1
24 |             return self.stack.pop()            
25 |         return None
26 | 
27 |     def top(self):
28 |         if not self.is_empty():
29 |             return self.stack[-1]
30 |         return None
31 | 
32 |     def bottom(self):
33 |         if not self.is_empty():
34 |             return self.stack[0]
35 |         return None
36 | 
37 |     def erase(self):
38 |         self.stack = []
39 |         self.len_stack = 0
40 | 
41 |     def elements(self):
42 |         return self.stack
43 | 
44 |     def length(self):
45 |         return self.len_stack
46 | 
47 | 
48 | p = Pilha()
49 | 
50 | for i in range(0, 9):
51 |     p.push(i)
52 | 
53 | p.length()
54 | 9
55 | 
56 | p.elements()
57 | [0, 1, 2, 3, 4, 5, 6, 7, 8]
58 | 
59 | p.top()
60 | 8
61 | 
62 | p.bottom()
63 | 0
64 | 
65 | p.pop()
66 | 8
67 | 
68 | p.is_empty()
69 | False
70 | 
71 | p.elements()
72 | [0, 1, 2, 3, 4, 5, 6, 7]
73 | 
74 | p.erase()
75 | 
76 | p.is_empty()
77 | Aviso: stack vazia!
78 | True
79 | 
80 | p.pop()
81 | Aviso: stack vazia!
82 | 
83 | p.push(777)
84 | 
85 | p.elements()
86 | [777]
87 | 


--------------------------------------------------------------------------------
/source/content/set_frozenset.rst:
--------------------------------------------------------------------------------
  1 | set e frozenset
  2 | ***************
  3 | 
  4 | |    Similarmente a list e tuple, a diferença entre eles é que frozenset é um tipo imutável.
  5 | |    Seus elementos são únicos.
  6 | |    Implementam operações matemáticas de conjuntos.
  7 | 
  8 | 
  9 | 
 10 | .. code-block:: python
 11 | 
 12 |     # Set vazio:
 13 |     s = {*()}
 14 | 
 15 | ou
 16 | 
 17 | 
 18 | .. code-block:: python
 19 | 
 20 |     s = set()
 21 | 
 22 | 
 23 | .. code-block:: python
 24 | 
 25 |     # Criação de um conjunto (set) não vazio:
 26 |     s = set([1, 1, 2, 3])
 27 | 
 28 | ou
 29 | 
 30 | .. code-block:: python
 31 | 
 32 |     s = set((1, 1, 2, 3))
 33 | 
 34 | ou
 35 | 
 36 | .. code-block:: python
 37 | 
 38 |     s = set([1, 1, 2, 3])
 39 | 
 40 | ou
 41 | 
 42 | .. code-block:: python
 43 | 
 44 |     s = set({1, 1, 2, 3})
 45 | 
 46 | ou
 47 | 
 48 | .. code-block:: python
 49 | 
 50 |     s = {1, 2, 3}
 51 | 
 52 | .. code-block:: python
 53 | 
 54 |     # Exibindo o conteúdo do set:
 55 |     s
 56 | 
 57 | .. code-block:: console
 58 | 
 59 |     {1, 2, 3}
 60 | 
 61 | .. code-block:: python
 62 | 
 63 |     # Definição de dois conjuntos:
 64 |     a = set([1,2,3])
 65 |     b = set([2,3,4])
 66 | 
 67 | 
 68 | .. code-block:: python
 69 | 
 70 |     # Operação de união entre os conjuntos:
 71 |     a | b
 72 | 
 73 | ou
 74 | 
 75 | .. code-block:: python
 76 | 
 77 |     a.union(b)
 78 | 
 79 | .. code-block:: console
 80 | 
 81 |     {1, 2, 3, 4}
 82 | 
 83 | 
 84 | .. code-block:: python
 85 | 
 86 |     # Operação de intersecção entre os conjuntos:
 87 |     a & b
 88 | 
 89 | ou
 90 | 
 91 | .. code-block:: python
 92 | 
 93 |     a.intersection(b)
 94 | 
 95 | .. code-block:: console
 96 | 
 97 |     {2, 3}
 98 | 
 99 | 
100 | .. code-block:: python
101 | 
102 |     # Frozenset vazio:
103 |     f = frozenset()
104 | 
105 | .. code-block:: python
106 | 
107 |     # Frozenset não vazio:
108 |     f = frozenset((1, 2, 3))
109 | 
110 | ou
111 | 
112 | .. code-block:: python
113 | 
114 |     f = frozenset({1, 2, 3})
115 | 
116 | ou
117 | 
118 | .. code-block:: python
119 | 
120 |     f = frozenset([1, 2, 3])
121 | 
122 | ou
123 | 
124 | .. code-block:: python
125 | 
126 |     f = frozenset({1, 2, 3})
127 | 
128 | .. code-block:: python
129 | 
130 |     # Exibindo o conteúdo do frozenset:
131 |     f
132 | 
133 | .. code-block:: console
134 | 
135 |     frozenset({1, 2, 3})
136 | 


--------------------------------------------------------------------------------
/source/content/packages.rst:
--------------------------------------------------------------------------------
  1 | Pacotes
  2 | *******
  3 | 
  4 | 
  5 | Criação de diretório (pacote):
  6 | 
  7 | .. code-block:: bash
  8 | 
  9 |     mkdir pack_0
 10 | 
 11 | 
 12 | 
 13 | Criação de um módulo dentro do pacote:
 14 | 
 15 | .. code-block:: bash
 16 | 
 17 |     vim pack_0/foo.py
 18 | 
 19 | .. code-block:: python
 20 | 
 21 |     # _*_ encoding: utf-8 _*_
 22 | 
 23 |     print(__name__)
 24 | 
 25 |     
 26 |     class Pessoa(object):
 27 |         nome = ''
 28 |         idade = 0
 29 | 
 30 |         def saudacao(self):
 31 |             print('Olá, meu nome é {}'.format(self.nome))
 32 | 
 33 |     class Funcionario(Pessoa):
 34 |         matricula = ''
 35 | 
 36 |     def cubo(x):
 37 |         return x ** 3
 38 | 
 39 | 
 40 | 
 41 | import pacote.modulo:
 42 | 
 43 | .. code-block:: python
 44 | 
 45 |     import pack_0.foo
 46 |     f1 = pack_0.foo.Funcionario()
 47 |     f1.nome = 'Zezinho'
 48 |     f1.saudacao()
 49 |     Olá, meu nome é Zezinho
 50 | 
 51 | $ ls pack_0/
 52 | foo.py  __init__.py  __pycache__
 53 | 
 54 | $ ls pack_0/__pycache__/
 55 | foo.cpython-34.pyc  __init__.cpython-34.pyc
 56 | 
 57 | $ file pack_0/__pycache__/foo.cpython-34.pyc 
 58 | pack_0/__pycache__/foo.cpython-34.pyc: python 3.4 byte-compiled
 59 | 
 60 | $ vim pack_0/__init__.py
 61 | 
 62 | # _*_ encoding: utf-8 _*_
 63 | 
 64 | if __name__ != '__main__':
 65 |     print('Pacote {} importado'.format(__name__))
 66 | 
 67 | > import pack_0.foo
 68 | Pacote pack_0 importado
 69 | pack_0.foo
 70 | 
 71 | > import pack_0
 72 | Pacote pack_0 importado
 73 | 
 74 | $ mkdir -p pack_0/pack_1/pack_2
 75 | 
 76 | $ mv pack_0/foo.py pack_0/pack_1/pack_2/
 77 | 
 78 | > import pack_0.pack_1.pack_2.foo
 79 | Pacote pack_0 importado
 80 | pack_0.pack_1.pack_2.foo
 81 | 
 82 | > f1 = pack_0.pack_1.pack_2.foo.Funcionario()
 83 | 
 84 | Apesar de terem sido declarados, os diretórios pack_1 e pack_2 não são pacotes.
 85 | 
 86 | 
 87 | Transformando os subdiretórios em pacotes:
 88 | 
 89 | $ > pack_0/pack_1/__init__.py
 90 | $ > pack_0/pack_1/pack_2/__init__.py
 91 | 
 92 | > from pack_0.pack_1.pack_2 import foo
 93 | Pacote pack_0 importado
 94 | pack_0.pack_1.pack_2.foo
 95 | > f1 = foo.Funcionario()
 96 | 
 97 | > from pack_0.pack_1.pack_2.foo import Funcionario
 98 | Pacote pack_0 importado
 99 | pack_0.pack_1.pack_2.foo
100 | > f1 = Funcionario()
101 | 
102 | $ echo 'print(__name__)' > pack_0/pack_1/__init__.py 
103 | $ echo 'print(__name__)' > pack_0/pack_1/pack_2/__init__.py
104 | 
105 | 
106 | > from pack_0.pack_1.pack_2.foo import Funcionario
107 | Pacote pack_0 importado
108 | pack_0.pack_1
109 | pack_0.pack_1.pack_2
110 | pack_0.pack_1.pack_2.foo
111 | 
112 | 
113 | > from pack_0.pack_1.pack_2.foo import *
114 | Pacote pack_0 importado
115 | pack_0.pack_1
116 | pack_0.pack_1.pack_2
117 | pack_0.pack_1.pack_2.foo
118 | > f1 = Funcionario()
119 | 
120 | $ python3 pack_0/__pycache__/foo.cpython-34.pyc 
121 | 
122 | __main__


--------------------------------------------------------------------------------
/source/content/pytest.rst:
--------------------------------------------------------------------------------
  1 | pytest
  2 | ******
  3 | 
  4 | 
  5 | 
  6 | sdsdsdsdsd:
  7 | 
  8 | .. code-block:: bash
  9 | 
 10 |     vim /tmp/test_pytest.py
 11 | 
 12 | 
 13 | .. code-block:: python
 14 | 
 15 |     # Função fatorial
 16 |     def fatorial(x):
 17 |         if x == 0:
 18 |             return 1
 19 |         return x * fatorial(x - 1)
 20 | 
 21 |     # Função que testa se um número é par
 22 |     def e_par(x):
 23 |         if x % 2 == 0:
 24 |             return True
 25 |         return False
 26 | 
 27 |     # Função para testar a função fatorial
 28 |     def test_fatorial():
 29 |         assert fatorial(0) == 1
 30 | 
 31 |     # Função para testar a função e_par
 32 |     def test_par():
 33 |         assert e_par(8)
 34 | 
 35 | 
 36 | 
 37 | sasasasasa:
 38 | 
 39 | .. code-block:: bash
 40 | 
 41 |     py.test /tmp/test_pytest.py
 42 | 
 43 | .. code-block:: console
 44 | 
 45 |     ================================================= test session starts =================================================
 46 |     platform linux -- Python 3.4.3+, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
 47 |     rootdir: /tmp, inifile: 
 48 |     collected 2 items 
 49 | 
 50 |     ../../tmp/test_pytest.py .F
 51 | 
 52 |     ====================================================== FAILURES =======================================================
 53 |     ______________________________________________________ test_par _______________________________________________________
 54 | 
 55 |         def test_par():
 56 |     >       assert e_par(8)
 57 |     E       assert e_par(8)
 58 | 
 59 |     /tmp/test_pytest.py:19: AssertionError
 60 |     ========================================= 1 failed, 1 passed in 0.01 seconds ==========================================
 61 | 
 62 | 
 63 | 
 64 | 
 65 | sdsdsdsd:
 66 | 
 67 | .. code-block:: bash
 68 | 
 69 |     vim /tmp/test_pytest.py
 70 |     
 71 | 
 72 | .. code-block:: python
 73 | 
 74 |     # Função fatorial
 75 |     def fatorial(x):
 76 |         if x == 0:
 77 |             return 1
 78 |         return x * fatorial(x - 1)
 79 | 
 80 |     # Função que testa se um número é par
 81 |     def e_par(x):
 82 |         if x % 2 == 0:
 83 |             return True
 84 |         return False
 85 | 
 86 |     # Função para testar a função fatorial
 87 |     def test_fatorial():
 88 |         assert fatorial(0) == 1
 89 | 
 90 |     # Função para testar a função e_par
 91 |     def test_par():
 92 |         assert e_par(8)
 93 | 
 94 | 
 95 | 
 96 | .. code-block:: bash
 97 | 
 98 |     py.test /tmp/test_pytest.py
 99 | 
100 | .. code-block:: console
101 | 
102 |     ================================================= test session starts =================================================
103 |     platform linux -- Python 3.4.3+, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
104 |     rootdir: /tmp, inifile: 
105 |     collected 2 items 
106 | 
107 |     ../../tmp/test_pytest.py ..
108 | 
109 |     ============================================== 2 passed in 0.00 seconds ===============================================


--------------------------------------------------------------------------------
/source/content/closures.rst:
--------------------------------------------------------------------------------
  1 | Closures
  2 | ********
  3 | 
  4 | Funções são objetos também.
  5 | Closures são funções que constroem funções, retorna outra função.
  6 | Sua estrutura é uma função dentro de outra.
  7 | A função interna é também conhecida como função auxiliadora (helper).
  8 | 
  9 | 
 10 | 
 11 | Criação de uma closure:
 12 | 
 13 | .. code-block:: python
 14 | 
 15 |     def funcao_principal(x):
 16 |         def funcao_auxiliadora(y):
 17 |             return x ** y
 18 |         return funcao_auxiliadora
 19 | 
 20 | 
 21 | 
 22 | Criação de uma variável foo e passando o valor x para a função principal:
 23 | 
 24 | .. code-block:: python
 25 | 
 26 |     foo = funcao_principal(2)
 27 | 
 28 | "foo" é uma nova função cujo o "x" de "função_principal" é 2.
 29 | 
 30 | 
 31 | 
 32 | Qual é o nome da função?:
 33 | 
 34 | .. code-block:: python
 35 | 
 36 |     print(foo.__name__)
 37 | 
 38 | .. code-block:: console
 39 | 
 40 |     funcao_auxiliadora
 41 | 
 42 | 
 43 | 
 44 | Tipo de "foo":
 45 | 
 46 | .. code-block:: python
 47 | 
 48 |     type(foo)
 49 | 
 50 | .. code-block:: console
 51 | 
 52 |     function
 53 | 
 54 | 
 55 | 
 56 | Representação de "foo":
 57 | 
 58 | .. code-block:: python
 59 | 
 60 |     repr(foo)
 61 | 
 62 | .. code-block:: console
 63 | 
 64 |     '<function funcao_principal.<locals>.funcao_auxiliadora at 0x7f9845369950>'
 65 | 
 66 | 
 67 | 
 68 | Imprimindo o valor resultante ao passar agora o valor y:
 69 | 
 70 | .. code-block:: python
 71 | 
 72 |     print(foo(6))
 73 | 
 74 | .. code-block:: console
 75 | 
 76 |     64
 77 | 
 78 | A operação realizada foi 2 elevado a 6 (x ** y).
 79 | 
 80 | 
 81 | 
 82 | Podemos também chamar a função principal passando o parâmetro da função auxiliar:
 83 | 
 84 | .. code-block:: python
 85 | 
 86 |     funcao_principal(5)(2)
 87 | 
 88 | .. code-block:: console
 89 | 
 90 |     25
 91 | 
 92 | 
 93 | 
 94 | Closures com Lambda
 95 | -------------------
 96 | 
 97 | Criação de uma closure com lambda:
 98 | 
 99 | .. code-block:: python
100 | 
101 |     def funcao_principal(x):
102 |         return lambda y: x ** y
103 | 
104 | 
105 | 
106 | O "x" será 3:
107 | 
108 | .. code-block:: python
109 | 
110 |     bar = funcao_principal(3)
111 | 
112 | 
113 | 
114 | Exibindo o nome do objeto:
115 | 
116 | .. code-block:: python
117 | 
118 |     print(bar.__name__)
119 | 
120 | .. code-block:: console
121 | 
122 |     <lambda>
123 | 
124 | 
125 | 
126 | Tipo:
127 | 
128 | .. code-block:: python
129 | 
130 |     type(bar)
131 | 
132 | .. code-block:: console
133 | 
134 |     function
135 | 
136 | 
137 | 
138 | Representação:
139 | 
140 | .. code-block:: python
141 | 
142 |     repr(bar)
143 | 
144 | .. code-block:: console
145 | 
146 |     '<function funcao_principal.<locals>.<lambda> at 0x7f9844527730>'
147 | 
148 | 
149 | 
150 | 3 elevado a 2:
151 | 
152 | .. code-block:: python
153 | 
154 |     print(bar(2))
155 | 
156 | .. code-block:: console
157 | 
158 |     9
159 | 
160 | 
161 | 
162 | Passando o parâmetro da função principal e de lambda:
163 | 
164 | .. code-block:: python
165 | 
166 |     funcao_principal(2)(5)
167 | 
168 | .. code-block:: console
169 | 
170 |     32


--------------------------------------------------------------------------------
/source/conf.py:
--------------------------------------------------------------------------------
 1 | # Configuration file for the Sphinx documentation builder.
 2 | #
 3 | # This file only contains a selection of the most common options. For a full
 4 | # list see the documentation:
 5 | # https://www.sphinx-doc.org/en/master/usage/configuration.html
 6 | 
 7 | # -- Path setup --------------------------------------------------------------
 8 | 
 9 | # If extensions (or modules to document with autodoc) are in another directory,
10 | # add these directories to sys.path here. If the directory is relative to the
11 | # documentation root, use os.path.abspath to make it absolute, like shown here.
12 | #
13 | # import os
14 | # import sys
15 | # sys.path.insert(0, os.path.abspath('.'))
16 | 
17 | 
18 | # -- Project information -----------------------------------------------------
19 | 
20 | project = 'Curso de Python'
21 | copyright = '2019, Juliano Atanazio'
22 | author = 'Juliano Atanazio'
23 | 
24 | # The full version, including alpha/beta/rc tags
25 | release = '2019-08-28'
26 | 
27 | 
28 | # -- General configuration ---------------------------------------------------
29 | 
30 | # Add any Sphinx extension module names here, as strings. They can be
31 | # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
32 | # ones.
33 | extensions = [
34 | ]
35 | 
36 | # Add any paths that contain templates here, relative to this directory.
37 | templates_path = ['_templates']
38 | 
39 | # The language for content autogenerated by Sphinx. Refer to documentation
40 | # for a list of supported languages.
41 | #
42 | # This is also used if you do content translation via gettext catalogs.
43 | # Usually you set "language" from the command line for these cases.
44 | language = 'pt_BR'
45 | 
46 | # List of patterns, relative to source directory, that match files and
47 | # directories to ignore when looking for source files.
48 | # This pattern also affects html_static_path and html_extra_path.
49 | exclude_patterns = []
50 | 
51 | 
52 | # -- Options for HTML output -------------------------------------------------
53 | 
54 | # The theme to use for HTML and HTML Help pages.  See the documentation for
55 | # a list of builtin themes.
56 | #
57 | # html_theme = 'alabaster'
58 | html_theme = 'sphinx_rtd_theme'
59 | 
60 | # Add any paths that contain custom static files (such as style sheets) here,
61 | # relative to this directory. They are copied after the builtin static files,
62 | # so a file named "default.css" will overwrite the builtin "default.css".
63 | html_static_path = ['_static']
64 | 
65 | source_suffix = {
66 |     '.rst': 'restructuredtext',
67 |     '.txt': 'restructuredtext',
68 |     '.md': 'markdown',
69 | }
70 | 
71 | html_theme_options = {
72 |     'canonical_url': '',
73 |     'analytics_id': 'UA-XXXXXXX-1',  #  Provided by Google in your dashboard
74 |     'logo_only': False,
75 |     'display_version': True,
76 |     'prev_next_buttons_location': 'bottom',
77 |     'style_external_links': False,
78 |     # 'vcs_pageview_mode': '',
79 |     'style_nav_header_background': '#1a1818',
80 |     # Toc options
81 |     'collapse_navigation': True,
82 |     'sticky_navigation': True,
83 |     'navigation_depth': 4,
84 |     'includehidden': True,
85 |     'titles_only': False
86 | }
87 | 


--------------------------------------------------------------------------------
/source/content/data_types.rst:
--------------------------------------------------------------------------------
  1 | Tipos de Dados
  2 | **************
  3 | 
  4 | 	Os tipos em Python podem ser mutáveis ou imutáveis, ou seja, permitem ou não alterar seu conteúdo.
  5 | 	Todos os tipos de dados são objetos, pois não existem tipos primitivos em Python.
  6 |     O tipo de dado de um objeto é determinado em tempo de execução e não há uma declaração explícita como se vê em outras linguagens.
  7 | 
  8 | 
  9 | 
 10 | Criação de um objeto e verificando seu tipo:
 11 | 
 12 | .. code-block:: python
 13 | 
 14 |     # Atribuir um inteiro à variável (objeto) "x":
 15 |     x = 7
 16 | 
 17 |     # Verificar o tipo de "x":
 18 |     type(x)
 19 | 
 20 | .. code-block:: console
 21 | 
 22 |     int
 23 | 
 24 | 
 25 | Variáveis
 26 | ---------
 27 | 
 28 | 	São criadas através de atribuição de valor e quando não existem mais referência a elas são destruídas pelo garbage colector.
 29 | 	Seus nomes devem começar por uma letra (não acentuadas) ou por underline "_".
 30 | 
 31 | Tipagem Dinâmica
 32 | ~~~~~~~~~~~~~~~~
 33 | 
 34 |     No mesmo código pode ter objetos diferentes com o mesmo nome.
 35 |     Como dito anteriormente, o tipo é determinado na execução e um mesmo nome pode ter tipos diferentes ao longo do código, porém na verdade será outro objeto.
 36 | 
 37 | 
 38 | .. code-block:: python
 39 | 
 40 |     # Criação de dois objetos de mesmo nome
 41 |     x = 3.7
 42 | 
 43 |     # Exibir o id de "x": 
 44 |     id(x)
 45 | 
 46 | .. code-block:: console
 47 | 
 48 |     140291958334736
 49 | 
 50 | .. code-block:: python
 51 | 
 52 |     # Qual é o tipo de "x":
 53 |     type(x)
 54 | 
 55 | .. code-block:: console
 56 | 
 57 |     float
 58 | 
 59 | .. code-block:: python
 60 | 
 61 |     # Atribuir uma string à variável "x":
 62 |     x = 'foo'
 63 | 
 64 |     # Verificar a id de "x":
 65 |     id(x)
 66 | 
 67 | .. code-block:: console
 68 | 
 69 |     140292017787768
 70 | 
 71 | .. code-block:: python
 72 | 
 73 |     # Qual é o tipo de "x":
 74 |     type(x)
 75 | 
 76 | .. code-block:: console
 77 | 
 78 |     str
 79 | 
 80 | Foram criados dois objetos "x", sendo o primeiro float e o segundo uma string.
 81 | Nota-se ao redefinir o valor do objeto o mesmo deixou de existir (garbagem collector) criando um novo objeto.
 82 | 
 83 | 
 84 | Tipagem Forte
 85 | ~~~~~~~~~~~~~
 86 | 
 87 |     A tipagem em Python além de dinâmica ela é forte.
 88 |     Em casos de operações matemáticas, por exemplo, é necessário fazer um cast para ser possível quando os tipos são incompatíveis.
 89 | 
 90 | .. code-block:: python
 91 | 
 92 |     # Soma entre um um número de ponto flutuante e um inteiro
 93 |     5.0 + 2
 94 | 
 95 | .. code-block:: console
 96 | 
 97 |     7.0
 98 | 
 99 | .. code-block:: python
100 | 
101 |     # Tentativa de soma entre uma string e um inteiro
102 |     '5' + 2
103 | 
104 | .. code-block:: console
105 | 
106 |     TypeError: must be str, not int
107 | 
108 | 
109 | Ocorreu um erro, pois foi feita uma tentativa de somar uma string com um inteiro.
110 | Para isso ser possível é necessário fazer um cast da string para um valor numérico (quando for compatível, é claro).
111 | 
112 | .. code-block:: python
113 | 
114 |     # Soma utilizando cast
115 |     int('5') + 2
116 | 
117 | .. code-block:: console
118 | 
119 |     7


--------------------------------------------------------------------------------
/source/content/boolean.rst:
--------------------------------------------------------------------------------
  1 | Booleanos
  2 | *********
  3 | 
  4 |     Qualquer objeto pode ser testado como um valor verdadeiro, para uso como condição em um if ou um while ou como um operando de operações "booleanas". Os seguintes valores são considerados como False: 
  5 | 
  6 | 	``False``, ``0``, ``0.0``, ``0j``, ``[]``, ``()``, ``{}``, ``set([])``, ``None``, ``""`` ou ``''``.
  7 | 
  8 | 	Instâncias de classes definidas por usuários, se a classe define um método __bool__() ou __len__(), quando este método retornar o inteiro zero ou um valor booleano False.
  9 | 	Todos outros valores são considerados verdadeiros, então objetos de muitos tipos são considerados como True.
 10 | 
 11 | .. code-block:: python
 12 | 
 13 |     # Definindo a variável como True de forma indireta:
 14 |     b = bool(1)
 15 |     
 16 |     # Verificando o valor da variável:
 17 |     print(b)
 18 | 
 19 | .. code-block:: console
 20 | 
 21 |     True
 22 | 
 23 | .. code-block:: python
 24 | 
 25 |     # Definindo a variável como False de forma indireta:
 26 |     b = bool(0)
 27 | 
 28 |     # Verificando o valor da variável:
 29 |     print(b)
 30 |     
 31 | .. code-block:: console
 32 | 
 33 |     False
 34 | 
 35 | .. code-block:: python
 36 | 
 37 |     # Teste usando a lógica OR:
 38 |     True | False
 39 | 
 40 | .. code-block:: console
 41 | 
 42 |     True
 43 | 
 44 | .. code-block:: python
 45 | 
 46 |     # Teste usando a lógica AND:
 47 |     True & False
 48 | 
 49 | .. code-block:: console
 50 | 
 51 |     False
 52 | 
 53 | .. code-block:: python
 54 | 
 55 |     # Negação de True:
 56 |     not True
 57 | 
 58 | .. code-block:: console
 59 | 
 60 |     False
 61 | 
 62 | .. code-block:: python
 63 | 
 64 |     # Negação de False:
 65 |     not False
 66 | 
 67 | .. code-block:: console
 68 | 
 69 |     True
 70 | 
 71 | .. code-block:: python
 72 | 
 73 |     # Criação de classes de teste:
 74 |     class Foo(object):
 75 |         def __len__(self):
 76 |             return 1
 77 | 
 78 |     class Bar(object):
 79 |         def __len__(self):
 80 |             return 0
 81 | 
 82 | .. code-block:: python
 83 | 
 84 |     # Criação de objetos:
 85 |     foo = Foo()
 86 |     bar = Bar()
 87 | 
 88 |     # Verificando o valor booleano dos objetos:
 89 |     bool(foo)
 90 | 
 91 | .. code-block:: console
 92 | 
 93 |     True
 94 | 
 95 | .. code-block:: python
 96 | 
 97 |     bool(bar)
 98 | 
 99 | .. code-block:: console
100 | 
101 |     False
102 | 
103 | .. code-block:: python
104 | 
105 |     # True AND (NOT False):
106 |     bool(foo) & (not bool(bar))
107 | 
108 | .. code-block:: console
109 | 
110 |     True
111 | 
112 | .. code-block:: python
113 | 
114 |     # True AND False:
115 |     bool(foo) & bool(bar)
116 | 
117 | .. code-block:: console
118 | 
119 |     False
120 | 
121 | .. code-block:: python
122 | 
123 |     # Classe para testar os métodos __bool__ e __len__:
124 |     class Spam(object):
125 |         def __bool__(self):
126 |             return True
127 | 
128 |         def __len__(self):
129 |             return 0
130 | 
131 | O método __bool__ retorna um valor verdadeiro e o método __len__ um falso.
132 | Com ambos declarados na mesma classe, um objeto dela o que retornará?
133 | 
134 | .. code-block:: python
135 | 
136 |     # Criação de objeto:
137 |     spam = Spam()
138 | 
139 |     # Verificando o valor booleano:
140 |     bool(spam)
141 | 
142 | .. code-block:: console
143 | 
144 |     True
145 | 
146 | O retorno foi verdadeiro, o método ``__bool__`` prevalece.


--------------------------------------------------------------------------------
/source/content/exec_eval_execfile_compile.rst:
--------------------------------------------------------------------------------
  1 | Expressões vs Statements
  2 | ************************
  3 | 
  4 |     Expressão: é algo que pode ser reduzido para um valor.
  5 | 
  6 |     Statement: sinônimo de comando.
  7 | 
  8 | 
  9 | 
 10 | exec
 11 | ----
 12 | 
 13 |     É uma função que executa um comando (statement) passado como string.
 14 | 
 15 | 
 16 | 
 17 | bla bla bla:
 18 | 
 19 | .. code-block:: python
 20 | 
 21 |     exec('print(5)')  # prints 5.
 22 | 
 23 | .. code-block:: comando
 24 | 
 25 |     5
 26 | 
 27 | .. code-block:: python
 28 | 
 29 |     exec('print(5)\nprint(6)')  # prints 5{newline}6.
 30 | 
 31 | .. code-block:: console
 32 | 
 33 |     5
 34 |     6
 35 | 
 36 | 
 37 | sdsdsdsdsd:
 38 | 
 39 | .. code-block:: python
 40 | 
 41 |     exec('if True: print(6)')  # prints 6.
 42 | 
 43 | .. code-block:: console
 44 | 
 45 |     6
 46 | 
 47 | 
 48 | 
 49 | .. code-block:: python
 50 | 
 51 |     exec('5')  # does nothing and returns nothing.
 52 |     exec('x = 7')  # does nothing and returns nothing.
 53 | 
 54 | 
 55 | 
 56 | eval
 57 | ----
 58 | 
 59 |     É uma função que retorna o resultado de uma expressão.
 60 | 
 61 | 
 62 | 
 63 | bla bla bla:
 64 | 
 65 | .. code-block:: python
 66 | 
 67 |     x = eval('5')  # x <- 5
 68 |     x = eval('%d + 6' % x)  # x <- 11
 69 |     x = eval('abs(%d)' % -100)  # x <- 100
 70 |     x = eval('x = 5')  # INVÁLIDO; atribuição não é uma expressão
 71 | 
 72 | .. code-block:: console
 73 | 
 74 |     SyntaxError: invalid syntax
 75 | 
 76 | 
 77 | 
 78 | wewewewe:
 79 | 
 80 | .. code-block:: python
 81 | 
 82 |     x = eval('if 1: x = 4')  # INVÁLIDO; if é um statement e não uma expressão
 83 | 
 84 | .. code-block:: console
 85 | 
 86 |     SyntaxError: invalid syntax
 87 | 
 88 | 
 89 | 
 90 | .. https://nedbatchelder.com/blog/201206/eval_really_is_dangerous.html
 91 | 
 92 | bla bla bla:
 93 | 
 94 | .. code-block:: python
 95 | 
 96 |     execfile(file)
 97 | 
 98 | 
 99 | 
100 | bla bla bla:
101 | 
102 | .. code-block:: bash
103 | 
104 |     cat << EOF > /tmp/foo.py
105 |     print('hello, world!')
106 |     EOF
107 | 
108 | 
109 | 
110 | bla bla bla:
111 | 
112 | .. code-block:: bash
113 | 
114 |     python /tmp/foo.py
115 | 
116 | .. code-block:: console
117 | 
118 |     hello, world!
119 | 
120 | 
121 | 
122 | bla bla bla:
123 | 
124 | .. code-block:: bash
125 | 
126 |     execfile('/tmp/foo.py')
127 | 
128 | .. code-block:: console
129 | 
130 |     hello, world!
131 | 
132 | 
133 | compile
134 | -------
135 | 
136 | compile is a lower level version of exec and eval. It does not execute or evaluate your statements or expressions, but returns a code object that can do it. The modes are as follows:
137 | 
138 |     compile(string, '', 'eval') returns the code object that would have been executed had you done eval(string). Note that you cannot use statements in this mode; only a (single) expression is valid.
139 |     compile(string, '', 'exec') returns the code object that would have been executed had you done exec(string). You can use any number of statements here.
140 |     compile(string, '', 'single') is like the exec mode, but it will ignore everything except for the first statement. Note that an if/else statement with its results is considered a single statement.
141 | 
142 | .. http://sahandsaba.com/thirty-python-language-features-and-tricks-you-may-not-know.html
143 | 
144 | 
145 | 
146 | 
147 | .. python3.7 -mtimeit -s 'code = "a = 2; b = 3; c = a * b"' 'exec(code)'
148 | 
149 | 
150 | .. python3.7 -mtimeit -s 'code = compile("a = 2; b = 3; c = a * b", "<string>", "exec")' 'exec(code)'


--------------------------------------------------------------------------------
/source/content/tuple.rst:
--------------------------------------------------------------------------------
  1 | Tupla
  2 | *****
  3 | 
  4 | |	Tupla têm sua estrutura muito similar à da lista, no entanto, ela é imutável.
  5 | |	Ela é mais recomendada para uso de dados estáticos, pois comparada à lista, tem
  6 | | um desempenho melhor devido à sua simplicidade e consome menos recursos.
  7 | 
  8 | 
  9 | 
 10 | .. code-block:: python
 11 | 
 12 |     # Declaração de uma tupla vazia:
 13 | 	t = ()
 14 | 
 15 | ou
 16 | 
 17 | .. code-block:: python
 18 | 
 19 |     t = tuple()
 20 | 
 21 | 
 22 | .. code-block:: python
 23 | 
 24 |     # Declaração de uma tupla com três elementos:
 25 | 	t = tuple([1, 2, 3])
 26 | 
 27 | ou
 28 | 
 29 | .. code-block:: python
 30 | 
 31 |     t = (1, 2, 3)
 32 | 
 33 | ou
 34 | 
 35 | .. code-block:: python
 36 | 
 37 |     t = 1, 2, 3
 38 | 
 39 | .. code-block:: python
 40 | 
 41 |     # Exibindo o conteúdo da tupla:
 42 | 	t
 43 | 
 44 | .. code-block:: console
 45 | 
 46 |     (1, 2, 3)
 47 | 
 48 | 
 49 | .. code-block:: python
 50 | 
 51 | 	# Criação de um conjunto (set) contendo todos atributos e 
 52 | 	# métodos de uma tupla:
 53 | 	tupla = set(dir(tuple))
 54 | 
 55 | 
 56 | .. code-block:: python
 57 | 
 58 |     # Criação de um conjunto (set) contendo todos atributos e 
 59 | 	# métodos de uma lista:
 60 | 	lista = set(dir(list))
 61 | 
 62 | 
 63 | 
 64 | .. code-block:: python
 65 | 
 66 |     # Via intersecção, o que há em comum entre lista e tupla?:
 67 | 	tupla.intersection(lista)
 68 | 
 69 | . . .
 70 | 
 71 | Tuplas tem apenas os métodos count e index.
 72 | 
 73 | .. code-block:: python
 74 | 
 75 |     # Tupla de um único elemento:
 76 | 	t = (1, )
 77 | 
 78 | 
 79 | .. code-block:: python
 80 | 
 81 |     # Exibir o conteúdo da tupla:
 82 | 	t
 83 | 
 84 | .. code-block:: console
 85 | 
 86 |     (1,)
 87 | 
 88 | 
 89 | 
 90 | .. code-block:: python
 91 | 
 92 |     # Função type para verificar o tipo do objeto:
 93 | 	type(t)
 94 | 
 95 | .. code-block:: console
 96 | 
 97 |     tuple
 98 | 
 99 | 
100 | .. code-block:: python
101 | 
102 |     # Declaração de duas variáveis e trocando o valor entre elas:
103 | 	x = 0
104 | 	y = 1
105 | 	x, y = y, x  # A troca se dá pela atribuição respectiva
106 | 
107 | 
108 | 
109 | .. code-block:: python
110 | 
111 | 	# Verificando os valores das variáveis:
112 | 	x
113 | 
114 | .. code-block:: console
115 | 
116 |     1
117 | 
118 | 
119 | .. code-block:: python
120 | 
121 |     y
122 | 
123 | 
124 | .. code-block:: console
125 | 
126 |     0
127 | 
128 | 
129 | 
130 | .. code-block:: python
131 | 
132 |     # Criação de uma variável que retorna uma tupla com três elementos:
133 | 	def retorna_tupla():
134 | 		return 1, 2, 3
135 | 
136 | 
137 | 
138 | .. code-block:: python
139 | 
140 |     # Atribuição respectiva:
141 | 	x, y, z = retorna_tupla()
142 | 
143 | 
144 | .. code-block:: python
145 | 
146 |     # Verificando os valores das variáveis:
147 | 	print(x)
148 | 
149 | .. code-block:: console
150 | 
151 |     1
152 | 
153 | .. code-block:: python
154 | 
155 |     print(y)
156 | 
157 | .. code-block:: console
158 | 
159 |     2
160 | 
161 | .. code-block:: python
162 | 
163 |     print(z)
164 | 
165 | .. code-block:: console
166 | 
167 |     3
168 | 
169 | Tuplas são imutáveis, mas seus elementos não necessariamente:
170 | 
171 | .. code-block:: python
172 | 
173 |     t = ({}, [])   # Tupla com dois elementos; um dicionário e uma lista
174 | 	t[0].update({'chave': 'valor'})  # Alterando o primeiro elemento
175 | 	t[1].append(7)  # Alterando o segundo elemento
176 | 	t  # Exibindo a tupla
177 | 
178 | .. code-block:: console
179 | 
180 |     ({'chave': 'valor'}, [7])


--------------------------------------------------------------------------------
/source/content/modules.rst:
--------------------------------------------------------------------------------
  1 | Módulos
  2 | *******
  3 | 
  4 | 	Módulos são as bibliotecas de Python.
  5 | 	São simples arquivos de código Python (.py) e têm que estar dentro do PYTHONPATH.
  6 | 
  7 | > import sys
  8 | 
  9 | > dir(sys)
 10 | ['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spe
 11 | c__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames', '_debugmallocstats', '_getframe'
 12 | , '_home', '_mercurial', '_xoptions', 'abiflags', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_mo
 13 | dule_names', 'byteorder', 'call_tracing', 'callstats', 'copyright', 'displayhook', 'dont_write_bytecode', 'exc_info', '
 14 | excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'getallocatedblocks', 'get
 15 | checkinterval', 'getdefaultencoding', 'getdlopenflags', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'ge
 16 | trefcount', 'getsizeof', 'getswitchinterval', 'gettrace', 'hash_info', 'hexversion', 'implementation', 'int_info', 'int
 17 | ern', 'last_traceback', 'last_type', 'last_value', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks
 18 | ', 'path_importer_cache', 'platform', 'prefix', 'setcheckinterval', 'setdlopenflags', 'setprofile', 'setrecursionlimit'
 19 | , 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions'
 20 | ]
 21 | 
 22 | > print(sys.path)
 23 | 
 24 | ['', '/usr/bin', '/usr/lib/python3.4', '/usr/lib/python3.4/plat-x86_64-linux-gnu', '/usr/lib/python3.4/lib-dynload', '/usr/local/lib/python3.4/dist-packages', '/usr/lib/python3/dist-packages']
 25 | 
 26 | 
 27 | 	A primeira incidência é uma string vazia (''), o que significa ser o diretório corrente.
 28 | 
 29 | $ vim foo.py
 30 | 
 31 | # _*_ encoding: utf-8 _*_
 32 | 
 33 | print('Este arquivo, {} é um módulo!'.format(__file__))
 34 | print('Seu nome é {}.'.format(__name__))
 35 | 
 36 | 
 37 | > import foo
 38 | Este arquivo, /tmp/foo.py é um módulo!
 39 | Seu nome é foo.
 40 | 
 41 | 
 42 | $ python3 foo.py 
 43 | .. code-block:: console
 44 | 
 45 |     Este arquivo, foo.py é um módulo!
 46 |     Seu nome é __main__.
 47 | 
 48 | 
 49 | $ vim foo.py
 50 | 
 51 | # _*_ encoding: utf-8 _*_
 52 | 
 53 | if __name__ == '__main__':
 54 |     print('Executado a partir da linha de comando.')
 55 | else:
 56 |     print('Módulo importado.')
 57 | 
 58 | > import foo
 59 | Módulo importado.
 60 | 
 61 | > type(foo)
 62 | <class 'module'>
 63 | 
 64 | $ python3 foo.py
 65 | Executado a partir da linha de comando.
 66 | 
 67 | Recarregando um Módulo
 68 | 
 69 | > import importlib
 70 | > importlib.reload(foo)
 71 | .. code-block:: console
 72 | 
 73 |     Módulo importado.
 74 |     <module 'foo' from '/tmp/foo.py'>
 75 | 
 76 | 
 77 | $ vim foo.py
 78 | 
 79 | # _*_ encoding: utf-8 _*_
 80 | 
 81 | class Pessoa(object):
 82 |     nome = ''
 83 |     idade = 0
 84 | 
 85 |     def saudacao(self):
 86 |         print('Olá, meu nome é {}'.format(self.nome))
 87 | 
 88 | class Funcionario(Pessoa):
 89 |     matricula = ''
 90 | 
 91 | def cubo(x):
 92 |     return x ** 3
 93 | 
 94 | 
 95 | Recarregando um módulo
 96 | 
 97 | > importlib.reload(foo)
 98 | 
 99 | .. code-block:: console
100 | 
101 |     <module 'foo' from '/tmp/foo.py'>
102 | 
103 | > f1 = foo.Funcionario()
104 | > f1.nome = 'Chiquinho'
105 | > f1.saudacao()
106 | .. code-block:: console
107 | 
108 |     Olá, meu nome é Chiquinho
109 | 
110 | > print(foo.cubo(7))
111 | 
112 | .. code-block:: console
113 | 
114 |     343
115 | 
116 | 
117 | 
118 | 
119 | 
120 | import as ...
121 | 
122 | > import foo as meu_modulo
123 | > f1 = meu_modulo.Funcionario()
124 | > f1.matricula = 'xyz12345'
125 | > print(f1.matricula)
126 | .. code-block:: console
127 | 
128 |     xyz12345
129 | 
130 | 
131 | from módulo import ...
132 | 
133 | .. code-block:: python
134 | 
135 |     from foo import Funcionario
136 |     f1 = Funcionario()
137 |     f1.nome = 'Chiquinho'
138 |     f1.saudacao()
139 | 
140 | .. code-block:: console
141 | 
142 |     Olá, meu nome é Chiquinho


--------------------------------------------------------------------------------
/source/content/staticmethod_classmethod.rst:
--------------------------------------------------------------------------------
  1 | Método de Classe e Método Estático
  2 | **********************************
  3 | 
  4 | |   Existem dois tipos de métodos que podem ser executados diretamente de uma
  5 | | classe, ou seja, sem precisar criar um objeto dela. Por serem independentes
  6 | | de objetos não esperam um "`self`" como primeiro parâmetro.
  7 | |   A utilidade desses métodos é para processamento de dados de classes em vez
  8 | | de instâncias.
  9 | |   Mesmo que isso possa ser feito por uma função escrita externamente à classe,
 10 | | não terá uma associação a essa classe e não poderão ser herdados por classes
 11 | | filhas. 
 12 | |   Métodos estáticos são usados para agrupar funções que têm conexão lógica com
 13 | | a classe.
 14 | |   Métodos de classe são usados para o mesmo fim que os métodos estáticos, mas
 15 | | que também podem processar dados da classe diretamente.
 16 | 
 17 | 
 18 | 
 19 | Observe no exemplo a seguir as diferentes assinaturas para respectivamente os
 20 | métodos comum, de classe e estático:
 21 | 
 22 | .. code-block:: python
 23 | 
 24 |     class Foo(object):
 25 |         
 26 |         def metodo_comum(self):
 27 |             print(f'Método comum {self}')
 28 | 
 29 |         @classmethod
 30 |         def metodo_de_classe(cls):
 31 |             print(f'Método de classe {cls}')
 32 | 
 33 |         @staticmethod
 34 |         def metodo_estatico():
 35 |             print('Método estático')
 36 | 
 37 | 	
 38 | |   Na classe foram declarados três métodos, sendo que o primeiro que é um
 39 | | método comum, cujo primeiro argumento é o tradicional self que representa a
 40 | | instância (objeto) criada a partir da classe.
 41 | |   O segundo método é decorado com @classmethod, faz desse um método de
 42 | | classe, o qual não faz necessária a criação de um objeto para ser
 43 | | utilizado.
 44 | |   Esse tipo de método é invocado da seguinte forma:
 45 | |
 46 | | `Classe.metodo_de_classe().`
 47 | |
 48 | |   Ainda sobre o método de classe um detalhe interessante é o "cls" em vez de
 49 | | self.
 50 | |   A variável "cls" é utilizada com um propósito similar ao de self. No caso
 51 | | representa a classe à qual o método pertence.
 52 | |   Como self, cls é apenas uma convenção, deixando ao gosto do usuário, se o 
 53 | | mesmo quiser utilizar outro nome.
 54 | |   E por fim o método estático, decorado com @staticmethod é como uma função
 55 | | definida externamente à classe. Não recebe um "self" ou um "cls".
 56 | 
 57 | 
 58 | 
 59 | Chamada do método comum pela classe:
 60 | 
 61 | .. code-block:: python
 62 | 
 63 |     Foo.metodo_comum()
 64 | 
 65 | .. code-block:: console
 66 | 
 67 |     TypeError: metodo_comum() missing 1 required positional argument: 'self'
 68 | 
 69 | |   Observa-se que se for feita uma tentativa de invocar a partir da classe um
 70 | | método que não seja nem de classe e nem estático será retornado um erro.
 71 | 
 72 | 
 73 | 
 74 | Invocando um método de classe a partir da classe:
 75 | 
 76 | .. code-block:: python
 77 | 
 78 |     Foo.metodo_de_classe()
 79 | 
 80 | .. code-block:: console
 81 | 
 82 |     Método de classe <class '__main__.Foo'>
 83 | 
 84 | 
 85 | 
 86 | Invocando um método estático a partir da classe:
 87 | 
 88 | .. code-block:: python
 89 | 
 90 |     Foo.metodo_estatico()
 91 | 
 92 | .. code-block:: console
 93 | 
 94 |     Método estático
 95 | 
 96 | 
 97 | 
 98 | Criação de objeto:
 99 | 
100 | .. code-block:: python
101 | 
102 |     o = Foo()
103 | 
104 | |   A instância "o" é implicitamente passada como argumento para o método
105 | | construtor que não foi declarado.
106 | 
107 | 
108 | 
109 | Chamada do método comum pela instância:
110 | 
111 | .. code-block:: python
112 | 
113 |     o.metodo_comum()
114 | 
115 | 
116 | .. code-block:: console
117 | 
118 |     Método comum <__main__.Foo object at 0x7f40d812d410>
119 | 
120 | 
121 | 
122 | Chamada do método de classe pela instância:
123 | 
124 | .. code-block:: python
125 | 
126 |     o.metodo_de_classe()
127 | 
128 | .. code-block:: console
129 | 
130 |     Método de classe <class '__main__.Foo'>
131 | 
132 | 
133 | 
134 | Chamada do método estático pela instância:
135 | 
136 | .. code-block:: python
137 | 
138 |     o.metodo_estatico()
139 |     
140 | .. code-block:: console
141 | 
142 |     Método estático


--------------------------------------------------------------------------------
/source/content/recursive.rst:
--------------------------------------------------------------------------------
  1 | Recursividade
  2 | *************
  3 | 
  4 | 	De uma forma geral, recursividade é uma palavra cujo significado é a capacidade de um objeto fazer uma chamada a si mesmo em profundidade.
  5 | 	Como exemplo podemos citar aqui um espelho de frente para outro.
  6 | 	A palavra recursividade tem como origem o latim, do verbo "recurrere", cujo significado é algo como correr de volta. Essa característica de correr de volta é algo similar a um bumerangue, em que, obedecendo uma condição, ao chegar no fundo, esse "bumerangue" volta com o resultado desejado.
  7 | 	Em linguagem de programação, recursividade é a capacidade de uma função fazer uma chamada a si mesma dentro de sua definição. Uma função recursiva precisa de uma condição de término para não rodar em um loop infinito, o que causaria efeitos indesejados.
  8 | 
  9 | 
 10 | 
 11 | .. code-block:: python
 12 | 
 13 |     # _*_ coding: utf-8 _*_
 14 | 
 15 |     # Fatoração
 16 | 
 17 |     def fatorial(n):
 18 |         if (n == 1) or (n == 0):
 19 |             return 1
 20 |         else:
 21 |             return n * fatorial(n - 1)
 22 | 
 23 | 
 24 | Ida:
 25 | 
 26 | n = 5 -> 5 * fatorial(4)
 27 | 
 28 | n = 4 -> 4 * fatorial(3)
 29 | 
 30 | n = 3 -> 3 * fatorial(2)
 31 | 
 32 | n = 2 -> 2 * fatorial(1)
 33 | 
 34 | 
 35 | Volta:
 36 | 
 37 | fatorial(1) = 1
 38 | 
 39 | fatorial(2) = 2 * 1 = 2
 40 | 
 41 | fatorial(3) = 3 * 2 = 6
 42 | 
 43 | fatorial(4) = 4 * 6 = 24
 44 | 
 45 | fatorial(5) = 5 * 24 = 120
 46 | 
 47 | 
 48 | 
 49 | print(fatorial(5))
 50 | 
 51 | 
 52 | # Fibonacci
 53 | 
 54 | .. code-block:: python
 55 | 
 56 |     def fibo(n):
 57 |         if (n < 2):
 58 |             return n
 59 |         else:
 60 |             return fibo(n - 1) + fibo(n - 2)
 61 | 
 62 | 
 63 | 
 64 | +--------------+---+---+---+---+---+---+---+----+----+----+----+-----+
 65 | | Fibonacci    | 0 | 1 | 1 | 2 | 3 | 5 | 8 | 13 | 21 | 34 | 55 | ... |
 66 | +--------------+---+---+---+---+---+---+---+----+----+----+----+-----+
 67 | | Elemento (n) | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7  | 8  | 9  | 10 | ... |
 68 | +--------------+---+---+---+---+---+---+---+----+----+----+----+-----+
 69 | 
 70 | 
 71 | Ida:
 72 | 
 73 | n = 7 -> fib(6) + fib(5)
 74 | n = 6 -> fib(5) + fib(4)
 75 | n = 5 -> fib(4) + fib(3)
 76 | n = 4 -> fib(3) + fib(2)
 77 | n = 3 -> fib(2) + fib(1)
 78 | n = 2 -> fib(1) + fib(0)
 79 | n = 1 -> fib(0)
 80 | 
 81 | 
 82 | Volta:
 83 | 
 84 | fib(0) = 0
 85 | 
 86 | fib
 87 | 
 88 | 
 89 | 
 90 | print(fib(7))
 91 | 
 92 | 
 93 | Memoização
 94 | ----------
 95 | 
 96 | É uma técnica de otimização usada principalmente para acelerar aplicativos
 97 | pelo armazenamento de resultados de chamadas de função que têm custo alto de
 98 | processamento e retornando o resultado do cache quando as mesmas entradas
 99 | acontecerem novamente.
100 | 
101 | 
102 | Para testarmos vamos criar o arquivo memoizacao.py com o seguinte conteúdo:
103 | 
104 | .. code-block:: python
105 | 
106 |     #_*_ encoding: utf-8 _*_
107 | 
108 |     import time
109 | 
110 |     ''' Fibonacci function '''
111 |     def fibo(n):
112 |         if (n < 2): return n
113 |         else:
114 |             return fibo(n - 1) + fibo(n - 2)
115 | 
116 | 
117 |     ''' Memoize function '''
118 |     def memoize(f):
119 |         # dictionary (cache)
120 |         mem = {}
121 | 
122 |         ''' Helper function '''
123 |         def memoizer(*param):
124 |             key = repr(param)
125 |             if not key in mem:
126 |                 mem[key] = f(*param)
127 |             return mem[key]
128 | 
129 |         return memoizer
130 | 
131 |     # Start time
132 |     t1 = time.time()
133 | 
134 |     # Loop 
135 |     for i in range(35):
136 |         print('fib(%s) = %s' % (i, fibo(i)))
137 | 
138 |     # End time
139 |     t2 = time.time()
140 | 
141 |     # Total time
142 |     print('Tempo de execução: %.3fs' % (t2 - t1))
143 | 
144 |     # Take a pause
145 |     raw_input('Pressione <ENTER> para continuar\n')
146 | 
147 |     # Memoization of fibo
148 |     fibo = memoize(fibo)
149 | 
150 |     # Start time
151 |     t1 = time.time()
152 | 
153 |     # loop after memoization
154 |     for i in range(40):
155 |         print('fib(%s) = %s' % (i, fibo(i)))
156 | 
157 |     # End time
158 |     t2 = time.time()
159 | 
160 |     # Total time
161 |     print('Tempo de execução: %.3fs' % (t2 - t1))
162 | 
163 | 
164 | 
165 | Execute da seguinte forma:
166 | 
167 | .. code-block:: bash
168 | 
169 |     python memoizacao.py
170 | 
171 | 
172 | 
173 | Antes da memoização:
174 | 
175 | Tempo de execução: 5.107s
176 | 
177 | Depois da memoização:
178 | 
179 | Tempo de execução: 0.001s
180 | 
181 | Podemos ver na prática como é eficiente e como agiliza na execução.


--------------------------------------------------------------------------------
/source/content/decimal_module.rst:
--------------------------------------------------------------------------------
  1 | O Módulo decimal
  2 | ****************
  3 | 
  4 | 	O módulo decimal fornece suporte para aritmética de ponto flutuante decimal.
  5 | 	Ele oferece muitas vantagens sobre o tipo float.
  6 |     O módulo decimal "é baseado em um modelo de ponto flutuante que foi projetado com pessoas em mente e necessariamente tem um princípio orientador fundamental - computadores devem fornecer uma aritmética que funciona da mesma maneira que a aritmética que as pessoas aprendem na escola" - extraindo da especificação da aritmética decimal.
  7 |     Números decimais podem ser representados exatamente. Em contraste, números como 1.1 e 2.2 não têm representações exatas em ponto flutuante binário. Usuários finais não esperam que 1.1 + 2.2 seja exibido como 3.3000000000000003 como é feito como o ponto flutuante binário.
  8 | 	A exatidão leva à aritmética. Com ponto flutuante decimal, 0.1 + 0.1 + 0.1 - 0.3 é exatamente igual a zero. Com ponto flutuante binário, o resultado é 5.5511151231257827e-017.
  9 |     Enquanto próximo a zero, as diferenças evitam testes de igualdade confiáveis e diferenças podem acumular. Por essa razão, decimal é preferido em aplicações de contabilidade que tem invariações de igualdade rigorosas.
 10 |     O módulo decimal incorpora a noção de posições (casas decimais) significantes em que 1.30 + 1.20 é 2.50. O zero no fim é mantido para indicar a significância. Esta é a apresentação habitual para aplicações monetárias. Para multiplicação, a abordagem do "livro de escola" usa todos os números nos multiplicandos. Por exemplo, 1.3 * 1.2 dá 1.56 enquanto que 1.30 * 1.20 dá 1.5600.
 11 |     Ao contrário de hardware baseado em ponto flutuante binário, o módulo decimal tem uma precisão alterável (padrão 28 casas decimais).
 12 | 
 13 | 
 14 | 
 15 | .. code-block:: python
 16 | 
 17 |     # Importação do módulo:
 18 |     import decimal
 19 | 
 20 |     # Criação do objeto Decimal:
 21 |     d = decimal.Decimal('0.777')
 22 | 
 23 |     # Exibindo o valor do objeto decimal:
 24 |     d
 25 | 
 26 | .. code-block:: console
 27 | 
 28 |     Decimal('0.777')
 29 | 
 30 | .. code-block:: python
 31 | 
 32 |     # Exibe o valor de "d":
 33 |     print(d)
 34 | 
 35 | .. code-block:: console
 36 | 
 37 |     0.777
 38 | 
 39 | Algumas coisas "estranhas":
 40 | 
 41 | .. code-block:: python
 42 | 
 43 |     # Somando dois floats:
 44 |     1.1 + 2.2
 45 | 
 46 | .. code-block:: console
 47 | 
 48 |     3.3000000000000003
 49 | 
 50 | .. code-block:: python
 51 | 
 52 |     # Outra operação com floats:
 53 |     0.1 + 0.1 + 0.1 - 0.3
 54 | 
 55 | .. code-block:: console
 56 | 
 57 |     5.551115123125783e-17
 58 | 
 59 | .. code-block:: python
 60 | 
 61 |     # Importando apenas a classe Decimal:
 62 |     from decimal import Decimal
 63 | 
 64 |     # Fazendo as mesmas operações anteriores com o módulo decimal:
 65 |     Decimal('1.1') + Decimal('2.2')
 66 | 
 67 | .. code-block:: console
 68 | 
 69 |     Decimal('3.3')
 70 | 
 71 | .. code-block:: python
 72 | 
 73 |     # Importando a função getcontext:
 74 |     from decimal import getcontext
 75 | 
 76 |     # Operações de multiplicação:
 77 |     Decimal('1.3') * Decimal('1.2')
 78 | 
 79 | .. code-block:: console
 80 | 
 81 |     Decimal('1.56')
 82 | 
 83 | .. code-block:: python
 84 | 
 85 |     # Multiplicação de decimais:
 86 |     Decimal('1.30') * Decimal('1.20')
 87 | 
 88 | .. code-block:: console
 89 | 
 90 |     Decimal('1.5600')
 91 | 
 92 | O último retorno foi com um número com 4 (quatro) casas decimais.
 93 | 
 94 | A função getcontext, com o atributo "prec" (precision) ajusta a quantidade máxima de dígitos (antes e depois do ponto flutuante) para 3 (três):
 95 | 
 96 | .. code-block:: python
 97 | 
 98 |     # Alterar o nível de precisão para 3:
 99 |     getcontext().prec = 3
100 | 
101 | A precisão vai ser refletida em operações com o módulo decimal.
102 | Caso seja necessário o número será arredondado.
103 | 
104 | .. code-block:: python
105 | 
106 |     # Operação de multiplicação de números com ponto flutuante
107 |     Decimal('1.300') * Decimal('1.200')
108 | 
109 | .. code-block:: console
110 | 
111 |     Decimal('1.56')
112 | 
113 | .. code-block:: python
114 | 
115 |     # Ajustando a precisão para 10 (dez)
116 |     getcontext().prec = 10
117 | 
118 |     # Multiplicação:
119 |     Decimal('1.3897') * 2
120 | 
121 | .. code-block:: console
122 | 
123 |     Decimal('2.7794')
124 | 
125 | .. code-block:: python
126 | 
127 |     # Ajustando a precisão para 3 (três):
128 |     getcontext().prec = 3
129 | 
130 |     # Multiplicação:
131 |     Decimal('1.3897') * 2
132 | 
133 | .. code-block:: console
134 | 
135 |     Decimal('2.78')
136 | 
137 | Nota-se que foi feito um arredondamento do número.
138 | 


--------------------------------------------------------------------------------
/source/content/with.rst:
--------------------------------------------------------------------------------
  1 | with
  2 | ****
  3 | 
  4 | |   O comando with é usado para encapsular a execução de um bloco com métodos definidos por um gerenciador de contexto.
  5 | 
  6 | 
  7 | 
  8 | Criação de um arquivo via shell do sistema operacional:
  9 | 
 10 | .. code-block:: bash
 11 | 
 12 |     cat << EOF > /tmp/numbers.txt
 13 |     1
 14 |     2
 15 |     3
 16 |     EOF
 17 | 
 18 | 
 19 | 
 20 | Abrir o arquivo em modo leitura:
 21 | 
 22 | .. code-block:: python
 23 | 
 24 |     f = open('/tmp/numbers.txt', 'r')
 25 | 
 26 |     # Loop:
 27 |     for line in f:
 28 |         print(int(line))
 29 | 
 30 |     # Fecha o arquivo:
 31 |     f.close()
 32 | 
 33 | .. code-block:: console
 34 | 
 35 |     1
 36 |     2
 37 |     3
 38 | 
 39 |         
 40 | 
 41 | O arquivo foi fechado?:
 42 | 
 43 | .. code-block:: python
 44 | 
 45 |     print(f.closed)
 46 | 
 47 | .. code-block:: console
 48 | 
 49 |     True
 50 | 
 51 | 
 52 | 
 53 | Bla bla bla:
 54 | 
 55 | .. code-block:: python
 56 | 
 57 |     f = open('/tmp/numbers_str.txt', 'r')
 58 |     for line in f:
 59 |         print(int(line))
 60 |     f.close()
 61 |     print(f.closed)
 62 | 
 63 | .. code-block:: console
 64 | 
 65 |     1
 66 |     2
 67 | 
 68 |     ValueError: invalid literal for int() with base 10: 'three\n'
 69 | 
 70 | 
 71 | 
 72 | Bla bla bla:
 73 | 
 74 | .. code-block:: python
 75 | 
 76 |     # 
 77 |     f.closed
 78 | 
 79 | .. code-block:: console
 80 | 
 81 |     False
 82 | 
 83 | 
 84 | 
 85 | Bla bla bla:
 86 | 
 87 | .. code-block:: python
 88 | 
 89 |     # 
 90 |     f.close()
 91 |     f.closed
 92 | 
 93 | .. code-block:: console
 94 | 
 95 |     True
 96 | 
 97 | 
 98 | 
 99 | Bla bla bla:
100 | 
101 | .. code-block:: python
102 | 
103 |     try:
104 |         f = open('/tmp/numbers_str.txt', 'r')
105 |         for line in f:
106 |             print(int(line))
107 |     except ValueError: 
108 |         print('Ops... Isso não é um número em forma de dígitos...')
109 |     finally:
110 |         f.close()
111 |         print(f.closed)
112 | 
113 | .. code-block:: console
114 | 
115 |     1
116 |     2
117 |     Ops... Isso não é um número em forma de dígitos...
118 |     True
119 | 
120 | 
121 | 
122 | Bla bla bla:
123 | 
124 | .. code-block:: python
125 | 
126 |     with open('/tmp/numbers.txt', 'r') as f:
127 |         for line in f:
128 |             print(int(line))
129 |     print(f.closed)
130 | 
131 | .. code-block:: console
132 | 
133 |     1
134 |     2
135 |     3
136 |     True
137 | 
138 | 
139 | 
140 | Bla bla bla:
141 | 
142 | .. code-block:: python
143 | 
144 |     try:
145 |         with open('/tmp/numbers_str.txt', 'r') as f:
146 |             for line in f:
147 |                 print(int(line))
148 |     except ValueError:
149 |         print('Ops... Isso não é um número em forma de dígitos...')
150 |     finally:
151 |         print(f.closed)
152 | 
153 | .. code-block:: console
154 | 
155 |     1
156 |     2
157 |     Ops... Isso não é um número em forma de dígitos...
158 |     True
159 | 
160 | 
161 | 
162 | Exemplo de with com conexão a uma base de dados PostgreSQL:
163 | 
164 | .. code-block:: python
165 |     
166 |     from psycopg2 import connect as pg_conn
167 | 
168 |     # Parâmetros de conexão
169 |     PGHOST = 'localhost'
170 |     PGDB = 'postgres'
171 |     PGPORT = 5432
172 |     PGUSER = 'postgres'
173 |     PGPASS = '123'
174 |     APPLICATION_NAME = 'python'
175 | 
176 |     # String de conexão
177 |     CONN = f'''
178 |               host={PGHOST}
179 |               dbname={PGDB}
180 |               port={PGPORT}
181 |               user={PGUSER}
182 |               password={PGPASS}
183 |               application_name={APPLICATION_NAME}
184 |               '''
185 | 
186 |     # String SQL
187 |     SQL = "SELECT 'Hello, World!';"
188 | 
189 |     # Criação de uma classe para conexão ao banco com with.
190 |     # Através dela se conecta à base, executa comando(s) SQL e fecha a conexão
191 |     # ao banco.
192 | 
193 |     class PgConnection(object):
194 | 
195 |         def __init__(self, conn, sql):
196 |             self.conn = conn
197 |             self.sql = sql
198 | 
199 |         def __enter__(self):
200 |             print('===== __enter__ =====\n')
201 |             self.conn = pg_conn(self.conn)
202 |             cursor = self.conn.cursor()
203 |             cursor.execute(self.sql)
204 |             self.data = cursor.fetchone()
205 |             return self.data
206 | 
207 |         def __exit__(self, type, value, traceback):
208 |             print('\n===== __exit__ =====')
209 |             self.conn.close()
210 |             return 0
211 | 
212 | 
213 |     with PgConnection(CONN, SQL) as x:
214 |         print(x[0])
215 | 
216 | 
217 | .. code-block:: console
218 | 
219 |     ===== __enter__ =====
220 | 
221 |     Hello, World!
222 | 
223 |     ===== __exit__ =====


--------------------------------------------------------------------------------
/source/content/if.rst:
--------------------------------------------------------------------------------
  1 | if / elif / else
  2 | ****************
  3 | 
  4 | 	O comando if, que inglês significa "se" indica uma condição.
  5 | 
  6 | 
  7 | 
  8 | Criação de dois objetos int:
  9 | 
 10 | .. code-block:: python
 11 | 
 12 |     x = 7
 13 |     y = 5
 14 | 
 15 | 
 16 | 
 17 | Bloco if teste se x é maior que y:
 18 | 
 19 | .. code-block:: python
 20 | 
 21 |     if x > y:
 22 |         print('X é maior')
 23 | 
 24 | .. code-block:: console
 25 | 
 26 |     X é maior
 27 | 
 28 | 
 29 | 
 30 | Bloco if teste se x é menor que y:
 31 | 
 32 | .. code-block:: python
 33 | 
 34 |     if x < y:
 35 |         print('Y é maior')
 36 | 
 37 | |   Aqui nada aconteceu, pois a condição de if não foi satisfeita.
 38 | 
 39 | 
 40 | 
 41 | Criação de duas variáveis booleanas:
 42 | 
 43 | .. code-block:: python
 44 | 
 45 |     foo = True
 46 |     bar = False
 47 | 
 48 | 
 49 | 
 50 | Modo "pythônico" de se testar um valor booleano:
 51 | 
 52 | .. code-block:: python
 53 | 
 54 |     if foo:
 55 |         print('foo é verdadeiro!')
 56 | 
 57 | .. code-block:: console
 58 | 
 59 |     foo é verdadeiro!
 60 | 
 61 | |   Note que não foi testado `foo == False`, utilizou-se uma maneira muito mais elegante.
 62 | 
 63 | 
 64 | 
 65 | Testando uma Variável booleana com negação:
 66 | 
 67 | .. code-block:: python
 68 | 
 69 |     if not bar:
 70 |         print('bar é falso!')
 71 | 
 72 | .. code-block:: console
 73 | 
 74 |     bar é falso!
 75 | 
 76 | 
 77 | 
 78 | Podemos também de maneira parecida, se a variável tiver um conteúdo:    
 79 | 
 80 | .. code-block:: python
 81 | 
 82 |     # Objeto string:
 83 |     texto = 'Python e PostgreSQL: Poder!'
 84 | 
 85 |     # Bloco if:
 86 |     if texto:
 87 |         print('A string NÃO é vazia!')
 88 | 
 89 | 
 90 | .. code-block:: console
 91 | 
 92 |     A string NÃO é vazia!
 93 | 
 94 | 
 95 | 
 96 | Teste de negação com string vazia:    
 97 | 
 98 | .. code-block:: python
 99 | 
100 |     # String vazia:
101 |     texto = ''
102 | 
103 |     # Bloco if:
104 |     if not texto:
105 |         print('A string é vazia!')
106 | 
107 | .. code-block:: console
108 | 
109 |     A string é vazia!
110 | 
111 | 
112 | 
113 | Boco if com else:    
114 | 
115 | .. code-block:: python
116 | 
117 |     # Objetos int:
118 |     x = 1
119 |     y = 2
120 | 
121 |     # Bloco if:
122 |     if x > y:
123 |         print('X é maior')
124 |     else:
125 |         print('Y é maior')
126 | 
127 | .. code-block:: python
128 | 
129 |     Y é maior
130 | 
131 | 
132 | 
133 | Bloco if com elif:    
134 | 
135 | .. code-block:: python
136 | 
137 |     # Objetos int:
138 |     y = 1
139 |     x = 1
140 | 
141 |     # Bloco if:
142 |     if x > y:
143 |         print('X é maior')
144 |     elif x < y:    
145 |         print('Y é maior')
146 |     else:    
147 |         print('Valores iguais')
148 | 
149 | .. code-block:: console
150 | 
151 |     Valores iguais
152 | 
153 | 
154 | 
155 | O valor de y depende de x:    
156 | 
157 | .. code-block:: python
158 | 
159 |     # Objeto int:
160 |     x = 10
161 | 
162 |     # Bloco if:    
163 |     if (x > 5):
164 |         y = 3
165 |     else:
166 |         y = 0
167 | 
168 |     # Exibe o resultado
169 |     print(y)
170 | 
171 | .. code-block:: console
172 | 
173 |     3
174 | 
175 | 
176 | 
177 | Operador Ternário
178 | ~~~~~~~~~~~~~~~~~
179 | 
180 | |   Um recurso bastante interessante em outras linguagens como em C, por exemplo.
181 | |   Seu objetivo é abreviar um bloco if em apenas uma linha.
182 | 
183 | **Sintaxe**:
184 | 
185 | |   `retorno_se_verdadeiro if condição else retorno_se_falso`
186 | 
187 | 
188 | 
189 | 
190 | Declaração de uma variável x com valor, atribui a y o resultado e exibe seu valor:
191 | 
192 | .. code-block:: python
193 | 
194 |     x = 10  # Variável int
195 | 
196 |     # Atribuição de valor condicional:
197 |     y = (50 if (x > 5) else 40)
198 | 
199 |     # Exibe o valor de "y":
200 |     print(y)
201 | 
202 | .. code-block:: console
203 | 
204 |     50
205 | 
206 | 
207 | 
208 | Variável float para receber a nota:    
209 | 
210 | .. code-block:: python
211 | 
212 |     nota = float(input('Digite a nota do aluno: '))
213 | 
214 | .. code-block:: console
215 | 
216 |     Digite a nota do aluno: 8
217 | 
218 | 
219 | 
220 | Atribuição condicional:
221 | 
222 | .. code-block:: python
223 | 
224 |     estado = 'aprovado' if nota >= 7 else 'reprovado'
225 | 
226 | 
227 | 
228 | Exibe a mensagem:
229 | 
230 | .. code-block:: python
231 | 
232 |     print(f'Aluno {estado}!')
233 | 
234 | .. code-block:: console
235 | 
236 |     Aluno aprovado!
237 | 
238 | 
239 | 
240 | Variável int:
241 | 
242 | .. code-block:: python
243 | 
244 |     num = int(input('Digite um número: '))
245 | 
246 | .. code-block:: console
247 | 
248 |     Digite um número: -2
249 | 
250 | 
251 | 
252 | Atribuição condicional:
253 | 
254 | .. code-block:: python
255 | 
256 |     sinal = 'positivo' if num > 0 else 'negativo' if num < 0 else 'zero'
257 | 
258 | 
259 | 
260 | Exibe mensagem:
261 | 
262 | .. code-block:: python
263 | 
264 |     print(f'O número é {sinal}'
265 | 
266 | .. code-block:: console
267 | 
268 |     O número é negativo


--------------------------------------------------------------------------------
/txt/test/teste_unitario.txt:
--------------------------------------------------------------------------------
  1 | import unittest
  2 | 
  3 | def soma(x, y):
  4 |     return x + y
  5 | 
  6 | 
  7 | def subtracao(x, y):
  8 |     return x - y
  9 | 
 10 | 
 11 | class TesteUnitario(unittest.TestCase):
 12 |     def teste_soma(self):
 13 |         self.assertEqual(7, soma(5, 2))
 14 | 
 15 | unittest.main()
 16 | 
 17 | 
 18 | .
 19 | ----------------------------------------------------------------------
 20 | Ran 1 test in 0.000s
 21 | 
 22 | OK
 23 | 
 24 | 
 25 | class TesteUnitario(unittest.TestCase):
 26 |     def teste_soma(self):
 27 |         self.assertEqual(9, soma(5, 2))
 28 | 
 29 | 
 30 | 
 31 | F
 32 | ======================================================================
 33 | FAIL: teste_soma (__main__.TesteUnitario)
 34 | ----------------------------------------------------------------------
 35 | Traceback (most recent call last):
 36 |   File "teste.py", line 13, in teste_soma
 37 |     self.assertEqual(9, soma(5, 2))
 38 | AssertionError: 9 != 7
 39 | 
 40 | ----------------------------------------------------------------------
 41 | Ran 1 test in 0.000s
 42 | 
 43 | FAILED (failures=1)
 44 | 
 45 | class TesteUnitario(unittest.TestCase):
 46 |     def teste_soma(self):
 47 |         self.assertEqual(9, soma(5, 2))
 48 | 
 49 |     def teste_subtracao(self):
 50 |         self.asserrtEqual(10, subtracao(2, 1))
 51 | 
 52 | FF
 53 | ======================================================================
 54 | FAIL: teste_soma (__main__.TesteUnitario)
 55 | ----------------------------------------------------------------------
 56 | Traceback (most recent call last):
 57 |   File "teste.py", line 13, in teste_soma
 58 |     self.assertEqual(9, soma(5, 2))
 59 | AssertionError: 9 != 7
 60 | 
 61 | ======================================================================
 62 | FAIL: teste_subtracao (__main__.TesteUnitario)
 63 | ----------------------------------------------------------------------
 64 | Traceback (most recent call last):
 65 |   File "teste.py", line 16, in teste_subtracao
 66 |     self.assertEqual(10, subtracao(2, 1))
 67 | AssertionError: 10 != 1
 68 | 
 69 | ----------------------------------------------------------------------
 70 | Ran 2 tests in 0.000s
 71 | 
 72 | FAILED (failures=2)
 73 | 
 74 | 
 75 | 
 76 | 
 77 | class TesteUnitario(unittest.TestCase):
 78 |     def teste_soma(self):
 79 |         self.assertEqual(9, soma(5, 2))
 80 | 
 81 |     def teste_subtracao(self):
 82 |         self.assertEqual(10, subtracao(2, 1))
 83 | 
 84 |     def teste_potencia(self):
 85 |         self.assertEqual(21, 3 ** 3)
 86 | 
 87 | 
 88 | 
 89 | FFF
 90 | ======================================================================
 91 | FAIL: teste_potencia (__main__.TesteUnitario)
 92 | ----------------------------------------------------------------------
 93 | Traceback (most recent call last):
 94 |   File "teste.py", line 19, in teste_potencia
 95 |     self.assertEqual(21, 3 ** 3)
 96 | AssertionError: 21 != 27
 97 | 
 98 | ======================================================================
 99 | FAIL: teste_soma (__main__.TesteUnitario)
100 | ----------------------------------------------------------------------
101 | Traceback (most recent call last):
102 |   File "teste.py", line 13, in teste_soma
103 |     self.assertEqual(9, soma(5, 2))
104 | AssertionError: 9 != 7
105 | 
106 | ======================================================================
107 | FAIL: teste_subtracao (__main__.TesteUnitario)
108 | ----------------------------------------------------------------------
109 | Traceback (most recent call last):
110 |   File "teste.py", line 16, in teste_subtracao
111 |     self.assertEqual(10, subtracao(2, 1))
112 | AssertionError: 10 != 1
113 | 
114 | ----------------------------------------------------------------------
115 | Ran 3 tests in 0.000s
116 | 
117 | FAILED (failures=3)
118 | 
119 | 
120 | class TesteUnitario(unittest.TestCase):
121 |     def teste_soma(self):
122 |         self.assertEqual(9, soma(5, 2))
123 | 
124 |     def teste_subtracao(self):
125 |         self.assertEqual(10, subtracao(2, 1))
126 | 
127 |     def teste_potencia(self):
128 |         self.assertEqual(27, 3 ** 3)
129 | 
130 | .FF
131 | ======================================================================
132 | FAIL: teste_soma (__main__.TesteUnitario)
133 | ----------------------------------------------------------------------
134 | Traceback (most recent call last):
135 |   File "teste.py", line 13, in teste_soma
136 |     self.assertEqual(9, soma(5, 2))
137 | AssertionError: 9 != 7
138 | 
139 | ======================================================================
140 | FAIL: teste_subtracao (__main__.TesteUnitario)
141 | ----------------------------------------------------------------------
142 | Traceback (most recent call last):
143 |   File "teste.py", line 16, in teste_subtracao
144 |     self.assertEqual(10, subtracao(2, 1))
145 | AssertionError: 10 != 1
146 | 
147 | ----------------------------------------------------------------------
148 | Ran 3 tests in 0.000s
149 | 
150 | FAILED (failures=2)
151 | 
152 | class TesteUnitario(unittest.TestCase):
153 |     def teste_soma(self):
154 |         self.assertEqual(7, soma(5, 2))
155 | 
156 |     def teste_subtracao(self):
157 |         self.assertEqual(1, subtracao(2, 1))
158 | 
159 |     def teste_potencia(self):
160 |         self.assertEqual(27, 3 ** 3)
161 | 
162 | ...
163 | ----------------------------------------------------------------------
164 | Ran 3 tests in 0.000s
165 | 
166 | OK
167 | 


--------------------------------------------------------------------------------
/source/content/about.rst:
--------------------------------------------------------------------------------
  1 | Sobre Python
  2 | ************
  3 | 
  4 | O que é Python
  5 | --------------
  6 | 
  7 | 	Python é uma linguagem de programação criada pelo holandês Guido van Rossum no começo dos anos 90 na Stichting Mathematisch Centrum (http://www.cwi.nl/), na Holanda, com o objetivo de ser uma sucessora de uma linguagem chamada ABC.
  8 | 	O nome linguagem foi inspirado na série humorística Monty Python's Flying Circus, do grupo humorístico britânico Monty Python. 
  9 | 	É muito atrativa para desenvolvimento ágil de aplicações.
 10 | 
 11 | 	Site oficial: www.python.org
 12 | 	Site da comunidade brasileira: www.python.org.br
 13 | 
 14 | Características
 15 | ~~~~~~~~~~~~~~~
 16 | 
 17 | - Linguagem de altíssimo nível;
 18 | - Fácil de aprender;
 19 | - Simples;
 20 | - Objetiva;
 21 | - Preza pela legibilidade;
 22 | - Case sensitive;
 23 | - Mutiparadigma: orientada a objeto e procedural;
 24 | - Interpretada;
 25 | - Compilada (transparente ao usuário);
 26 | - Tipagem forte;
 27 | - Tipagem dinâmica;
 28 | - Suporte a módulos e packages encorajando modularidade e reúso de código;
 29 | - Multiplataforma (Linux, MacOS, BSDs, Windows e outros);
 30 | - Não suporte sobrecarga de funções;
 31 | - Blocos delimitados por endentação (ou espaços ou tabs: não misturar!);
 32 | - Um comando por linha (podem ser colocados mais que um após um ";", mas não é uma saída elegante);
 33 | - Possui modo interativo;
 34 | - Software Livre.
 35 | 
 36 | Licença
 37 | ~~~~~~~
 38 | 
 39 | 	Python utiliza uma licença similar à licença BSD, a PSF License (Python Software Foundation License).
 40 | 	É um tipo de licença muito permissiva e compatível com a licença GPL.
 41 | 	É tão permissiva que permite ao usuário escolher em manter ou não o código-fonte aberto.
 42 | 	Mesmo empresas que pegam o código-fonte de um projeto sob essa licença, quando o fecham e derivam então gerando um software proprietário, acabam colaborando com o projeto original firmando assim uma parceria em que ambos saem ganhando.
 43 | 	É o mesmo tipo de licença adotado por outros projetos de software livre como: PostgreSQL, FreeBSD, OpenBSD, NetBSD.
 44 | 
 45 | O Interpretador Python
 46 | ----------------------
 47 | 	Como o próprio nome diz, é o interpretador que faz a análise sintática e executa as instruções Python.
 48 | 
 49 | Modo Interativo do Interpretador Python
 50 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 51 | 
 52 | 	O modo interativo de Python é um recurso interessante que facilita o trabalho do desenvolvedor de forma que se possa testar algo que esteja fazendo assim que o comando é finalizado.
 53 | 	É um recurso muito útil para debugging, quick hacking e testes.	
 54 | 
 55 | Invocando o Modo Interativo do Interpretador
 56 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 57 | 
 58 | 	A maioria das distribuições Linux tem já o Python instalado, de forma que para ter acesso ao prompt interativo bastar digitar no terminal o comando python.
 59 | 	Para sair do interpretador basta digitar o caractere de fim de arquivo (EOF - End-Of-File) (<Ctrl + D> em Unix ou <Ctrl + Z> no Windows). Também pode-se usar as funções exit() ou quit().
 60 | 
 61 | A Filosofia de Python
 62 | ---------------------
 63 | 
 64 | 	Há um easter egg em Python bem divertido que exprime bem a filosofia de Python, que é conhecido como The Zen Of Python.
 65 | 	The Zen Of Python é a PEP 20, PEP que significa Python Enhancement Proposals (Propostas de Melhoria para Python).
 66 | 	Para visualizar esse easter egg basta que no shell interativo dê o seguinte comando:
 67 | 
 68 | .. code-block:: python
 69 |     
 70 |     import this
 71 | 
 72 | .. code-block:: console
 73 | 
 74 |     The Zen of Python, by Tim Peters
 75 | 
 76 |     Beautiful is better than ugly.
 77 |     Explicit is better than implicit.
 78 |     Simple is better than complex.
 79 |     Complex is better than complicated.
 80 |     Flat is better than nested.
 81 |     Sparse is better than dense.
 82 |     Readability counts.
 83 |     Special cases aren't special enough to break the rules.
 84 |     Although practicality beats purity.
 85 |     Errors should never pass silently.
 86 |     Unless explicitly silenced.
 87 |     In the face of ambiguity, refuse the temptation to guess.
 88 |     There should be one-- and preferably only one --obvious way to do it.
 89 |     Although that way may not be obvious at first unless you're Dutch.
 90 |     Now is better than never.
 91 |     Although never is often better than *right* now.
 92 |     If the implementation is hard to explain, it's a bad idea.
 93 |     If the implementation is easy to explain, it may be a good idea.
 94 |     Namespaces are one honking great idea -- let's do more of those!
 95 | 
 96 | Tradução:
 97 | 
 98 | .. code-block:: console
 99 | 
100 | 
101 |     O Zen de Python, por Tim Peters
102 | 
103 |     Bonito é melhor do que feio.
104 |     Explícito é melhor do que implícito.
105 |     Simples é melhor do que complexo.
106 |     Complexo é melhor do que complicado.
107 |     Plano é melhor do que aninhado.
108 |     Disperso é melhor do que denso.
109 |     Legibilidade conta.
110 |     Casos especiais não são especiais o bastante para quebrar as regras.
111 |     Embora a praticidade vença a pureza.
112 |     Erros não devem passar silenciosamente.
113 |     A não ser que sejam explicitamente silenciados.
114 |     Diante a ambigüidade, recuse a tentação de adivinhar.
115 |     Deve haver um-- e preferencialmente apenas um --modo óbvio de fazer isso.
116 |     Embora a maneira não seja óbvia à primeira vista, a menos que seja holandês.
117 |     Agora é melhor do que nunca.
118 |     Embora nunca é muitas vezes melhor do que *agora* mesmo
119 |     Se a implementação é difícil de explicar, é uma má idéia.
120 |     Se a implementação é fácil de explicar, deve ser uma boa idéia.
121 |     Namespaces são uma idéia fantástica – vamos fazer mais desses!


--------------------------------------------------------------------------------
/source/content/loops.rst:
--------------------------------------------------------------------------------
  1 | Loops - Laços de Repetição
  2 | **************************
  3 | 
  4 | while
  5 | -----
  6 | 
  7 | |   Executa em laço (loop) **enquanto** a condição for verdadeira.
  8 | 
  9 | 
 10 | 
 11 | Enquanto i for menor que 5, exiba i:
 12 | 
 13 | .. code-block:: python
 14 | 
 15 |     i = 0
 16 | 
 17 |     while i < 5:
 18 |         print(i)
 19 |         i += 1
 20 | 
 21 | .. code-block:: console
 22 | 
 23 |     0
 24 |     1
 25 |     2
 26 |     3
 27 |     4
 28 | 
 29 | 
 30 | 
 31 | O else no loop while
 32 | ~~~~~~~~~~~~~~~~~~~~
 33 | 
 34 | |   Opcionalmente, pode-se adicionar um else ao while em Python.
 35 | |   A idéia é que se caso o loop seja executado sem interrupção, um break, por exemplo, o que estiver dentro do bloco else será executado.
 36 | 
 37 | 
 38 | 
 39 | Loop while com else sem interrupção:
 40 | 
 41 | .. code-block:: python
 42 | 
 43 |     i = 0
 44 |     while i < 5:
 45 |         print(i)
 46 |         i += 1
 47 |     else:   
 48 |         print('Fim')
 49 | 
 50 | .. code-block:: console
 51 | 
 52 |     0
 53 |     1
 54 |     2
 55 |     3
 56 |     4
 57 |     Fim
 58 | 
 59 | 
 60 | 
 61 | Loop while com else com interrupção (break):
 62 | 
 63 | .. code-block:: python
 64 | 
 65 |     i = 0
 66 | 
 67 |     while i <= 10:
 68 |         if i == 5: break       
 69 |         print(i)
 70 |         i += 1
 71 |     else:   
 72 |         print('Fim')
 73 | 
 74 | .. code-block:: console
 75 | 
 76 |     0
 77 |     1
 78 |     2
 79 |     3
 80 |     4
 81 | 
 82 | 
 83 | 
 84 | Loop while com else e sem break:
 85 | 
 86 | .. code-block:: python
 87 | 
 88 |     i = 0
 89 | 
 90 |     while i <= 10:
 91 |         if (i % 2 == 0): 
 92 |             i += 1
 93 |             continue
 94 |         print(i)
 95 |         i += 1        
 96 |     else:   
 97 |         print('Fim')
 98 | 
 99 | .. code-block:: console
100 | 
101 |     1
102 |     3
103 |     5
104 |     7
105 |     9
106 |     Fim
107 | 
108 | 
109 | 
110 | Loop Infinito
111 | ~~~~~~~~~~~~~
112 | 
113 | |   Em determinadas situações se faz necessário o uso de um loop sem fim.
114 | |   Para que esse loop infinito seja rompido é preciso que uma ação externa ocorra, como uma interrupção com a combinação de teclas <Ctrl> + C.
115 | 
116 | 
117 | 
118 | Enquanto não houver uma interrupção externa, o loop abaixo exibirá "x" eternamente:
119 | 
120 | .. code-block:: python
121 | 
122 |     while True:
123 |         print('x')
124 | 
125 | .. code-block:: console
126 | 
127 |     x
128 |     x
129 |     x
130 |     . . .
131 | 
132 | 
133 | 
134 | for
135 | ~~~
136 | 
137 | |   O loop for interage sobre cada membro de um objeto iterável.
138 | 
139 | 
140 | 
141 | Um simples loop for com a função range:
142 | 
143 | .. code-block:: python
144 | 
145 |     for i in range(5):
146 |         print(i)
147 | 
148 | .. code-block:: console
149 | 
150 |     0
151 |     1
152 |     2
153 |     3
154 |     4
155 | 
156 | 
157 | 
158 | Loop sobre os elementos de uma tupla:
159 | 
160 | .. code-block:: python
161 | 
162 |     lor = ('Gandalf', 'Bilbo', 'Frodo', 'Sauron', 'Aragorn', 'Legolas')
163 | 
164 |     for i in lor:
165 |         print(i)
166 | 
167 | .. code-block:: console
168 | 
169 |     Gandalf
170 |     Bilbo
171 |     Frodo
172 |     Sauron
173 |     Aragorn
174 |     Legolas
175 | 
176 | 
177 | 
178 | Loop sobr os elementos da tupla enumerados:
179 | 
180 | .. code-block:: python
181 | 
182 |     for i, personagem in enumerate(lor):
183 |         print(f'{i} - {personagem}')
184 | 
185 | .. code-block:: console
186 | 
187 |     0 - Gandalf
188 |     1 - Bilbo
189 |     2 - Frodo
190 |     3 - Sauron
191 |     4 - Aragorn
192 |     5 - Legolas
193 | 
194 | 
195 | 
196 | Enumerando a tupla e convertendo-a para uma lista:
197 | 
198 | .. code-block:: python
199 | 
200 |     list(enumerate(lor))
201 | 
202 | .. code-block:: console
203 | 
204 |     [(0, 'Gandalf'), (1, 'Bilbo'), (2, 'Frodo'), (3, 'Sauron'), (4, 'Aragorn'), (5, 'Legolas')]
205 | 
206 | 
207 | 
208 | Lista cujos elementos são tuplas cujos elementos representam chave e valor, e por fim loop:
209 | 
210 | .. code-block:: python
211 | 
212 |     dados =  [('Nome', 'Chiquinho'), ('Sobrenome', 'da Silva'), ('Idade', 50)]
213 | 
214 |     for k, v in dados:
215 |         print(f'{k}: {v}')
216 | 
217 | .. code-block:: console
218 | 
219 |     Nome: Chiquinho
220 |     Sobrenome: da Silva
221 |     Idade: 50
222 | 
223 | 
224 | 
225 | Criação de um dicionário:
226 | 
227 | .. code-block:: python
228 | 
229 |     dados = {
230 |         'Nome': 'Chiquinho',
231 |         'Sobrenome': 'da Silva',
232 |         'Idade': 50
233 |     }
234 | 
235 | 
236 | 
237 | Loop sobre um dicionário:
238 | 
239 | .. code-block:: python
240 | 
241 |     for k, v in dados.items():
242 |         print(f'{k}: {v}')
243 | 
244 | .. code-block:: console
245 | 
246 |     Sobrenome: da Silva
247 |     Idade: 50
248 |     Nome: Chiquinho
249 | 
250 | 
251 | 
252 | Loop for com else e sem interrupção:
253 | 
254 | .. code-block:: python
255 | 
256 |     for i in range(5):
257 |         print(i)
258 |     else:
259 |         print('Fim')
260 | 
261 | .. code-block:: console
262 | 
263 |     0
264 |     1
265 |     2
266 |     3
267 |     4
268 |     Fim
269 | 
270 | 
271 | 
272 | Loop for com else e com interrupção:
273 | 
274 | .. code-block:: python
275 | 
276 |     for i in range(10):
277 |         if i == 6:
278 |             break
279 |         print(i)
280 |     else:
281 |         print('Fim')
282 | 
283 | .. code-block:: console
284 | 
285 |     0
286 |     1
287 |     2
288 |     3
289 |     4
290 |     5
291 | 
292 | 
293 | 
294 | Loop for com else e sem interrupção:
295 | 
296 | .. code-block:: python
297 | 
298 |     for i in range(10):
299 |         if i % 2 == 0:
300 |             continue
301 |         print(i)
302 |     else:
303 |         print('Fim')
304 | 
305 | .. code-block:: console
306 | 
307 |     1
308 |     3
309 |     5
310 |     7
311 |     9
312 |     Fim


--------------------------------------------------------------------------------
/source/content/date_time.rst:
--------------------------------------------------------------------------------
  1 | Data e Hora
  2 | ***********
  3 | 
  4 | O Módulo datetime
  5 | -----------------
  6 | 
  7 | Módulo que fornece classes para manipular datas e horas de maneiras simples e
  8 | complexas.
  9 | Enquanto data e hora são suportados aritmeticamente, o foco da implementação
 10 | estã em uma extração eficiente de atributo para saída formatada e manipulação.
 11 | 
 12 | 
 13 | 
 14 | .. code-block:: python
 15 | 
 16 |     # Imports:
 17 |     from datetime import date
 18 |     from datetime import datetime
 19 |     from sys import getsizeof
 20 | 
 21 | 
 22 | .. code-block:: python
 23 | 
 24 |     # Inserir dados via teclado conforme sugere o modelo na mensagem:
 25 |     dt_evento = input('Digite a data e hora do evento (AAAA-MM-DD HH:MM): ')
 26 | 
 27 | .. code-block:: console
 28 | 
 29 |     Digite a data e hora do evento (AAAA-MM-DD HH:MM):
 30 | 
 31 | .. code-block:: python
 32 | 
 33 |     # Verificando o tipo da variável:
 34 |     type(dt_evento)
 35 | 
 36 | .. code-block:: console
 37 | 
 38 |     str
 39 | 
 40 | .. code-block:: python
 41 | 
 42 |     # Quanto custa essa variável em bytes?:
 43 |     getsizeof(dt_evento)
 44 | 
 45 | .. code-block:: console
 46 | 
 47 |     65
 48 | 
 49 | 
 50 | | Strings não são adequadas para armazenar data e hora.
 51 | | strptime transforma uma string para datetime conforme uma dada máscara:
 52 | 
 53 | 
 54 | 
 55 | .. code-block:: python
 56 | 
 57 |     # Converter a string para datetime:
 58 |     datetime.strptime(dt_evento, '%Y-%m-%d %H:%M')
 59 | 
 60 | .. code-block:: console
 61 | 
 62 |     datetime.datetime(2019, 12, 27, 19, 0)
 63 | 
 64 | 
 65 | **strptime: str -> datetime**
 66 | 
 67 | 
 68 | .. code-block:: python
 69 | 
 70 |     # O tamanho em bytes do dado em datetime:
 71 |     getsizeof(datetime.strptime(dt_evento, '%Y-%m-%d %H:%M'))
 72 | 
 73 | .. code-block:: console
 74 | 
 75 |     48
 76 | 
 77 | A mesma informação armazenada como datetime ocupa menos espaço que string.
 78 | 
 79 | .. code-block:: python
 80 | 
 81 |     # Recriar a variável como datetime utilizando seu valor antigo de string:
 82 |     dt_evento = datetime.strptime(dt_evento, '%Y-%m-%d %H:%M')
 83 | 
 84 |     # Verificando o tipo:
 85 |     type(dt_evento)
 86 | 
 87 | .. code-block:: console
 88 | 
 89 |     datetime.datetime
 90 | 
 91 | 
 92 | 
 93 | Pode ser necessário também fazer o caminho inverso, para transformar um dado datetime para string.
 94 | 
 95 |     Para isso pode-se usar strftime:
 96 | 
 97 | .. code-block:: python
 98 | 
 99 |     # Extrair como string de um dado datetime:
100 |     datetime.strftime(dt_evento, '%Y-%m-%d %H:%M')
101 | 
102 | .. code-block:: console
103 | 
104 |     '2019-12-27 19:00'
105 | 
106 | **strftime: datetime -> str**    
107 | 
108 | .. code-block:: python
109 | 
110 |     # Variável que contém apenas a data atual:
111 |     hoje = date.today()
112 | 
113 |     # Exibindo o valor da variável:
114 |     print(hoje)
115 | 
116 | .. code-block:: console
117 | 
118 |     2019-12-26
119 | 
120 | Exibindo apenas partes da data:    
121 | 
122 | .. code-block:: python
123 | 
124 |     # dia:
125 |     print(hoje.day)
126 | 
127 | .. code-block:: console
128 | 
129 |     26
130 | 
131 | .. code-block:: python
132 | 
133 |     # mês:
134 |     print(hoje.month)
135 | 
136 | .. code-block:: console
137 | 
138 |     12
139 | 
140 | .. code-block:: python
141 | 
142 |     # ano:
143 |     print(hoje.year)
144 | 
145 | .. code-block:: console
146 | 
147 |     2019
148 | 
149 | .. code-block:: python
150 | 
151 |     # Formato ISO:
152 |     hoje.isoformat()
153 | 
154 | .. code-block:: console
155 | 
156 |     '2019-12-26'
157 | 
158 | .. code-block:: python
159 | 
160 |     # Método toordinal; retorna a quantidade de dias 
161 |     # passados desde 01/01/0001:
162 |     hoje.toordinal()
163 | 
164 | .. code-block:: console
165 | 
166 |     737419
167 | 
168 | .. code-block:: python
169 | 
170 |     # Método fromordinal; retorna a data a partir da quantidade 
171 |     # de dias passados desde 01/01/0001:
172 |     date.fromordinal(737419)
173 | 
174 | .. code-block:: console
175 | 
176 |     datetime.date(2019, 12, 26)
177 | 
178 | .. code-block:: python
179 | 
180 |     # Que dia será daqui a 40 dias?:
181 |     date.fromordinal(hoje.toordinal() + 40)   # formato datetime.date
182 | 
183 | .. code-block:: console
184 | 
185 |     datetime.date(2020, 2, 4)
186 | 
187 | .. code-block:: python
188 | 
189 |     # Formato ISO:
190 |     date.fromordinal(hoje.toordinal() + 40).isoformat()
191 | 
192 | .. code-block:: console
193 | 
194 |     '2020-02-04'
195 | 
196 | .. code-block:: python
197 | 
198 |     # Método weekday (dia da semana), em que segunda-feira = 0 e domingo = 6:
199 |     hoje.weekday()
200 | 
201 | .. code-block:: console
202 | 
203 |     3
204 | 
205 | .. code-block:: python
206 | 
207 |     # Método isoweekday, em que segunda-feira = 1 e domingo = 7
208 |     hoje.isoweekday()
209 | 
210 | .. code-block:: console
211 | 
212 |     4
213 | 
214 | 
215 | O Módulo time
216 | -------------
217 | 
218 |  |   Módulo cujos objetos representam uma hora (local) de dia, independente de
219 |  | qualquer dia em particular, e sujeito a ajustes via um objeto tzinfo.
220 |  |   Fornece várias funções para manipular valores de hora. Não confundir com 
221 |  | a classe time do módulo datetime.
222 | 
223 | .. code-block:: python
224 | 
225 |     # Imports:
226 |     from time import ctime
227 |     from time import sleep
228 |     from time import time
229 |     from time import tzname    
230 | 
231 | .. code-block:: python
232 | 
233 |     # Criação de função que espera n segundos e exibe uma mensagem no final:
234 |     def espera(tempo):
235 |         sleep(tempo)
236 |         print(f'Passaram-se {tempo} segundos')
237 | 
238 | .. code-block:: python
239 | 
240 |     # Execução da função:
241 |     espera(3)
242 | 
243 | .. code-block:: console
244 | 
245 |     Passaram-se 3 segundos
246 | 
247 | .. code-block:: python
248 | 
249 |     # time.time retorna o tempo atual em segundos 
250 |     # desde Epoch (01/01/1970 00:00:00):
251 |     time()
252 | 
253 | .. code-block:: console
254 | 
255 |     1577375404.8968937
256 | 
257 | .. code-block:: python
258 | 
259 |     # Converte um tempo em segundos desde Epoch para uma string, 
260 |     # se nenhum parâmetro for passado retorna string do momento atual:
261 |     ctime()
262 | 
263 | .. code-block:: console
264 | 
265 |     'Thu Dec 26 12:50:22 2019'
266 | 
267 | .. code-block:: python
268 | 
269 |     ctime(1540000000)
270 | 
271 | .. code-block:: console
272 | 
273 |     'Fri Oct 19 22:46:40 2018'


--------------------------------------------------------------------------------
/source/content/numeric_data_types.rst:
--------------------------------------------------------------------------------
  1 | Tipos Numéricos - int, float e complex
  2 | **************************************
  3 | 
  4 | int
  5 | ---
  6 | 
  7 | 	Para representação de todos números inteiros é o tipo int.
  8 | 	A princípio utilizamos para números inteiros o tipo int. O número máximo de int que é aceito pode variar de uma máquina para outra.
  9 | 	Para sabermos qual é o número máximo do tipo int fazemos:
 10 | 
 11 | 
 12 | .. code-block:: python
 13 | 
 14 |     # Objeto inteiro:
 15 |     i = int(7)
 16 | 
 17 | ou
 18 | 
 19 | .. code-block:: python
 20 | 
 21 |     i = 7
 22 | 
 23 | .. code-block:: python
 24 | 
 25 |     # Verificando seu valor:
 26 |     i
 27 | 
 28 | .. code-block:: console
 29 | 
 30 |     7
 31 | 
 32 | .. code-block:: python
 33 | 
 34 |     # Verificando seu tipo:
 35 |     type(i)
 36 | 
 37 | .. code-block:: console
 38 | 
 39 |     int
 40 | 
 41 | .. code-block:: python
 42 | 
 43 |     # Tipo de "bar":
 44 |     type(bar)
 45 | 
 46 | .. code-block:: console
 47 | 
 48 |     long
 49 | 
 50 | .. code-block:: python
 51 | 
 52 |     # Representação hexadecimal de 178
 53 |     0xb2
 54 | 
 55 | .. code-block:: console
 56 | 
 57 |     178
 58 | 
 59 | .. code-block:: python
 60 | 
 61 |     # Representação octal de 8:
 62 |     0o10
 63 | 
 64 | .. code-block:: console
 65 | 
 66 |     8
 67 | 
 68 | .. code-block:: python
 69 | 
 70 |     # Representação binária de 14:
 71 |     0b1110
 72 | 
 73 | .. code-block:: console
 74 | 
 75 |     14
 76 | 
 77 | .. code-block:: python
 78 | 
 79 |     # Número 7 (sete) convertido para as bases 
 80 |     # binária, hexadecimal e octal respectivamente:
 81 |     bin(7)
 82 | 
 83 | .. code-block:: console
 84 | 
 85 |     '0b111'
 86 | 
 87 | .. code-block:: python
 88 | 
 89 |     # Retorna a forma octal de 7:
 90 |     oct(7)
 91 | 
 92 | .. code-block:: console
 93 | 
 94 |     '0o7'
 95 | 
 96 | .. code-block:: python
 97 | 
 98 |     # Retorna a versão hexadecimal de 7:
 99 |     hex(7)
100 | 
101 | .. code-block:: console
102 | 
103 |     '0x7'
104 | 
105 | .. code-block:: python
106 | 
107 |     # Descobrir o decimal dada uma base:
108 |     int('facada', base=16)
109 | 
110 | .. code-block:: console
111 | 
112 |     16435930
113 | 
114 | .. code-block:: python
115 | 
116 |     # 25 octal em decimal é:
117 |     int('25', base=8)
118 | 
119 | .. code-block:: console
120 | 
121 |     21
122 | 
123 | .. code-block:: python
124 | 
125 |     # 1111 binário é em decimal:
126 |     int('1111', base=2)
127 | 
128 | .. code-block:: console
129 | 
130 |     15
131 | 
132 | 
133 | float
134 | -----
135 | 
136 | 	Ponto flutuante; não tem precisão absoluta, sua precisão é relativa.
137 | 	Para uma maior precisão com números que tenham ponto flutuante, utilizar o módulo decimal.
138 | 
139 | 
140 | 
141 | .. code-block:: python
142 | 
143 |     # Criação de um float:
144 |     f = float(3)
145 | 
146 | ou
147 | 
148 | .. code-block:: python
149 | 
150 |     f = 3.0
151 | 
152 | .. code-block:: python
153 | 
154 |     f  # Veririca o valor
155 | 
156 | .. code-block:: console
157 | 
158 |     3.0
159 | 
160 | Formas de se definir um float:
161 | 
162 | .. code-block:: python
163 | 
164 | 	x = 0.5000000000
165 | 
166 | ou
167 | 
168 | .. code-block:: python
169 | 
170 | 	x = 0.5
171 | 
172 | ou
173 | 
174 | .. code-block:: python
175 | 
176 | 	x = .5
177 | 
178 | 	x  # Exibe o valor
179 | 
180 | .. code-block:: console
181 | 
182 |     0.5
183 | 
184 | .. code-block:: python
185 | 
186 |     type(x)  # Tipo
187 | 
188 | .. code-block:: console
189 | 
190 |     float
191 | 
192 | .. code-block:: python
193 | 
194 | 	x = 2.
195 | 
196 | 	x  # Verifica o valor
197 | 
198 | .. code-block:: console
199 | 
200 |     2.0
201 | 
202 | .. code-block:: python
203 | 
204 |     # Que tipo resulta de da soma de um inteiro e um float?:
205 | 	type(7 + 3.0)
206 | 
207 | .. code-block:: console
208 | 
209 |     float
210 | 
211 | 
212 | .. code-block:: python
213 | 
214 |     # Resultado:
215 |     7 + 3.0
216 | 
217 | .. code-block:: console
218 | 
219 |     10.0
220 | 
221 | 
222 | .. code-block:: python
223 | 
224 |     # Divisão:
225 |     3 / 2
226 | 
227 | ou
228 | 
229 | .. code-block:: python
230 | 
231 |     3 / 2.0
232 | 
233 | ou
234 | 
235 | .. code-block:: python
236 | 
237 |     3.0 / 2
238 | 
239 | ou
240 | 
241 | .. code-block:: python
242 | 
243 |     3.0 / 2.0
244 | 
245 | .. code-block:: console
246 | 
247 |     1.5
248 | 
249 | .. code-block:: python
250 | 
251 |     # Divisão Inteira:
252 |     3 // 2.0
253 | 
254 | .. code-block:: console
255 | 
256 |     1.0
257 | 
258 | .. code-block:: python
259 | 
260 |     # Notação Científica:
261 |     1e+2
262 | 
263 | .. code-block:: console
264 | 
265 |     100.0
266 | 
267 | .. code-block:: python
268 | 
269 |     # Notação científica com expoente negativo:
270 |     1e-3
271 | 
272 | .. code-block:: console
273 | 
274 |     0.001
275 | 
276 | complex
277 | -------
278 | 
279 |     É o tipo de dados em Python que trata de números complexos, que são muito utilizados em engenharia elétrica.
280 | 
281 | .. code-block:: python
282 | 
283 |     # Número complexo somente com a parte real:
284 |     c = complex(1)
285 |     print(c)
286 | 
287 | .. code-block:: console
288 | 
289 |     (1+0j)
290 | 
291 | .. code-block:: python
292 | 
293 |     # Verificando seu valor e seu tipo:
294 |     type(c)
295 | 
296 | .. code-block:: console
297 | 
298 |     complex
299 | 
300 | .. code-block:: python
301 | 
302 |     # Novo valor do número complexo com parte real e imaginária:
303 |     c = complex(5, 3)
304 | 
305 | .. code-block:: python
306 | 
307 | 	c  # Verificando o valor
308 | 
309 | .. code-block:: console
310 | 
311 |     (5+3j)
312 | 
313 | 
314 | .. code-block:: python
315 | 
316 |     # Número complexo somente com a parte imaginária:
317 |     c = complex(0, 3)
318 | 
319 | .. code-block:: python
320 | 
321 | 	c  # Verificando seu valor
322 | 
323 | .. code-block:: console
324 | 
325 |     3j
326 | 
327 | .. code-block:: python
328 | 
329 | 	c.imag  # Extraindo somente a parte imaginária
330 | 
331 | .. code-block:: console
332 | 
333 |     3.0
334 | 
335 | .. code-block:: python
336 | 
337 | 	c.real  # Extraindo somente a parte real
338 | 
339 | .. code-block:: console
340 | 
341 |     0.0
342 | 
343 | .. code-block:: python
344 | 
345 | 	c + 1  # Somando o número com a parte real
346 | 
347 | .. code-block:: console
348 | 
349 |     (1+3j)
350 | 
351 | .. code-block:: python
352 | 
353 | 	c + complex('7j')  # Somando o número com a parte imaginária
354 | 
355 | .. code-block:: console
356 | 
357 |     10j
358 | 
359 | .. code-block:: python
360 | 
361 | 	c + complex(2, 17)  # somando o número complexo com outro complexo
362 | 
363 | .. code-block:: console
364 | 
365 |     (2+20j)
366 | 


--------------------------------------------------------------------------------
/source/content/decorators.rst:
--------------------------------------------------------------------------------
  1 | Decoradores em Python
  2 | *********************
  3 | 
  4 |     É um conceito diferente do conceito decorator de design pattern.
  5 |     Pode ser implementado como uma classe ou como uma função.
  6 |     Modificam funções.
  7 |     É identificado da seguinte forma: @nome_do_decorador.
  8 |     Deve ser inserido na linha anterior da definição.
  9 |     Um decorador deve ser executável, ou seja, deve ter o método __call__().
 10 |     São envelopes de função.
 11 |     Decoradores podem ser definidos como classes ou funções.
 12 | 
 13 | Decoradores de Funções
 14 | ----------------------
 15 | 
 16 | Classe como decorador:
 17 | 
 18 | .. code-block:: python
 19 | 
 20 |     class Decorador(object):
 21 |         
 22 |         def __init__(self, funcao):
 23 |             '''        
 24 |             O parâmetro "funcao" é a função que será decorada.
 25 |             '''
 26 | 
 27 |             print('Método __init__() do decorador')  # Mensagem ao instanciar
 28 |             funcao()  # Executa a função ao instanciar
 29 |         
 30 |         def __call__(self):    
 31 |             print('Método __call__() do decorador')
 32 | 
 33 | 
 34 | 
 35 | Definição da classe com decorador:
 36 |       
 37 | .. code-block:: python
 38 | 
 39 |     @Decorador
 40 |     def funcao_decorada():
 41 |         print('Dentro da função decorada')
 42 | 
 43 | 
 44 | .. code-block:: console
 45 | 
 46 |     Método __init__() do decorador
 47 |     Dentro da função decorada
 48 | 
 49 | O método construtor do decorador é invocado logo após da definição da função
 50 | decorada.
 51 | No exemplo, a própria função, que é usada como parâmetro, é invocada pelo
 52 | método construtor __init__().
 53 | 
 54 | 
 55 | 
 56 | Execução da função decorada:
 57 | 
 58 | .. code-block:: python
 59 | 
 60 |     funcao_decorada()
 61 | 
 62 | .. code-block:: console
 63 | 
 64 |     Método __call__() do decorador
 65 | 
 66 | 
 67 | 
 68 | Recriação da classe decoradora:
 69 | 
 70 | .. code-block:: python
 71 | 
 72 |     class Decorador(object):
 73 |         def __init__(self, funcao):
 74 |             print('Método __init__() do decorador')
 75 |             self.funcao = funcao
 76 | 
 77 |         def __call__(self):        
 78 |             print('Método __call__() do decorador')
 79 |             self.funcao()
 80 | 
 81 | Diferente da criação da classe anteriormente, aqui a função não é chamada
 82 | no método construtor, mas sim no método __call__.
 83 | 
 84 | 
 85 | 
 86 | Definição da função decorada:
 87 | 
 88 | .. code-block:: python
 89 | 
 90 |     @Decorador
 91 |     def funcao_decorada():
 92 |         print('Dentro da função')
 93 | 
 94 | .. code-block:: console
 95 | 
 96 |     Método __init__() do decorador
 97 | 
 98 | 
 99 | 
100 | Execução da função decorada:
101 | 
102 | .. code-block:: python
103 | 
104 |     funcao_decorada()
105 | 
106 | .. code-block:: console
107 | 
108 |     Método __call__() do decorador
109 |     Dentro da função
110 | 
111 | 
112 | 
113 | Decorador com Argumentos
114 | ------------------------
115 | 
116 |     Para funções decoradas que têm argumentos.
117 | 
118 | 
119 | 
120 | Criação da classe decoradora:
121 | 
122 | .. code-block:: python
123 | 
124 |     class Decorador():
125 | 
126 |         def __init__(self, f):
127 |             print('Método __init__() do decorador')
128 |             self.f = f
129 | 
130 |         def __call__(self, *args, **kargs):        
131 |             print('Método __call__() do decorador')
132 |             return self.f(*args, **kargs)
133 | 
134 | 
135 | 
136 | Definição da classe decorada:
137 | 
138 | .. code-block:: python
139 | 
140 |     @Decorador
141 |     def soma(x, y):
142 |         return x + y
143 | 
144 | 
145 | 
146 | Execução da classe decorada:
147 | 
148 | .. code-block:: python
149 | 
150 |     print(soma(2, 5))
151 | 
152 | .. code-block:: console
153 | 
154 |     Método __call__() do decorador
155 |     7
156 | 
157 | 
158 | 
159 | Função como Decorador
160 | ---------------------
161 | 
162 |     Até então foram vistos exemplos de decoradores definidos como classes, agora serão vistos os definidos como função.
163 | 
164 | 
165 | 
166 | Criação da função decoradora, o decorador em si:
167 | 
168 | .. code-block:: python
169 | 
170 |     def funcao_decoradora(funcao):
171 |     
172 |         # Função auxiliar
173 |         def funcao_auxiliar():
174 |         print('Antes da função decorada')
175 |         funcao()
176 |         print('Depois da função decorada')
177 |         
178 |         return funcao_auxiliar
179 | 
180 | 
181 | 
182 | Definição da função decorada:
183 | 
184 | .. code-block:: python
185 | 
186 |     @funcao_decoradora
187 |     def foo():
188 |         print('Função decorada')
189 | 
190 | 
191 | 
192 | Execução da função decorada:
193 |   
194 | .. code-block:: python
195 | 
196 |     foo() 
197 | 
198 | .. code-block:: console
199 | 
200 |     Antes da função decorada
201 |     Função decorada
202 |     Depois da função decorada
203 | 
204 | 
205 | 
206 | Podemos também aplicar mais de um decorador a uma função:
207 | 
208 | .. code-block:: python
209 | 
210 |     # Função para itálico em HTML
211 |     def to_italic(funcao):
212 |         def funcao_auxiliadora(*args, **kargs):
213 |             return '<i>' + funcao(*args, **kargs) + '</i>'
214 |         return funcao_auxiliadora
215 | 
216 |     # Função para negrito em HTML
217 |     def to_bold(funcao):
218 |         def funcao_auxiliadora(*args, **kargs):
219 |             return '<b>' + funcao(*args, **kargs) + '</b>'
220 |         return funcao_auxiliadora
221 | 
222 | 
223 | 
224 | Definição da função decorada com dois decoradores:
225 | 
226 | .. code-block:: python
227 | 
228 |     @to_italic
229 |     @to_bold
230 |     def fc_msg(msg):
231 |         return msg
232 | 
233 | 
234 | 
235 | Execução da função decorada:
236 | 
237 | .. code-block:: python
238 | 
239 |     fc_msg('Hello, World!')
240 | 
241 | .. code-block:: console
242 | 
243 |     '<i><b>Hello, World!</b></i>'
244 | 
245 | 
246 | Memoização
247 | ----------
248 | 
249 |     Texto...
250 | 
251 | 
252 | 
253 | Criação do decorador de memoização:
254 | 
255 | .. code-block:: python
256 | 
257 |     def memoize(f):
258 |         '''
259 |         Memoize function (as decorator)
260 |         '''
261 | 
262 |         # dictionary (cache)
263 |         mem = {}
264 | 
265 |         ''' Helper function '''
266 |         def memoizer(*param):
267 |             key = repr(param)
268 |             if not key in mem:
269 |                 mem[key] = f(*param)
270 |             return mem[key]
271 |         return memoizer
272 | 
273 | 
274 | 
275 | Criação da função decorada com memoização aplicada para Fibonacci:
276 | 
277 | .. code-block:: python
278 | 
279 |     @memoize
280 |     def fibo(n):
281 |         if (n < 2): return n
282 |         else:
283 |             return fibo(n - 1) + fibo(n - 2)
284 | 
285 | 
286 | 
287 | Execução da função decorada:
288 | 
289 | .. code-block:: python
290 | 
291 |     fibo(39)
292 | 
293 | .. code-block:: console
294 | 
295 |     63245986


--------------------------------------------------------------------------------
/source/content/iter_gen.rst:
--------------------------------------------------------------------------------
  1 | Iteratoradores e Geradores
  2 | **************************
  3 | 
  4 | Iterator
  5 | --------
  6 | 
  7 | 
  8 |     Um iterator (iterador) permite acessar elementos de uma coleção / sequência, retornando cada elemento sequencialmente.
  9 |     Todo objeto que tiver o método __next__() é um iterator.
 10 | 
 11 | 
 12 | 
 13 | Criação de um iterator com uma string:
 14 | 
 15 | .. code-block:: python
 16 | 
 17 |     it = iter('bar')
 18 | 
 19 | 
 20 | 
 21 | Representação:
 22 | 
 23 | .. code-block:: python
 24 | 
 25 |     repr(it)
 26 | 
 27 | .. code-block:: console
 28 | 
 29 |     '<iterator object at 0x7f123cd62c50>'
 30 | 
 31 | 
 32 | 
 33 | Executando o método __next__ até seu fim:
 34 | 
 35 | .. code-block:: python
 36 | 
 37 |     it.__next__()
 38 | 
 39 | .. code-block:: console
 40 | 
 41 |     'b'
 42 | 
 43 | .. code-block:: python
 44 | 
 45 |     it.__next__()
 46 | 
 47 | .. code-block:: console
 48 | 
 49 |     'a'
 50 | 
 51 | .. code-block:: python
 52 | 
 53 |     it.__next__()
 54 | 
 55 | .. code-block:: console
 56 | 
 57 |     'r'
 58 | 
 59 | .. code-block:: python
 60 | 
 61 |     it.__next__()
 62 | 
 63 | .. code-block:: console
 64 | 
 65 |     StopIteration:
 66 | 
 67 |         Bla bla bla
 68 | 
 69 | |   Nota-se que a iteração foi feita sobre a string declarada, de forma a 
 70 | | retornar caractere por caractere e após o último foi lançada uma exceção
 71 | | indicando que não há mais elementos a serem retornados.
 72 | 
 73 | 
 74 | 
 75 | Classe Iterator
 76 | ---------------
 77 | 
 78 | |   É possível também implementar um iterador como um objeto de uma classe
 79 | | personalizada.
 80 | |   É necessário implementar os métodos __iter__ e __next__.
 81 | |   __iter__ retorna o objeto iterador por si.
 82 | |   __next__ retorna o próximo item da coleção e ao alcançar o fim e se
 83 | | houver uma chamada sequente uma exceção é lançada (StopIteration).
 84 | 
 85 | 
 86 | 
 87 | Criação da classe de iterador:
 88 | 
 89 | .. code-block:: python
 90 | 
 91 |     class FirstNumbers(object):
 92 | 
 93 |     def __init__(self, n):
 94 |         self.n = n
 95 |         self.i = 0
 96 |     
 97 |     def __iter__(self):
 98 |         return self
 99 |     
100 |     
101 |     def __next__(self):
102 |         if self.i <= self.n:
103 |             cur = self.i
104 |             self.i += 1
105 |             return cur
106 |         else:
107 |             raise StopIteration()
108 | 
109 | 
110 | 
111 | Somatória dos 10 primeiros números:
112 | 
113 | .. code-block:: python
114 | 
115 |     print(sum(FirstNumbers(10)))
116 | 
117 | .. code-block:: console
118 | 
119 |     45
120 | 
121 | 
122 | 
123 | Generator
124 | ---------
125 | 
126 | |   Um generator é um objeto iterável assim como um iterator, mas nem todo
127 | | iterator é um generator.
128 | |   Funções de generator permite declarar uma função que se comporta como um
129 | | iterador, podendo ser usadas em loops.
130 | |   Um generator implementa o conceito de lazy evaluation, o que faz com que
131 | | em determinadas situações economize-se recursos de processamento, pois cada
132 | | elemento é processado conforme a demanda.
133 | 
134 | 
135 | 
136 | Criando um objeto range que vai de 0  a 9:
137 | 
138 | .. code-block:: python
139 | 
140 |     numeros = range(0, 10)
141 | 
142 | 
143 | 
144 | Se for utilizado list comrprehension será gerada uma lista:
145 | 
146 | .. code-block:: python
147 | 
148 |     rq = [x ** 2 for x in numeros]
149 | 
150 | 
151 | 
152 | Verificando os elementos:
153 | 
154 | .. code-block:: python
155 | 
156 |     rq
157 | 
158 | .. code-block:: console
159 | 
160 |     [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
161 | 
162 | 
163 | 
164 | Verificando o tipo:
165 | 
166 | .. code-block:: python
167 | 
168 |     type(rq)
169 | 
170 | .. code-block:: console
171 | 
172 |     list
173 | 
174 | 
175 | 
176 | Tuple comprehension é uma maneira de se criar um generator:
177 | 
178 | .. code-block:: python
179 | 
180 |     rq = (x ** 2 for x in numeros)
181 | 
182 | 
183 | 
184 | Verificando o tipo do objeto:
185 | 
186 | .. code-block:: python
187 | 
188 |     type(rq)
189 | 
190 | .. code-block:: console
191 | 
192 |     generator
193 | 
194 | 
195 | 
196 | Executando o método dunder next até o fim dos elementos:
197 | 
198 | .. code-block:: python
199 | 
200 |     rq.__next__()
201 | 
202 | .. code-block:: console
203 | 
204 |     0
205 | 
206 | .. code-block:: python
207 | 
208 |     rq.__next__()
209 | 
210 | .. code-block:: console
211 | 
212 |     1
213 | 
214 | . . .
215 | 
216 | .. code-block:: console
217 | 
218 |     81
219 | 
220 | .. code-block:: python
221 | 
222 |     rq.__next__()
223 | 
224 | .. code-block:: console
225 | 
226 |     StopIteration:
227 | 
228 |         Bla bla bla
229 | 
230 | 
231 | 
232 | Funções Generator
233 | -----------------
234 | 
235 | |   Uma função generator utiliza o comando yield em vez de return, o que faz
236 | | com que retorne o próximo elemento da sequência.
237 | 
238 | 
239 | 
240 | Criação de uma função generator:
241 | 
242 | .. code-block:: python
243 | 
244 |     def gen():
245 | 
246 |     i = 0
247 | 
248 |     while i < 10:
249 |         yield i
250 |         i += 1
251 | 
252 | 
253 | 
254 | Criação do gerador via execução da função:
255 | 
256 | .. code-block:: python
257 | 
258 |     x = gen()
259 | 
260 | 
261 | 
262 | Verificando os tipos:
263 | 
264 | .. code-block:: python
265 | 
266 |     type(gen)
267 | 
268 | .. code-block:: console
269 | 
270 |     function
271 | 
272 | .. code-block:: python
273 | 
274 |     type(x)
275 | 
276 | .. code-block:: console
277 | 
278 |     generator
279 | 
280 | 
281 | 
282 | Execução do método __next__ até o fim:
283 | 
284 | .. code-block:: python
285 | 
286 |     x.__next__()
287 | 
288 | .. code-block:: console
289 | 
290 |     0
291 | 
292 | . . . 
293 | 
294 | .. code-block:: python
295 | 
296 |     x.__next__()
297 | 
298 | .. code-block:: console
299 | 
300 |     9
301 | 
302 | .. code-block:: python
303 | 
304 |     x.__next__()
305 | 
306 | .. code-block:: console
307 | 
308 |     StopIteration:
309 | 
310 | 
311 | 
312 | Iterator vs Generator
313 | ---------------------
314 | 
315 | - Para criar um generator utilizamos ou uma função com yield no lugar de 
316 |   return ou tuple comprehension.
317 |   Para criar um iterador utilizamos a função `iter()`;
318 | 
319 | - Generator utiliza `yield`, iterator não;
320 | 
321 | - Gerador salva o estado de variáveis locais a cada vez que o yield pausa o
322 |   loop. Um iterador não faz uso de variáveis locais, tudo o que ele precisa é
323 |   faz a iteração.
324 | 
325 | - Iteradores fazem uso mais eficiente de memória.
326 | 
327 | 
328 | 
329 | Do módulo timeit importar a função de mesmo nome:
330 | 
331 | .. code-block:: python
332 | 
333 |     from timeit import timeit
334 | 
335 | 
336 | 
337 | Verificação de tipos:
338 | 
339 | .. code-block:: python
340 | 
341 |     type(iter([x for x in range(1, 1001)]))
342 | 
343 | .. code-block:: console
344 | 
345 |     list_iterator
346 | 
347 | .. code-block:: python
348 | 
349 |     type((x for x in range(1, 1001)))
350 | 
351 | .. code-block:: console
352 | 
353 |     generator
354 | 
355 | 
356 | 
357 | Strings com código em loop sobre iterador e gerador, respectivamente:
358 | 
359 | .. code-block:: python
360 | 
361 |     code_it = '''                                
362 |     for i in (iter([x for x in range(1, 1001)])):
363 |         pass
364 |     '''
365 | 
366 | .. code-block:: python
367 | 
368 |     code_gen = '''                                
369 |     for i in ((x for x in range(1, 1001))):
370 |         pass
371 |     '''
372 | 
373 | 
374 | 
375 | Cronometrando os códigos de iterador e gerador, respectivamente:
376 | 
377 | .. code-block:: python
378 | 
379 |     timeit(code_it)
380 | 
381 | .. code-block:: console
382 | 
383 |     42.666774257901125
384 | 
385 | .. code-block:: python
386 | 
387 |     timeit(code_gen)
388 | 
389 | .. code-block:: console
390 | 
391 |     53.58039242995437


--------------------------------------------------------------------------------
/source/content/sequences.rst:
--------------------------------------------------------------------------------
  1 | Sequências
  2 | **********
  3 | 
  4 | 	Com sequências podemos fazer iteração, indexação, fatiamento (slice) e operações de list comprehension.
  5 | 
  6 | Mútável:
  7 | 
  8 | **lista -> list -> [0, 'string', 7.0, 1000L]**
  9 | 
 10 | Imutáveis:
 11 | 
 12 | **string -> str -> 'texto'**
 13 | 
 14 | **tupla -> tuple -> (0, 'string', 7.0, 1000L)**
 15 | 
 16 | Strings e tuplas funcionam de forma idêntica à lista, porém, seus itens são imutáveis, consomem menos recursos.
 17 | 
 18 | 
 19 | Operações com Sequências
 20 | ------------------------
 21 | 
 22 | - Índices
 23 | 
 24 | 	Toda sequência, seguindo a mesma idéia de vetores de outras linguagens, como C, por exemplo, começa com o índice 0 (zero).
 25 | 	Para se obter um índice, fazemos da seguinte forma:
 26 | 
 27 | 	sequencia[indice]
 28 | 
 29 | 
 30 | 
 31 | Segundo elemento da string:
 32 | 
 33 | .. code-block:: python
 34 | 
 35 |     'Python'[1]
 36 | 
 37 | .. code-block:: console
 38 | 
 39 |     'y'
 40 | 
 41 | 
 42 | 
 43 | Primeiro elemento da lista:
 44 | 
 45 | .. code-block:: python
 46 | 
 47 |     ['foo', 'bar', 2.7, 80,  2 + 7j][0]
 48 | 
 49 | .. code-block:: console
 50 | 
 51 |     'foo'
 52 | 
 53 | 
 54 | 
 55 | Quarto elemento da tupla:
 56 | 
 57 | .. code-block:: python
 58 | 
 59 |     ('Python', 'C', 'C++', 2.7, 3.7)[3]
 60 | 
 61 | .. code-block:: console
 62 | 
 63 |     2.7
 64 | 
 65 | 
 66 | 
 67 | Iteráveis
 68 | ---------
 69 | 
 70 | 	Sequências nos permite também fazer iteração sobre cada elemento.
 71 | 
 72 | 
 73 | 
 74 | Definição de uma tupla:
 75 | 
 76 | .. code-block:: python
 77 | 
 78 |     regiao_sudeste = ('SP', 'MG', 'ES', 'RJ')
 79 | 
 80 | 
 81 | 
 82 | Loop sobre a tupla e impressão em tela de cada elemento:
 83 | 
 84 | .. code-block:: python
 85 | 
 86 |     for i in regiao_sudeste:
 87 |         print(i)
 88 | 
 89 | .. code-block:: console
 90 | 
 91 |     SP
 92 |     MG
 93 |     ES
 94 |     RJ
 95 | 
 96 | 
 97 | 
 98 | Loop sobre a string e impressão em tela de cada caractere:
 99 | 
100 | .. code-block:: python
101 | 
102 |     for i in 'Python':
103 |         print(i)
104 | 
105 | .. code-block:: console
106 | 
107 |     P
108 |     y
109 |     t
110 |     h
111 |     o
112 |     n
113 | 
114 | 
115 | 
116 | Loop sobre um range de 0 (zero) a 20 (vinte) com a condição de exibir somente 0 (zero) e divisíveis por 5 (cinco):
117 | 
118 | .. code-block:: python
119 | 
120 |     for i in range(21):
121 |         if (i % 5 == 0):
122 |             print(i)
123 | 
124 | .. code-block:: console
125 | 
126 |     0
127 |     5
128 |     10
129 |     15
130 |     20
131 | 
132 | 
133 | 
134 | Fatiamento / Slicing
135 | --------------------
136 | 
137 |     É o corte de uma sequência.
138 | 
139 |     **[inicio:fim - 1:incremento]**
140 | 
141 | 
142 | 
143 | Fatiamento sem qualquer determinação:
144 | 
145 | .. code-block:: python
146 | 
147 |     'Python Language'[::]
148 | 
149 | .. code-block:: console
150 | 
151 |     'Python Language'
152 | 
153 | 
154 | Não foram determinados início, fim e incremento.
155 | 
156 | 
157 | 
158 | Fatiamento determinando apenas o início, que é o último elemento:
159 | 
160 | .. code-block:: python
161 | 
162 |     'Python Language'[-1::]
163 | 
164 | .. code-block:: console
165 | 
166 |     'e'
167 | 
168 | 
169 | 
170 | Pelo sinal de subtração, os três últimos caracteres da string:
171 | 
172 | .. code-block:: python
173 | 
174 |     'Python Language'[-3::]
175 | 
176 | .. code-block:: console
177 | 
178 |     'age'
179 | 
180 | 
181 | 
182 | Determinando apenas o incremento de 4 (quatro) em 4:
183 | 
184 | .. code-block:: python
185 | 
186 |     (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)[::4]
187 | 
188 | .. code-block:: console
189 | 
190 |     (0, 4, 8)
191 | 
192 | 
193 | 
194 | Incremento negativo faz com que a string seja colocada em ordem reversa:
195 | 
196 | .. code-block:: python
197 | 
198 |     'Python Language'[::-1]
199 | 
200 | .. code-block:: console
201 | 
202 |     'egaugnaL nohtyP'
203 | 
204 | 
205 | 
206 | A partir do primeiro caractere:
207 | 
208 | .. code-block:: python
209 | 
210 |     'Python Language'[0:]
211 | 
212 | .. code-block:: console
213 | 
214 |     'Python Language'
215 | 
216 | 
217 | 
218 | Do primeiro ao primeiro caractere:
219 | 
220 | .. code-block:: python
221 | 
222 |     'Python Language'[0:1]
223 | 
224 | .. code-block:: console
225 | 
226 |     'P'
227 | 
228 | 
229 | 
230 | Do primeiro ao sexto caractere:
231 | 
232 | .. code-block:: python
233 | 
234 |     Python Language'[0:6]
235 | 
236 | .. code-block:: console
237 | 
238 |     'Python'
239 | 
240 | 
241 | 
242 | Do oitavo caractere em diante:
243 | 
244 | .. code-block:: python
245 | 
246 |     'Python Language'[7:]
247 | 
248 | .. code-block:: console
249 | 
250 |     'Language'
251 | 
252 | 
253 | 
254 | Criação de uma tupla de exemplo:
255 | 
256 | .. code-block:: python
257 | 
258 |     linux_distros = (
259 |                      'Debian',
260 |                      'RedHat',
261 |                      'Slackware',
262 |                      'Ubuntu',
263 |                      'CentOS',
264 |                      'SuSE',
265 |                     )
266 | 
267 | 
268 | 
269 | Do primeiro ao terceiro elemento:
270 | 
271 | .. code-block:: python
272 | 
273 |     linux_distros[0:3]
274 | 
275 | .. code-block:: console
276 | 
277 |     ('Debian', 'RedHat', 'Slackware')
278 | 
279 | 
280 | 
281 | List Comprehension
282 | ------------------
283 | 
284 | 	Ou em português, "Compreensão de Lista", fornece uma maneira concisa para criar listas.
285 | 	Usos comuns são para fazer novas listas onde cada elemento é o resultado de algumas operações aplicadas para cada membro de outra sequência ou iterável, criar uma subsequência desses elementos que satisfaçam uma certa condição.
286 | 	Sempre retornará uma lista.
287 | 
288 | 
289 | 
290 | Lista a partir de uma list comprehension do range:
291 | 
292 | .. code-block:: python
293 | 
294 |     [i for i in range(21)]
295 | 
296 | .. code-block:: console
297 | 
298 |     [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
299 | 
300 | 
301 | 
302 | Lista cujos elementos são a metade de cada elemento do range:
303 | 
304 | .. code-block:: python
305 | 
306 |     [i / 2.0 for i in range(10)]
307 | 
308 | .. code-block:: console
309 | 
310 |     [0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5]
311 | 
312 | 
313 | 
314 | Lista com condição que seja 0 (zero) ou divisível por 5 (cinco):
315 | 
316 | .. code-block:: python
317 | 
318 |     [i for i in range(21) if (i % 5 == 0)]
319 | 
320 | .. code-block:: console
321 | 
322 |     [0, 5, 10, 15, 20]
323 | 
324 | 
325 | 
326 | Tuple Comprehension
327 | -------------------
328 | 
329 |     Ou em português "Compreenção de Tupla" é similar a uma list comprehension, no entanto resulta em um generator.
330 | 
331 | 
332 | 
333 | Criação de um generator a partir de uma tuple comprehension:
334 | 
335 | .. code-block:: python
336 | 
337 |     x = (i for i in range(21))
338 | 
339 | 
340 | 
341 | Verificando o tipo do objeto:
342 | 
343 | .. code-block:: python
344 | 
345 |     type(x)
346 | 
347 | .. code-block:: console
348 | 
349 |     generator
350 | 
351 | 
352 | 
353 | Dict Comprehension
354 | ------------------
355 | 
356 |     Ou também conhecido em português como "Compreenção de Dicionário"
357 | 
358 | 
359 | Objeto dicionário a ser criado:
360 | 
361 | .. code-block:: python
362 | 
363 |     d1 = {'a': 1, 'b':2, 'c': 3}
364 | 
365 | 
366 | 
367 | Novo dicionário criado a partir de dict comprehension:    
368 | 
369 | .. code-block:: python
370 | 
371 |     d2 = {k.upper(): v * 10 for k, v in d1.items()}
372 | 
373 | Cada chave é o caractere maiúsculo das chave correspondente ao dicionário
374 | original e seus valores são multiplicados por 10 (dez).
375 | 
376 | 
377 | 
378 | Exibindo o dicionário gerado a partir da dict comprehension:
379 | 
380 | .. code-block:: python
381 | 
382 |     print(d2)
383 | 
384 | .. code-block:: console
385 | 
386 |     {'A': 10, 'B': 20, 'C': 30}


--------------------------------------------------------------------------------
/source/content/property.rst:
--------------------------------------------------------------------------------
  1 | Encapsulamento
  2 | **************
  3 | 
  4 | |   O conceito de encapsulamento no geral consiste em isolar atributos e / ou métodos de acesso externo deixando-os como privados.
  5 | |   Atributos privados devem ser acessados ou modificados através de *getters* e *setters*, respectivamente.
  6 | |   Métodos privados têm sua área de atuação restrita somente internamente na classe.
  7 | 
  8 | 
  9 | Modificador Private (__)
 10 | ------------------------
 11 | 
 12 | |   Colocando 2 (dois) underscores antecedendo o atributo, ele fica privado, ou seja, não é acessível fora da classe.
 13 | |   Em Python não existem modificadores de atributos e métodos como em outras linguagens, ou seja, não existe *public*, *private* ou *protected*.
 14 | 
 15 | 
 16 | 
 17 | Criação de uma classe de teste:
 18 | 
 19 | .. code-block:: python
 20 | 
 21 |     class Foo(object):
 22 |         __atributo = 0
 23 | 
 24 | 
 25 | 
 26 | Instância da classe:
 27 | 
 28 | .. code-block:: python
 29 | 
 30 |     f = Foo()
 31 | 
 32 | 
 33 | 
 34 | 
 35 | Tentativa de acesso a atributo privado:
 36 | 
 37 | .. code-block:: python
 38 | 
 39 |     f.__atributo
 40 | 
 41 | .. code-block:: console
 42 | 
 43 |     . . .
 44 |     AttributeError: 'Foo' object has no attribute '__atributo'
 45 | 
 46 | |   Por ser um atributo privado, seu acesso externo não foi reconhecido.    
 47 | 
 48 | 
 49 | 
 50 | Property
 51 | --------
 52 | 
 53 | |   Property é a solução pythônica para implementar getters e setters de forma inteligente e podendo inclusive impor restrições.
 54 | 
 55 | 
 56 | 
 57 | Criação da classe Carro:
 58 | 
 59 | .. code-block:: python
 60 | 
 61 |     class Carro(object):
 62 |         def __init__(self):
 63 |             self.__velocidade = 0
 64 |         
 65 |         # Métodos privados para a property
 66 | 
 67 |         def __get__velocidade(self):
 68 |             print(f'Velocidade: {self.__velocidade} km/h')
 69 |             return self.__velocidade
 70 |         
 71 |         def __set__velocidade(self, velocidade):
 72 |             if velocidade > 300:
 73 |                 raise ValueError('A velocidade máxima permitida é de 300 km/h')        
 74 |             self.__velocidade = velocidade
 75 |             print(f'Velocidade = {self.__velocidade} km/h')
 76 |             
 77 |         def __del__velocidade(self):
 78 |             print('Removendo a propriedade de velocidade')
 79 |             del self.__velocidade
 80 |         
 81 |         # Definição da property velocidade
 82 |         velocidade = property(__get__velocidade,  # getter
 83 |                               __set__velocidade,  # setter
 84 |                               __del__velocidade,  # deleter
 85 |                               'Velocidade máxima do carro')  # Descrição
 86 | 
 87 | 
 88 | 
 89 | Instância da classe Carro:
 90 | 
 91 | .. code-block:: python
 92 | 
 93 |     c = Carro()
 94 | 
 95 | 
 96 | 
 97 | Tentativa de acesso ao atributo privado:
 98 | 
 99 | .. code-block:: python
100 | 
101 |     c.__velocidade
102 | 
103 | 
104 | .. code-block:: console
105 | 
106 |     AttributeError: 'Carro' object has no attribute '__velocidade'
107 | 
108 | 
109 | 
110 | Acessando a property velocidade:    
111 | 
112 | .. code-block:: python
113 | 
114 |     c.velocidade
115 | 
116 | .. code-block:: console
117 | 
118 |     Velocidade: 0 km/h
119 |     0
120 | 
121 | 
122 | 
123 | Atribuindo um valor para a property:
124 | 
125 | .. code-block:: python
126 | 
127 |     c.velocidade = 200
128 | 
129 | .. code-block:: console
130 | 
131 |     Velocidade = 200 km/h
132 | 
133 | 
134 | 
135 | O que acontece se pegarmos o nome do atributo privado e o definirmos externamente?:
136 | 
137 | .. code-block:: python
138 | 
139 |     c.__velocidade = 'valor equivocado'
140 |     
141 |     
142 |     
143 | Acessando o atributo adicionado:
144 | 
145 | .. code-block:: python
146 | 
147 |     c.__velocidade                                                                                                                                                                                            
148 | .. code-block:: console
149 | 
150 |     'valor equivocado'
151 |     
152 |     
153 |     
154 | Será que a property foi afetada?:
155 | 
156 | .. code-block:: python
157 | 
158 |     c.velocidade
159 | 
160 | .. code-block:: console
161 | 
162 |     Velocidade: 200 km/h
163 |     
164 | |   Felizmente a property não foi afetada e o encapsulamento foi mantido :)
165 | 
166 | 
167 | 
168 | Reatribuir um novo valor:
169 | 
170 | .. code-block:: python
171 | 
172 |     c.velocidade = 170                                                                                                                                                                                        
173 | 
174 | .. code-block:: console
175 | 
176 |     Velocidade = 170 km/h
177 |     
178 |     
179 |     
180 | Consultar o valor do atributo:
181 | 
182 | .. code-block:: python
183 | 
184 |     c.velocidade
185 |     
186 | .. code-block:: console
187 | 
188 |     Velocidade: 170 km/h
189 |     170    
190 | 
191 | 
192 | 
193 | Tentativa de atribuir um valor não permitido:    
194 | 
195 | .. code-block:: python
196 | 
197 |     c.velocidade = 301
198 | 
199 | .. code-block:: console
200 |     
201 |     . . .
202 | 
203 |     ValueError: A velocidade máxima permitida é de 300 km/h
204 | 
205 | 
206 | 
207 | Remover a property:
208 | 
209 | .. code-block:: python
210 | 
211 |     del c.velocidade
212 | 
213 | .. code-block:: console
214 | 
215 |     Removendo a propriedade de velocidade
216 | 
217 | 
218 | 
219 | Tentativa de acesso à property apagada:
220 | 
221 | .. code-block:: python
222 | 
223 |     c.velocidade
224 | 
225 | .. code-block:: console
226 | 
227 |     AttributeError: 'Carro' object has no attribute '_Carro__velocidade'
228 | 
229 | 
230 | 
231 | Property como Decorator
232 | ~~~~~~~~~~~~~~~~~~~~~~~
233 | 
234 | |   Além da já citada implementação de property, pode-se também fazer isso por meio de decorators.
235 | 
236 | 
237 | 
238 | Criação de classe com definição de properties via decorators:
239 | 
240 | .. code-block:: python
241 | 
242 |     class Carro(object):
243 |         def __init__(self):
244 |             self.__velocidade = 0
245 | 
246 |         # Properties    
247 |             
248 |         @property 
249 |         def velocidade(self):
250 |             '''
251 |             Velocidade máxima do carro
252 |             '''
253 |             print(f'Velocidade: {self.__velocidade} km/h')
254 |             return self.__velocidade
255 |         
256 |         @velocidade.setter    
257 |         def velocidade(self, velocidade):
258 |             if velocidade > 300:
259 |                 raise ValueError('A velocidade máxima permitida é de 300 km/h')        
260 |             self.__velocidade = velocidade
261 |             print(f'Velocidade = {self.__velocidade} km/h')
262 |             
263 |         @velocidade.deleter   
264 |         def velocidade(self):
265 |             print('Removendo a propriedade de velocidade')
266 |             del self.__velocidade
267 | 
268 | |   Repetir os comandos do exercício anterior ;) 
269 | 
270 | 
271 | 
272 | Descriptors
273 | -----------
274 | 
275 | |   São objetos Python que implementam um método do protocolo descritor, que nos permite criar objetos que
276 | tenham um comportamento desejado quando seus atributos são acessados por outros objetos.
277 | 
278 | 
279 | 
280 | Criação de uma classe descriptor:
281 | 
282 | .. code-block:: python
283 | 
284 |     class Verbose(object):
285 | 
286 |         def __get__(self, obj, type=None) -> object:
287 |             return 7
288 |             
289 |         def __set__(self, obj, value) -> None:
290 |             raise AttributeError('Não pode mudar o valor!!!')
291 |             
292 |         def __delete__(self, obj, type=None) -> None:
293 |             raise AttributeError('Não pode remover o atributo!!!')
294 |         
295 |         
296 |         
297 |         
298 |         
299 | Criação de uma classe de teste para o descriptor:
300 | 
301 | .. code-block:: python
302 | 
303 |     class Foo(object):
304 |         atributo = Verbose()
305 | 
306 | 
307 | 
308 |     
309 | Instanciação da classe Foo:
310 | 
311 | .. code-block:: python
312 | 
313 |     o = Foo()
314 | 
315 | 
316 | 
317 | 
318 | Verificação do tipo do atributo que utiliza o descriptor:
319 | 
320 | .. code-block:: python
321 | 
322 |     type(o.atributo)                                                                                                                                                                                           
323 | 
324 | .. code-block:: console
325 | 
326 |     int
327 | 
328 | 
329 | 
330 | 
331 | Exibe o valor do atributo:
332 | 
333 | .. code-block:: python
334 | 
335 |     print(o.atributo)                                                                                                                                                                                          
336 | 
337 | .. code-block:: console
338 | 
339 |     7
340 | 
341 | 
342 | 
343 | Tentativa de atribuir um novo valor ao atributo:
344 | 
345 | .. code-block:: python
346 | 
347 |     o.atributo = 9
348 | 
349 | .. code-block:: console
350 | 
351 |     AttributeError: Não pode mudar o valor!!!
352 | 
353 | |   Houve um lançamento de exceção ao tentar redefinir o valor do atributo.
354 | 
355 | 
356 | 
357 | Tentativa de remover o atributo do objeto:
358 | 
359 | .. code-block:: python
360 | 
361 |     del o.atributo
362 | 
363 | .. code-block:: console
364 | 
365 |     AttributeError: Não pode remover o atributo!!!
366 | 
367 | |   Houve um lançamento de exceção ao tentar remover o atributo.
368 | 
369 | 
370 | 
371 | Verificando se o atributo foi alterado:
372 | 
373 | .. code-block:: python
374 | 
375 |     print(o.atributo)
376 | 
377 | .. code-block:: console
378 | 
379 |     7


--------------------------------------------------------------------------------
/source/content/scope.rst:
--------------------------------------------------------------------------------
  1 | Escopo
  2 | ******
  3 | 
  4 | |   Por escopo entende-se o contexto onde um identificador será considerado.
  5 | |   Um identificador pode ser uma variável, um comando, uma função uma clase ou um objeto.
  6 | |   A ordem de busca de um identificador em escopos é a seguinte:
  7 |     
  8 | 1. Local ou dentro de função;
  9 | 2. Função externa;
 10 | 3. Global ou de módulo;
 11 | 4.  __builtins__
 12 | 
 13 | 
 14 | 
 15 | Escopo Local ou Dentro de Função
 16 | --------------------------------
 17 | 
 18 |     É o escopo que tem a maior prioridade.
 19 | 
 20 | 
 21 | 
 22 | Declaração de uma variável com seu valor:
 23 | 
 24 | .. code-block:: python
 25 | 
 26 |     foo = 7
 27 | 
 28 | 
 29 | 
 30 | Exibindo na tela o valor da variável:
 31 | 
 32 | .. code-block:: python
 33 | 
 34 |     print(foo)
 35 | 
 36 | .. code-block:: console
 37 | 
 38 |     7
 39 | 
 40 | 
 41 | 
 42 | Função locals
 43 | ~~~~~~~~~~~~~
 44 | 
 45 | |   A função locals() retorna um dicionário com os identificadores locais e seus respectivos valores.
 46 | | Então é pedido o valor dada a chave que é o nome da variável local.
 47 | 
 48 | 
 49 | 
 50 | Usando locals para retornar o valor de uma variável:
 51 | 
 52 | .. code-block:: python
 53 | 
 54 |     locals()['foo']
 55 | 
 56 | .. code-block:: console
 57 | 
 58 |     7
 59 | 
 60 | 
 61 | 
 62 | Escopo Interno de uma Função
 63 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 64 | 
 65 | |   Diz respeito ao espaço delimitado de alcance, dentro de uma função.
 66 | 
 67 | 
 68 | 
 69 | Declaração de uma variável externamente ao escopo da função:
 70 | 
 71 | .. code-block:: python
 72 | 
 73 |     foo = 7
 74 | 
 75 | 
 76 | 
 77 | Definição de uma função:
 78 | 
 79 | .. code-block:: python
 80 | 
 81 |     def funcao():
 82 |         foo = 9
 83 |         print(id(foo))
 84 |         print(foo)
 85 |     
 86 | |   Nota-se que dentro da função também há uma variável chamada "foo". Essa função imprime o ID desse identificador e depois imprime seu valor.
 87 | 
 88 | 
 89 | 
 90 | Exibindo o ID de foo:
 91 | 
 92 | .. code-block:: python
 93 | 
 94 |     print(id(foo))
 95 | 
 96 | .. code-block:: console
 97 | 
 98 |     162857064
 99 |     
100 |     
101 | 
102 | Exibindo o valor de foo:
103 | 
104 | .. code-block:: python
105 | 
106 |     print(foo)
107 | 
108 | .. code-block:: console
109 | 
110 |     7
111 | 
112 | 
113 | 
114 | Acionando a função:
115 | 
116 | .. code-block:: python
117 | 
118 |     funcao()
119 | 
120 | .. code-block:: console
121 | 
122 |     162857040
123 |     9
124 | 
125 | |   Nota-se também que bem como o ID e o valor retornados pela função, da variável interna foo são diferentes da variável externa de mesmo nome.
126 | 
127 | 
128 | 
129 | Escopo de Função Externa
130 | ------------------------
131 | 
132 | |   Ao se criar uma função dentro de outra, a função mais interna pode utilizar um identificador que esteja no nível mais acima.
133 | 
134 | 
135 | 
136 | Definição de uma função com uma função interna:
137 | 
138 | .. code-block:: python
139 | 
140 |     def funcao_principal():
141 |         x = 1
142 |         def funcao_secundaria():
143 |             print(x)
144 |         funcao_secundaria()
145 | 
146 | |   A função principal tem uma variável x, cujo valor é impresso em tela pela função secundária.
147 | |   A função principal invoca a função secundária.
148 | 
149 | 
150 | 
151 | Chamando a função:
152 | 
153 | .. code-block:: python
154 | 
155 |     funcao_principal()
156 | 
157 | .. code-block:: console
158 | 
159 |     1
160 | 
161 | 
162 | Uma nova definição da função:
163 | 
164 | .. code-block:: python
165 | 
166 |     def funcao_principal():
167 |         x = 1
168 |         def funcao_secundaria():
169 |             x = 2
170 |             print(x)
171 |         funcao_secundaria()
172 | 
173 | |   Diferente do exemplo anterior, a função secundária declarou sua própria variável "x".    
174 | 
175 | 
176 | 
177 | Testando a função:
178 | 
179 | .. code-block:: python
180 | 
181 |     funcao_principal()
182 |     
183 | .. code-block:: console
184 | 
185 |     2
186 | 
187 | |   Nota-se que o valor considerado foi o de "x", que é o identificador mais interno.
188 | 
189 | 
190 | 
191 | Escopo Global ou Escopo do Módulo
192 | ---------------------------------
193 | 
194 | |   É também conhecido como escopo de módulo devido ao fato de estar na endentação do mesmo.
195 | 
196 | 
197 | 
198 | Criação de variável:
199 | 
200 | .. code-block:: python
201 | 
202 |     foo = 'bar'
203 | 
204 | 
205 | 
206 | Criação de função:
207 | 
208 | .. code-block:: python
209 | 
210 |     def funcao():
211 |         foo = 'eggs'
212 |         print(foo)
213 |     
214 | |   A função criada tem uma variável com o mesmo nome que uma variável global, a ela dá um valor e imprime esse valor em tela.
215 | |   Será que isso altera o valor da variável global?
216 | 
217 | 
218 | 
219 | Execução da função:
220 | 
221 | .. code-block:: python
222 | 
223 |     funcao()
224 | 
225 | .. code-block:: console
226 | 
227 |     eggs
228 | 
229 | |   Nota-se que o valor impresso é igual ao da variável "foo" dentro da função.
230 | |   Pra saber se a variável global foi alterada, vamos testar com a função print.
231 | 
232 | 
233 | 
234 | Imprimindo o valor da variável global:
235 | 
236 | .. code-block:: python
237 | 
238 |     print(foo)
239 | 
240 | .. code-block:: console
241 | 
242 |     bar
243 | 
244 | |   Pode-se concluir que a função criada não interferiu na variável global.
245 | |   Para alterar uma variável global em um contexto local precisamos utilizar o comando global.
246 | 
247 | 
248 | Criação de função que altera a variável global:
249 | 
250 | .. code-block:: python
251 | 
252 |     def funcao():
253 |         global foo
254 |         foo = 'eggs'
255 |         print(foo)
256 | 
257 | 
258 | 
259 | Executar função:
260 | 
261 | .. code-block:: python
262 | 
263 |     funcao()
264 | 
265 | .. code-block:: console
266 | 
267 |     eggs
268 | 
269 | |   OK, a função imprimiu o valor local da função.
270 | |   Mas será que a variável global também foi alterada?
271 | 
272 | 
273 | 
274 | Imprimir o valor da variável global:
275 | 
276 | .. code-block:: python
277 | 
278 |     print(foo)
279 | 
280 | .. code-block:: console
281 | 
282 |     eggs
283 | 
284 | |   Agora a função pôde alterar a variável global. Isso se deve ao fato do comando global ter sido empregado.
285 | |   A variável global a ser alterada deve ser declarada como global antes de sua atribuição.
286 | 
287 | 
288 | 
289 | Escopo __builtins__
290 | -------------------
291 | 
292 | |   O escopo __builtins__ abrange identificadores que já estão definidos antes mesmo do código a ser escrito.
293 | |   São funções, comandos e variáveis internas de Python.
294 | 
295 | 
296 | 
297 | "str" é está em __builtins__?:
298 | 
299 | .. code-block:: python
300 | 
301 |     'str' in dir(__builtins__)
302 | 
303 | .. code-block:: console
304 | 
305 |     True
306 | 
307 | |   Resposta afirmativa (True), ou seja, "str" faz parte desse escopo.
308 | |   E se sobescrevermos esse item localmente?
309 | 
310 | 
311 | 
312 | Criando uma variável cujo identificador pertence ao escopo __builtins__:
313 | 
314 | .. code-block:: python
315 | 
316 |     str = 1
317 | 
318 | 
319 | 
320 | Qual é o tipo?:
321 | 
322 | .. code-block:: python
323 | 
324 |     type(str)
325 | 
326 | .. code-block:: console
327 | 
328 |     int
329 | 
330 | |   "str" que inicialmente era um identificador para o tipo de strings em Python, aqui agora virou uma variável de inteiro.
331 | |   Mas e o tipo "str" deixou de existir?
332 | 
333 | 
334 | 
335 | Qual tipo?
336 | 
337 | .. code-block:: python
338 | 
339 |     type(__builtins__.str)
340 | 
341 | .. code-block:: console
342 | 
343 |     type
344 | 
345 | |   É do tipo "tipo"
346 | 
347 | 
348 | 
349 | Valor de str?:
350 | 
351 | .. code-block:: python
352 | 
353 |     str
354 | 
355 | .. code-block:: console
356 | 
357 |     1
358 | 
359 | 
360 | 
361 | Chamar a str built-in para converter a str redefinida:
362 | 
363 | .. code-block:: python
364 | 
365 |     __builtins__.str(str)
366 | 
367 | .. code-block:: console
368 | 
369 |     '1'
370 | 
371 | 
372 | 
373 | Apagando a variável:
374 | 
375 | .. code-block:: python
376 | 
377 |     del str
378 | 
379 | 
380 | 
381 | Função built-in str:
382 | 
383 | .. code-block:: python
384 | 
385 |     str(7)
386 | 
387 | .. code-block:: console
388 | 
389 |     '7'
390 | 
391 | |   Observe que a função não foi removida, apenas a variável criada por redefinição.    
392 | 
393 | 
394 | 
395 | Verificar todos identificadores built-ins:
396 | 
397 | .. code-block:: python
398 | 
399 |     dir(__builtins__)
400 | 
401 | |   . . .
402 | 
403 | 
404 | 
405 | Funções globals(), locals() e vars() e Comando global
406 | -----------------------------------------------------
407 | 
408 | |   Cada uma das funções retornam dicionários de variáveis e seus respectivos valores.
409 | 
410 | - globals(): Retorna variáveis globais (escopo do módulo);
411 | - locals(): Retorna variáveis locais (escopo local);
412 | - vars(obj): sem argumentos é equivalente a locals(), com um argumento, equivalente a objeto.__dict__.
413 | 
414 | 
415 | 
416 | Variável em um escopo global:
417 | 
418 | .. code-block:: python
419 | 
420 |     foo = 'escopo global'
421 | 
422 | 
423 | 
424 | Função de teste:
425 | 
426 | .. code-block:: python
427 | 
428 |     def f():
429 |         foo = 'escopo local'
430 |         bar = 'uma variável qualquer...'
431 |         print(globals()['foo'])  # Valor do identificador global
432 |         print(locals()['foo'])  # Valor do identificador local
433 | 
434 | 
435 | 
436 | Chamada da função:
437 | 
438 | .. code-block:: python
439 | 
440 |     f()
441 | 
442 | .. code-block:: console
443 | 
444 |     escopo global
445 |     escopo local
446 | 
447 | 
448 | 
449 | Criação de uma classe de teste:
450 | 
451 | .. code-block:: python
452 | 
453 |     class Spam(object):
454 |         foo = ''
455 |         bar = ''
456 | 
457 | 
458 | 
459 | "foo" e "bar" ambos identificadores estão contidos em "vars(Spam)"?:
460 | 
461 | .. code-block:: python
462 | 
463 |     set(('foo', 'bar')).issubset(vars(Spam))
464 | 
465 | .. code-block:: console
466 | 
467 |     True
468 | 
469 | 
470 | 
471 | Função de teste:
472 | 
473 | .. code-block:: python
474 | 
475 |     def f():
476 |         global x
477 |         x = 7
478 | 
479 | 
480 | 
481 | Verificando o tipo:
482 | 
483 | .. code-block:: python
484 | 
485 |     type(x)
486 | 
487 | .. code-block:: console
488 | 
489 |     NameError: name 'x' is not defined
490 | 
491 | |   A variável "x" não existe ainda.    
492 | 
493 | 
494 | 
495 | Executando a função:
496 | 
497 | .. code-block:: python
498 | 
499 |     f()
500 | 
501 | 
502 | 
503 | Verificando o tipo:
504 | 
505 | .. code-block:: python
506 | 
507 |     type(x)
508 | 
509 | .. code-block:: console
510 | 
511 |     int
512 | 
513 | 
514 | 
515 | Exibir o valor da variável:
516 | 
517 | .. code-block:: python
518 | 
519 |     print(x)
520 | 
521 | .. code-block:: console
522 | 
523 |     7


--------------------------------------------------------------------------------
/source/content/dict.rst:
--------------------------------------------------------------------------------
  1 | Dicionários
  2 | ***********
  3 | 
  4 |     Em Python um dicionário é uma estrutura de dados envolta por chaves cujos elementos são compostos por chave:valor e separados por vírgula.
  5 | 
  6 | 
  7 | 
  8 | Dicionário vazio:
  9 | 
 10 | .. code-block:: python
 11 | 
 12 |     d = {}
 13 | 
 14 | 
 15 | 
 16 | Criação de um dicionário utilizando a função dict:
 17 | 
 18 | .. code-block:: python
 19 | 
 20 |     d = dict(chave1 = 'valor2', chave2 = 1980)
 21 | 
 22 | 
 23 | 
 24 | Criação de um dicionário utilizando chaves:
 25 | 
 26 | .. code-block:: python
 27 | 
 28 |     d = {
 29 |          'nome': 'Chiquinho',
 30 |          'sobrenome': 'da Silva',
 31 |          'email': 'chiquinho.silva@zeninguem.com',
 32 |         }
 33 | 
 34 | 
 35 | 
 36 | Exibir o valor de uma chave do dicionário:
 37 | 
 38 | .. code-block:: python
 39 | 
 40 |     d['nome']
 41 | 
 42 | .. code-block:: console
 43 | 
 44 |     'Chiquinho'
 45 | 
 46 | 
 47 | Loop para exibir cada par de chave e valor do dicionário:
 48 | 
 49 | .. code-block:: python
 50 | 
 51 |     for k in d:
 52 |         print(f'{k} = {d[k]}')
 53 | 
 54 | .. code-block:: console
 55 | 
 56 |     nome = Chiquinho
 57 |     sobrenome = da Silva
 58 |     email = chiquinho.silva@zeninguem.com
 59 | 
 60 | 
 61 | 
 62 | Loop para exibir cada par de chave e valor do dicionário ordenado por chave:
 63 | 
 64 | .. code-block:: python
 65 | 
 66 |     for k in sorted(d):
 67 |         print(f'{k} = {d[k]}')
 68 | 
 69 | .. code-block:: console
 70 | 
 71 |     email = chiquinho.silva@zeninguem.com
 72 |     nome = Chiquinho
 73 |     sobrenome = da Silva
 74 | 
 75 | 
 76 | 
 77 | Itens do dicionário:
 78 | 
 79 | .. code-block:: python
 80 | 
 81 |     d.items()
 82 | 
 83 | .. code-block:: console
 84 | 
 85 |     dict_items([('nome', 'Chiquinho'), ('sobrenome', 'da Silva'), ('email', 'chiquinho.silva@zeninguem.com')])
 86 | 
 87 | 
 88 | 
 89 | 
 90 | Loop sobre os itens do dicionário:
 91 | 
 92 | .. code-block:: python
 93 | 
 94 |     for k, v in d.items():
 95 |         print(f'{k} = {v}')
 96 | 
 97 | .. code-block:: console
 98 | 
 99 |     nome = Chiquinho
100 |     sobrenome = da Silva
101 |     email = chiquinho.silva@zeninguem.com
102 | 
103 | 
104 | 
105 | Método para exibir as chaves do dicionário:
106 | 
107 | .. code-block:: python
108 | 
109 |     d.keys()
110 | 
111 | .. code-block:: console
112 | 
113 |     dict_keys(['nome', 'sobrenome', 'email'])
114 | 
115 | 
116 | 
117 | Método para exibir as chaves do dicionário:
118 | 
119 | .. code-block:: python
120 | 
121 |     d.values()
122 | 
123 | .. code-block:: console
124 | 
125 |     dict_values(['Chiquinho', 'da Silva', 'chiquinho.silva@zeninguem.com'])
126 | 
127 | 
128 | 
129 | Método para limpar o dicionário:
130 | 
131 | .. code-block:: python
132 | 
133 |     d.clear()
134 | 
135 | 
136 | 
137 | Dicionário após a execução do método clear:
138 | 
139 | .. code-block:: python
140 | 
141 |     d
142 | 
143 | .. code-block:: console
144 | 
145 |     {}
146 | 
147 | 
148 | 
149 | Método update para adicionar chaves e valores:
150 | 
151 | .. code-block:: python
152 | 
153 |     d.update({
154 |               'nome': 'Chiquinho',
155 |               'sobrenome': 'da Silva',
156 |               'email': 'chiquinho.silva@zeninguem.com',
157 |              }
158 |             )
159 | 
160 | 
161 | 
162 | Exibindo o conteúdo do dicionário:
163 | 
164 | .. code-block:: python
165 | 
166 |     d
167 | 
168 | .. code-block:: console
169 | 
170 |     {'email': 'chiquinho.silva@zeninguem.com',
171 |      'nome': 'Chiquinho',
172 |      'sobrenome': 'da Silva'}
173 | 
174 | 
175 | 
176 | Adicionando uma chave e valor ao dicionário:
177 | 
178 | .. code-block:: python
179 | 
180 |     d.update({'data_nascimento': '28/02/1936'})
181 | 
182 | 
183 | 
184 | Exibindo o conteúdo do dicionário:
185 | 
186 | .. code-block:: python
187 | 
188 |     d
189 | 
190 | .. code-block:: console
191 | 
192 |     {'nome': 'Chiquinho',
193 |      'sobrenome': 'da Silva',
194 |      'email': 'chiquinho.silva@zeninguem.com',
195 |      'data_nascimento': '28/02/1936'}
196 | 
197 | 
198 | 
199 | Alterando uma chave do dicionário:
200 | 
201 | .. code-block:: python
202 | 
203 |     d['data_nascimento'] = '08/02/1936'
204 | 
205 | 
206 | 
207 | Exibindo o conteúdo do dicionário:
208 | 
209 | .. code-block:: python
210 | 
211 |     d
212 | 
213 | .. code-block:: console
214 | 
215 |     {'nome': 'Chiquinho',
216 |      'sobrenome': 'da Silva',
217 |      'email': 'chiquinho.silva@zeninguem.com',
218 |      'data_nascimento': '08/02/1936'}
219 | 
220 | 
221 | 
222 | Adicionando uma nova chave e valor:
223 | 
224 | .. code-block:: python
225 | 
226 |     d['cidade_origem'] = 'Cascatinha'
227 | 
228 | 
229 | Exibindo o conteúdo do dicionário:
230 | 
231 | .. code-block:: python
232 | 
233 |     d
234 | 
235 | .. code-block:: console
236 | 
237 |     {'nome': 'Chiquinho',
238 |      'sobrenome': 'da Silva',
239 |      'email': 'chiquinho.silva@zeninguem.com',
240 |      'data_nascimento': '08/02/1936',
241 |      'cidade_origem': 'Cascatinha'}
242 | 
243 | Como chave só são aceitos tipos que utilizam hash, listas não são aceitas, mas
244 | instâncias de classes e tuplas são aceitas.
245 | 
246 | 
247 | 
248 | Criação de uma lista e uma tupla respectivamente:
249 | 
250 | .. code-block:: python
251 | 
252 |     l = [1, 2, 3]
253 |     t = (5, 7)
254 | 
255 | 
256 | 
257 | Criação de uma classe para teste:
258 | 
259 | .. code-block:: python
260 | 
261 |     class Funcionario(object):
262 |         pass
263 | 
264 | 
265 | 
266 | Objeto da classe Funcionário:
267 | 
268 | .. code-block:: python
269 | 
270 |     f1 = Funcionario()
271 | 
272 | 
273 | 
274 | Tentativa de fazer uma lista ser chave do dicionário e atribuir um valor:
275 | 
276 | .. code-block:: python
277 | 
278 |     d[l] = 0
279 | 
280 | .. code-block:: console
281 | 
282 |     TypeError: unhashable type: 'list'
283 | 
284 | Listas são "unhashable", portanto não podem ser chaves de um dicionário.
285 | 
286 | 
287 | 
288 | Objeto da classe Funcionário como chave do dicionário:
289 | 
290 | .. code-block:: python
291 | 
292 |     d[f1] = 'Funcionário 1'
293 | 
294 | 
295 | Exibir o conteúdo do dicionário:
296 | 
297 | .. code-block:: python
298 | 
299 |     d
300 | 
301 | .. code-block:: console
302 | 
303 |     {'nome': 'Chiquinho',
304 |      'sobrenome': 'da Silva',
305 |      'email': 'chiquinho.silva@zeninguem.com',
306 |      'data_nascimento': '08/02/1936',
307 |      'cidade_origem': 'Cascatinha',
308 |      <__main__.Funcionario at 0x7f3769ca9c88>: 'Funcionário 1'}
309 | 
310 | 
311 | 
312 | Tupla como chave do dicionário e atribuir um valor:
313 | 
314 | .. code-block:: python
315 | 
316 |     d[t] = 0
317 | 
318 | 
319 | 
320 | Exibir o conteúdo do dicionário:
321 | 
322 | .. code-block:: python
323 | 
324 |     d
325 | 
326 | .. code-block:: console
327 | 
328 |     {'nome': 'Chiquinho',
329 |      'sobrenome': 'da Silva',
330 |      'email': 'chiquinho.silva@zeninguem.com',
331 |      'data_nascimento': '08/02/1936',
332 |      'cidade_origem': 'Cascatinha',
333 |      <__main__.Funcionario at 0x7f3769ca9c88>: 'Funcionário 1',
334 |      (5, 7): 0}
335 | 
336 | 
337 | 
338 | Tentativa de acessar uma chave inexistente:
339 | 
340 | .. code-block:: python
341 | 
342 |     d[endereco]
343 | 
344 | .. code-block:: console
345 | 
346 |     NameError: name 'endereco' is not defined
347 | 
348 | 
349 | 
350 | Método get:
351 | 
352 | .. code-block:: python
353 | 
354 |     d.get('nome')
355 | 
356 | .. code-block:: console
357 | 
358 |     'Chiquinho'
359 | 
360 | Existe a chave "nome", então seu valor foi retornado.
361 | 
362 | .. code-block:: python
363 | 
364 |     d.get('endereco')
365 | 
366 | Não existe a chave "endereço", por isso nada foi retornado, no entanto, não
367 | foi lançada exceção.
368 | 
369 | .. code-block:: python
370 | 
371 |     d.get('endereco', 'R. do Cafezal, 30')
372 | 
373 | .. code-block:: console
374 | 
375 |     'R. do Cafezal, 30'
376 | 
377 | Não existe a chave "endereço", mas no método get foi passado um segundo
378 | parâmetro, o qual foi retornado, porém não houve modificação no dicionário.
379 | 
380 | .. code-block:: python
381 | 
382 |     d.get('nome', 'Zezinho')
383 | 
384 | .. code-block:: console
385 | 
386 |     'Chiquinho'
387 | 
388 | A chave "nome" já existia, sendo um valor diferente do valor da mesma, foi
389 | retornado o valor que pertence à chave.
390 | 
391 | 
392 | 
393 | Criação de um dicionário:
394 | 
395 | .. code-block:: python
396 | 
397 |     carro = {
398 |              'marca': 'Fiat',
399 |              'modelo': '147'
400 |             }
401 | 
402 | 
403 | 
404 | Tentando acessar uma chave inexistente:
405 | 
406 | .. code-block:: python
407 | 
408 |     carro['cor']
409 | 
410 | .. code-block:: console
411 | 
412 |     KeyError: 'cor'
413 | 
414 | 
415 | 
416 | Método get apenas para retorno:
417 | 
418 | .. code-block:: python
419 | 
420 |     carro.get('cor', 'amarelo')
421 | 
422 | .. code-block:: console
423 | 
424 |     'amarelo'
425 | 
426 | 
427 | 
428 | Verificando o conteúdo do dicionário:
429 | 
430 | .. code-block:: python
431 | 
432 |     carro
433 | 
434 | .. code-block:: console
435 | 
436 |     {'marca': 'Fiat', 'modelo': '147'}
437 | 
438 | 
439 | 
440 | Método setdefault:
441 | 
442 | .. code-block:: python
443 | 
444 |     carro.setdefault('modelo', 'Topazio')
445 | 
446 | .. code-block:: console
447 | 
448 |     '147'
449 | 
450 | Já havia uma chave "modelo", então foi retornado seu valor e não o segundo
451 | parâmetro fornecido.
452 | 
453 | 
454 | 
455 | .. code-block:: python
456 | 
457 |     carro.setdefault('cor', 'verde')
458 | 
459 | .. code-block:: console
460 | 
461 |     'verde'
462 | 
463 | Não havia uma chave "cor", agora ela e seu valor fazem parte do dicionário.
464 | 
465 | 
466 | 
467 | Verificando o conteúdo do dicionário:
468 | 
469 | .. code-block:: python
470 | 
471 |     carro
472 | 
473 | .. code-block:: console
474 | 
475 |     {'cor': 'verde', 'marca': 'Fiat', 'modelo': '147'}
476 | 
477 | 
478 | 
479 | Método update para alterar valores de chaves pré existentes ou mesmo para
480 | adicionar novos pares de chave-valor:
481 | 
482 | .. code-block:: python
483 | 
484 |     carro.update(modelo = 'Topazio', cor = 'cinza')
485 | 
486 | 
487 | Verificando o conteúdo do dicionário:
488 | 
489 | .. code-block:: python
490 | 
491 |     carro
492 | 
493 | .. code-block:: console
494 | 
495 |     {'cor': 'cinza', 'marca': 'Fiat', 'modelo': 'Topazio'}
496 | 
497 | 
498 | 
499 | Método pop; retira uma chave do dicionário e retorna seu valor:
500 | 
501 | .. code-block:: python
502 | 
503 |     carro.pop('cor')
504 | 
505 | .. code-block:: console
506 | 
507 |     'cinza'
508 | 
509 | 
510 | 
511 | Verificando o conteúdo do dicionário:
512 | 
513 | .. code-block:: python
514 | 
515 |     carro
516 | 
517 | .. code-block:: console
518 | 
519 |     {'marca': 'Fiat', 'modelo': 'Topazio'}
520 | 
521 | 
522 | 
523 | Método pop para uma chave que não existe:
524 | 
525 | .. code-block:: python
526 | 
527 |     carro.pop('ano')
528 | 
529 | .. code-block:: console
530 | 
531 |     KeyError: 'ano'
532 | 
533 | 
534 | 
535 | Método pop para uma chave que não existe, mas fornecendo um valor:
536 | 
537 | .. code-block:: python
538 | 
539 |     carro.pop('ano', 1981)
540 | 
541 | .. code-block:: console
542 | 
543 |     1981
544 | 
545 | O dicionário continua sem a chave, mas não lançou uma exceção.
546 | 
547 | 
548 | 
549 | Existe a chave "marca" no dicionário?:
550 | 
551 | .. code-block:: python
552 | 
553 |     'marca' in carro
554 | 
555 | .. code-block:: console
556 | 
557 |     True
558 | 
559 | 
560 | 
561 | Existe a chave "cor" no dicionário?:
562 | 
563 | .. code-block:: python
564 | 
565 |     'cor' in carro
566 | 
567 | .. code-block:: console
568 | 
569 |     False
570 | 
571 | 
572 | Adicionando novas chaves e seus respectivos valores:
573 | 
574 | .. code-block:: python
575 | 
576 |     carro['cor'] = 'cinza'
577 |     carro['ano'] = 1981
578 | 
579 | 
580 | 
581 | Verificando o conteúdo do dicionário:
582 | 
583 | .. code-block:: python
584 | 
585 |     carro
586 | 
587 | .. code-block:: console
588 | 
589 |     {'marca': 'Fiat', 'modelo': 'Topazio', 'cor': 'cinza', 'ano': 1981}


--------------------------------------------------------------------------------
/source/content/list.rst:
--------------------------------------------------------------------------------
  1 | Lista
  2 | *****
  3 | 
  4 |     Uma lista é uma estrutura de dados similar ao tradicional array que tem em
  5 |     outras linguagens, porém seus elementos podem ser de tipos diferentes.
  6 |     Uma lista é também uma coleção de dados mutável, pois sua estrutura pode ser mudada.
  7 | 
  8 | 
  9 | 
 10 | Formas de criar uma lista vazia:
 11 | 
 12 | .. code-block:: python
 13 | 
 14 |     l = []
 15 | 
 16 | ou 
 17 | 
 18 | .. code-block:: python
 19 | 
 20 |     l = list()
 21 | 
 22 | 
 23 | 
 24 | Formas de criar uma lista com elementos:
 25 | 
 26 | .. code-block:: python
 27 | 
 28 |     l = list([1, 2, 3])
 29 | 
 30 | ou
 31 | 
 32 | .. code-block:: python
 33 | 
 34 |     l = [1, 2, 3]
 35 | 
 36 | 
 37 | 
 38 | Declaração de uma nova lista:
 39 | 
 40 | .. code-block:: python
 41 | 
 42 |     x = ['a', 'b', 3, 4.0]
 43 | 
 44 | 
 45 | 
 46 | Exibindo o terceiro elemento da lista:
 47 | 
 48 | .. code-block:: python
 49 | 
 50 |     print(x[2])
 51 | 
 52 | .. code-block:: console
 53 | 
 54 |     3
 55 | 
 56 | 
 57 | 
 58 | Alterando o terceiro elemento da lista:
 59 | 
 60 | .. code-block:: python
 61 | 
 62 |     x[2] = 30
 63 | 
 64 | 
 65 | 
 66 | Exibindo o terceiro elemento da lista:
 67 | 
 68 | .. code-block:: python
 69 | 
 70 |     print(x[2])
 71 | 
 72 | .. code-block:: console
 73 | 
 74 |     30
 75 | 
 76 | 
 77 | 
 78 | Exibindo os elementos da lista:
 79 | 
 80 | .. code-block:: python
 81 | 
 82 |     print(x)
 83 | 
 84 | .. code-block:: console
 85 | 
 86 |     ['a', 'b', 30, 4.0]
 87 | 
 88 | 
 89 | 
 90 | Existe "7" na lista?:
 91 | 
 92 | .. code-block:: python
 93 | 
 94 |     7 in x
 95 | 
 96 | .. code-block:: console
 97 | 
 98 |     False
 99 | 
100 | 
101 | 
102 | Existe "3" na lista?:
103 | 
104 | .. code-block:: python
105 | 
106 |     3 in x
107 | 
108 | .. code-block:: console
109 | 
110 |     True
111 | 
112 | 
113 | 
114 | O método append adiciona um elemento ao final da lista:
115 | 
116 | .. code-block:: python
117 | 
118 |     x.append('Uma string qualquer...')
119 | 
120 | 
121 | 
122 | Exibindo os elementos da lista:
123 | 
124 | .. code-block:: python
125 | 
126 |     print(x)
127 | 
128 | .. code-block:: console
129 | 
130 |     ['a', 'b', 30, 4.0, 'Uma string qualquer...']
131 | 
132 | 
133 | 
134 | O método extend faz com que os elementos de outra lista sejam adicionadas a
135 | uma lista atual:
136 | 
137 | .. code-block:: python
138 | 
139 |     foo = ['a', 'b', 'c']  # Definição da primeira lista
140 |     bar = [1, 2]  # Definição da segunda lista
141 |     foo.extend(bar)  # Extendendo a primeira lista com os elementos da segunda
142 |     print(foo)  # Exibindo a lista extendida
143 | 
144 | .. code-block:: console
145 | 
146 |     ['a', 'b', 'c', 1, 2]
147 | 
148 | 
149 | 
150 | O operador "+" sendo utilizado para criar uma nova lista a partir de outra somada à outra:
151 | 
152 | .. code-block:: python
153 | 
154 |     y = x + ['abobrinha', '7', {'chave': 'valor'}, ('SP', 'MG', 'PR', 'RO')]
155 | 
156 | 
157 | 
158 | Exibindo a nova lista:
159 | 
160 | .. code-block:: python
161 | 
162 |     y
163 | 
164 | .. code-block:: python
165 | 
166 |     ['a',
167 |      'b',
168 |      30,
169 |      4.0,
170 |      'Uma string qualquer...',
171 |      'abobrinha',
172 |      '7',
173 |      {'chave': 'valor'},
174 |      ('SP', 'MG', 'PR', 'RO')]
175 | 
176 | 
177 | 
178 | Utilizando "+=" como um atalho para o método extend e exibindo seu novo conteúdo:
179 | 
180 | .. code-block:: python
181 | 
182 |     x += ['xyz']
183 |     x
184 | 
185 | .. code-block:: console
186 | 
187 |     ['a', 'b', 30, 4.0, 'Uma string qualquer...', 'xyz']
188 | 
189 | 
190 | 
191 | Removendo um elemento da lista e exibindo seu novo conteúdo:
192 | 
193 | .. code-block:: python
194 | 
195 |     x.remove('xyz')
196 |     x
197 | 
198 | .. code-block:: console
199 | 
200 |     ['a', 'b', 30, 4.0, 'Uma string qualquer...']
201 | 
202 | 
203 | 
204 | Método extend com uma lista como parâmetro:
205 | 
206 | .. code-block:: python
207 | 
208 |     x.extend(['xyz'])
209 |     x
210 | 
211 | .. code-block:: console
212 | 
213 |     ['a', 'b', 30, 4.0, 'Uma string qualquer...', 'xyz']
214 | 
215 | 
216 | 
217 | Método extend com uma string como parâmetro:
218 | 
219 | .. code-block:: python
220 | 
221 |     x.extend('xyz')
222 |     x
223 | 
224 | .. code-block:: console
225 | 
226 |     ['a', 'b', 30, 4.0, 'Uma string qualquer...', 'xyz', 'x', 'y', 'z']
227 | 
228 | Ao utilizarmos uma string como parâmetro do método extend, a string foi
229 | convertida em lista de forma a transformar cada caractere em elemento
230 | de uma lista.
231 | 
232 | 
233 | 
234 | Método append:
235 | 
236 | .. code-block:: python
237 | 
238 |     x.append('xyz')
239 |     x
240 | 
241 | .. code-block:: console
242 | 
243 |     ['a', 'b', 30, 4.0, 'Uma string qualquer...', 'xyz', 'x', 'y', 'z', 'xyz']
244 | 
245 | Aqui podemos ver claramente a diferença entre os métodos extend e append, que
246 | pode causar uma certa confusão inicial para quem está iniciando em Python.
247 | Nota-se que o método append adicionou a string inteira como um novo elemento
248 | da lista.
249 | 
250 | 
251 | 
252 | 
253 | Extendendo a lista com o operador "+=":
254 | 
255 | .. code-block:: python
256 | 
257 |     x += 'String'
258 |     x
259 | 
260 | .. code-block:: console
261 | 
262 |     ['a',
263 |     'b',
264 |     30,
265 |     4.0,
266 |     'Uma string qualquer...',
267 |     'xyz',
268 |     'x',
269 |     'y',
270 |     'z',
271 |     'xyz',
272 |     'S',
273 |     't',
274 |     'r',
275 |     'i',
276 |     'n',
277 |     'g']
278 | 
279 | Como o operador "+=" ser um atalho para o método extend ele transformou a
280 | string numa lista, uma lista cujos elementos são os caracteres da string.
281 | 
282 | 
283 | 
284 | Tentativa de utilizar o operador "+" em uma lista:
285 | 
286 | .. code-block:: python
287 | 
288 |     x + 'bla bla bla'
289 | 
290 | .. code-block:: console
291 | 
292 |     TypeError: can only concatenate list (not "str") to list
293 | 
294 | Não se pode concatenar uma lista com uma string.
295 | 
296 | 
297 | 
298 | Criação de uma nova lista a partir de uma string:
299 | 
300 | .. code-block:: python
301 | 
302 |     z = list('Hobbit')
303 |     z
304 | 
305 | .. code-block:: console
306 | 
307 |     ['H', 'o', 'b', 'b', 'i', 't']
308 | 
309 | 
310 | 
311 | Novamente o método append:
312 | 
313 | .. code-block:: python
314 | 
315 |     z.append('Hobbit')
316 |     z
317 | 
318 | .. code-block:: console
319 | 
320 |     ['H', 'o', 'b', 'b', 'i', 't', 'Hobbit']
321 | 
322 | 
323 | 
324 | Qual o tamanho (quantos elementos) da lista?
325 | 
326 | .. code-block:: python
327 | 
328 |     len(z)
329 | 
330 | .. code-block:: console
331 | 
332 |     7
333 | 
334 | Tamanho 7, posições variam de 0 a 6.
335 | 
336 | 
337 | 
338 | Método insert utilizando a priemira posição (0):
339 | 
340 | .. code-block:: python
341 | 
342 |     z.insert(0, 'Gandalf')
343 |     z
344 | 
345 | .. code-block:: console
346 | 
347 |     ['Gandalf', 'H', 'o', 'b', 'b', 'i', 't', 'Hobbit']
348 | 
349 | 
350 | 
351 | Pode-se também verificar o tamanho de uma lista com o dunder len:
352 | 
353 | .. code-block:: python
354 | 
355 |     z.__len__()
356 | 
357 | .. code-block:: console
358 | 
359 |     8
360 | 
361 | 
362 | 
363 | Dado que a lista tem 8 (oito) elementos, inserir num novo elemento na nona (8) posição:
364 | 
365 | .. code-block:: python
366 | 
367 |     z.insert(8, 'Bilbo')
368 |     z
369 | 
370 | .. code-block:: console
371 | 
372 |     ['Gandalf', 'H', 'o', 'b', 'b', 'i', 't', 'Hobbit', 'Bilbo']
373 | 
374 | O efeito foi o mesmo que utilizar o método append.
375 | 
376 | 
377 | 
378 | O método pop sem parâmetros retorna o último elemento e o apaga da lista:
379 | 
380 | .. code-block:: python
381 | 
382 |     z.pop()
383 | 
384 | .. code-block:: console
385 | 
386 |     'Bilbo'
387 | 
388 | 
389 | .. code-block:: python
390 | 
391 |     z
392 | 
393 | 
394 | .. code-block:: console
395 | 
396 |     ['Gandalf', 'H', 'o', 'b', 'b', 'i', 't', 'Hobbit']
397 | 
398 | 
399 | 
400 | Como o método pop retorna o último elemento, o mesmo pode ser utilizado para atribuição:
401 | 
402 | .. code-block:: python
403 | 
404 |     livro = ('O {}'.format(z.pop()))
405 |     livro
406 | 
407 | .. code-block:: console
408 | 
409 |     'O Hobbit'
410 | 
411 | 
412 | 
413 | Retornando e apagando o sexto elemento:
414 | 
415 | .. code-block:: python
416 | 
417 |     z.pop(5)
418 | 
419 | .. code-block:: console
420 | 
421 |     'i'
422 | 
423 | 
424 | 
425 | 
426 | Método sort, organiza a lista com seus elementos pela ordem alfabética:
427 | 
428 | .. code-block:: python
429 | 
430 |     z.sort()
431 |     z
432 | 
433 | 
434 | 
435 | .. code-block:: console
436 | 
437 |     ['Gandalf', 'H', 'b', 'b', 'i', 'o', 't']
438 | 
439 | 
440 | 
441 | O método reverse pega a atual posição dos elementos e reconstrói a lista
442 | na ordem reversa:
443 | 
444 | .. code-block:: python
445 | 
446 |     z.reverse()
447 |     z
448 | 
449 | .. code-block:: python
450 | 
451 |     ['t', 'o', 'b', 'b', 'H', 'Gandalf']
452 | 
453 | 
454 | 
455 | A função sorted não altera a lista, apenas retorna o conteúdo pela ordem
456 | alfabética:
457 | 
458 | .. code-block:: python
459 | 
460 |     sorted(z)
461 | 
462 | .. code-block:: console
463 | 
464 |     ['Gandalf', 'H', 'b', 'b', 'o', 't']
465 | 
466 | 
467 | .. code-block:: python
468 | 
469 |     z
470 | 
471 | .. code-block:: console
472 | 
473 |     ['t', 'o', 'i', 'b', 'b', 'H', 'Gandalf']
474 | 
475 | 
476 | 
477 | A função sorted também pode somente retornar o reverso de uma lista:
478 | 
479 | .. code-block:: python
480 | 
481 |     sorted([1, 2, 3], reverse=True)
482 | 
483 | .. code-block:: console
484 | 
485 |     [3, 2, 1]
486 | 
487 | 
488 | 
489 | Criação de uma lista a partir do retorno de sorted:
490 | 
491 | .. code-block:: python
492 | 
493 |     w = sorted(z)
494 |     w
495 | 
496 | .. code-block:: console
497 | 
498 |     ['Gandalf', 'H', 'b', 'b', 'o', 't']
499 | 
500 | .. code-block:: python
501 | 
502 |     z
503 | 
504 | .. code-block:: console
505 | 
506 |     ['t', 'o', 'b', 'b', 'H', 'Gandalf']
507 | 
508 | 
509 | 
510 | A função reversed() sempre retorna um iterador:
511 | 
512 | > reversed(z)
513 | 
514 | <listreverseiterator object at 0x1653c10>
515 | 
516 | 
517 | 
518 | Convertendo para lista o iterador gerado pela função reversed:
519 | 
520 | .. code-block:: python
521 | 
522 |     z = list(reversed(z))
523 |     z
524 | 
525 | .. code-block:: console
526 | 
527 |     ['Gandalf', 'H', 'b', 'b', 'o', 't']
528 | 
529 | 
530 | 
531 | Função sorted transforma a string numa lista e organiza por ordem
532 | alfabética:
533 | 
534 | .. code-block:: python
535 | 
536 |     sorted('aAcb')
537 | 
538 | .. code-block:: console
539 | 
540 |     ['A', 'a', 'b', 'c']
541 | 
542 | 
543 | 
544 | Função sorted transforma a string numa lista e organiza por ordem alfabética:
545 | 
546 | .. code-block:: python
547 | 
548 |     sorted('aAcb', reverse=True)
549 | 
550 | .. code-block:: console
551 | 
552 |     ['c', 'b', 'a', 'A']
553 | 
554 | 
555 | 
556 | Função reversed transforma a string em uma lista com seus caracteres em ordem
557 | reversa:
558 | 
559 | .. code-block:: python
560 | 
561 |     list(reversed('aAcb'))
562 | 
563 | .. code-block:: console
564 | 
565 |     ['b', 'c', 'A', 'a']
566 | 
567 | 
568 | 
569 | Definição de lista com 3 (três) elementos:
570 | 
571 | .. code-block:: python
572 | 
573 |     x = [1, 2, 3]
574 | 
575 | 
576 | 
577 | A partir da lista "x", atribuir respectivamente seus elementos como valores
578 | para as variáveis à esquerdae exibir seus valores:
579 | 
580 | .. code-block:: python
581 | 
582 |     a, b, c = x
583 |     print(a)
584 | 
585 | .. code-block:: console
586 | 
587 |     1
588 | 
589 | .. code-block:: python
590 | 
591 |     print(b)
592 | 
593 | .. code-block:: console
594 | 
595 |     2
596 | 
597 | .. code-block:: python
598 | 
599 |     print(c)
600 | 
601 | .. code-block:: console
602 | 
603 |     3
604 | 
605 | 
606 | 
607 | E se a quantidade de variáveis que receberão os valores forem em menor
608 | número que a quantidade de elementos da lista?:
609 | 
610 | .. code-block:: python
611 | 
612 |     y, z, = x
613 | 
614 | .. code-block:: console
615 | 
616 |     ValueError: too many values to unpack (expected 2)
617 | 
618 | Lista com três elementos não pode fazer atribuição respectiva a apenas
619 | duas variáveis.
620 | 
621 | 
622 | 
623 | Utilização do caractere underscore como solução:
624 | 
625 | .. code-block:: python
626 | 
627 |     y, z, _ = x
628 |     print(y)
629 | 
630 | .. code-block:: console
631 | 
632 |     1
633 | 
634 | 
635 | .. code-block:: python
636 | 
637 |     print(z)
638 | 
639 | .. code-block:: console
640 | 
641 |     2


--------------------------------------------------------------------------------
/source/content/open.rst:
--------------------------------------------------------------------------------
  1 | open
  2 | ****
  3 | 
  4 | 
  5 | |   É a forma nativa de Python para manipular arquivos (leitura e escrita).
  6 | |   Um arquivo é iterável, cujas iterações são por linha.
  7 | 
  8 | `open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)`
  9 | 
 10 | +---------+--------------------------------------------------------------------------+
 11 | |**Modo** | **Descrição**                                                            |
 12 | +---------+--------------------------------------------------------------------------+
 13 | | r       | Leitura (padrão).                                                        |
 14 | +---------+--------------------------------------------------------------------------+
 15 | | w       | Escrita (novo arquivo, ou se o mesmo existir será truncado).             |
 16 | +---------+--------------------------------------------------------------------------+
 17 | | x       | Cria um novo arquivo e o abre para escrita.                              |
 18 | +---------+--------------------------------------------------------------------------+
 19 | | a       | Escrita (append; o novo conteúdo é adicionado ao arquivo pré existente). |
 20 | +---------+--------------------------------------------------------------------------+
 21 | | b       | Modo binário.                                                            |
 22 | +---------+--------------------------------------------------------------------------+
 23 | | t       | Modo de texto (padrão).                                                  |
 24 | +---------+--------------------------------------------------------------------------+
 25 | | \+      | Abre um arquivo em disco para a atualização (leitura e escrita).         |
 26 | +---------+--------------------------------------------------------------------------+
 27 | 
 28 | 
 29 | 
 30 | Supondo que o arquivo não exista, criação do mesmo para leitura e escrita:
 31 | 
 32 | .. code-block:: python
 33 | 
 34 |     f = open('/tmp/foo.txt', 'w+')
 35 | 
 36 | 
 37 | 
 38 | Verificando o tipo de f:
 39 | 
 40 | .. code-block:: python
 41 | 
 42 |     type(f)
 43 | 
 44 | .. code-block:: console
 45 | 
 46 |     _io.TextIOWrapper
 47 | 
 48 | 
 49 | 
 50 | Escrevendo no arquivo com a função print:
 51 | 
 52 | .. code-block:: python
 53 | 
 54 |     print('Teste de escrita em arquivo', file=f)
 55 | 
 56 | 
 57 | 
 58 | Uma linha em branco:
 59 | 
 60 | .. code-block:: python
 61 | 
 62 |     print(' ', file=f)
 63 | 
 64 | 
 65 | 
 66 | Mais uma linha...:
 67 | 
 68 | .. code-block:: python
 69 | 
 70 |     print('Uma linha qualquer', file=f)
 71 | 
 72 | 
 73 | 
 74 | Fechando o objeto e aplicando todas as escritas feitas:
 75 | 
 76 | .. code-block:: python
 77 | 
 78 |     f.close()
 79 | 
 80 | 
 81 | 
 82 | Reabrindo o arquivo para somente leitura:
 83 | 
 84 | .. code-block:: python
 85 | 
 86 |     f = open('/tmp/foo.txt', 'r')
 87 | 
 88 | 
 89 | 
 90 | Imprimir o arquivo em tela linha por linha:
 91 | 
 92 | .. code-block:: python
 93 | 
 94 |     for line in f:
 95 |         print(line.strip('\n'))
 96 | 
 97 | 
 98 | 
 99 | Fechamento de arquivo:
100 | 
101 | .. code-block:: python
102 | 
103 |     f.close()
104 | 
105 | 
106 | 
107 | No shell do sistema operacional usar o recurso heredoc para criar linhas em um novo arquivo:
108 | 
109 | .. code-block:: bash
110 | 
111 |     cat << EOF > /tmp/linhas.txt
112 |     linha_1
113 |     linha_2
114 |     linha_3
115 |     EOF
116 | 
117 | 
118 | 
119 | Exibir as linhas:
120 | 
121 | .. code-block:: bash
122 | 
123 |     cat /tmp/linhas.txt
124 | 
125 | .. code-block:: console
126 | 
127 |     linha_1
128 |     linha_2
129 |     linha_3
130 | 
131 | 
132 | 
133 | Em um shell Python abrir o arquivo:
134 | 
135 | .. code-block:: python
136 | 
137 |     f = open('/tmp/linhas.txt')
138 | 
139 | 
140 | 
141 | Método readline:
142 | 
143 | .. code-block:: python
144 | 
145 |     f.readline()
146 | 
147 | .. code-block:: console
148 | 
149 |     'linha_1\n'
150 | 
151 | 
152 | 
153 | Método split na saída do método readline (3X):
154 | 
155 | .. code-block:: python
156 | 
157 |     f.readline().split()
158 | 
159 | .. code-block:: console
160 | 
161 |     ['linha_2']
162 | 
163 | 
164 | .. code-block:: console
165 | 
166 |     ['linha_3']
167 | 
168 | 
169 | .. code-block:: console
170 | 
171 |     []
172 | 
173 | |   O método readline interagiu para cada linha retornando-a até não ter mais nada a ler no arquivo.    
174 | 
175 | 
176 | 
177 | Fechando o arquivo:
178 | 
179 | .. code-block:: python
180 | 
181 |     f.close()
182 | 
183 | 
184 | 
185 | Reabrindo o arquivo:
186 | 
187 | .. code-block:: python
188 | 
189 |     f = open('/tmp/linhas.txt')
190 | 
191 | 
192 | 
193 | Método readlines:
194 | 
195 | .. code-block:: python
196 | 
197 |     f.readlines()
198 | 
199 | .. code-block:: console
200 | 
201 |     ['linha_1\n', 'linha_2\n', 'linha_3\n']
202 | 
203 | |   O método readlines retorna cada linha do arquivo como um elemento de uma lista.    
204 | 
205 | 
206 | 
207 | Fechando o arquivo:
208 | 
209 | .. code-block:: python
210 | 
211 |     f.close()
212 | 
213 | 
214 | 
215 | Criar um script Python cujo comportamento é o mesmo do utilitário shell cat:
216 | 
217 | .. code-block:: bash
218 | 
219 |     vim /tmp/cat.py
220 | 
221 | 
222 | 
223 | Código Python:
224 | 
225 | .. code-block:: python
226 | 
227 |     #!/usr/bin/env python3
228 |     #_*_ encoding: utf8 _*_
229 | 
230 |     import sys
231 | 
232 |     # Primeiro argumento do script
233 |     f = sys.argv[1]
234 | 
235 |     # Abrir o arquivo como somente leitura (sobrescreve a variável original)
236 |     f = open(f, 'r')
237 | 
238 |     # Para cada linha imprimir, com o método strip suprimindo linhas em branco
239 |     # desnecessárias. (Supressão de \n no final de cada linha)
240 |     for i in f:
241 |         print(i.strip())
242 | 
243 |     f.close()
244 | 
245 | 
246 | 
247 | Tornar o script executável:
248 | 
249 | .. code-block:: bash
250 | 
251 |     chmod +x /tmp/cat.py
252 | 
253 | 
254 | 
255 | Teste do script:
256 | 
257 | .. code-block:: bash
258 | 
259 |     /tmp/cat.py /tmp/linhas.txt
260 | 
261 | .. code-block:: console
262 | 
263 |     linha_1
264 |     linha_2
265 |     linha_3
266 | 
267 | 
268 | 
269 | Novo arquivo criado via shell do sistema operacional:
270 | 
271 | .. code-block:: bash
272 | 
273 |     cat << EOF > /tmp/cores.txt
274 |     1 - Verde
275 |     2 - Preto
276 |     3 - Branco
277 |     EOF
278 | 
279 | 
280 | 
281 | Abrir o arquivo em modo somente leitura:
282 | 
283 | .. code-block:: python
284 | 
285 |     f = open('/tmp/cores.txt', 'r')
286 | 
287 | 
288 | 
289 | Um simples loop for sobre o arquivo:
290 | 
291 | .. code-block:: python
292 | 
293 |     for i in f:
294 |         print(i.strip())
295 | 
296 | .. code-block:: python
297 | 
298 |     1 - Verde
299 |     2 - Preto
300 |     3 - Branco
301 | 
302 | 
303 | 
304 | Nova execução do loop:
305 | 
306 | .. code-block:: python
307 | 
308 |     for i in f:
309 |         print(i.strip())
310 | 
311 | 
312 | 
313 | Método seek; posição 0 do cursor:
314 | 
315 | .. code-block:: python
316 | 
317 |     f.seek(0)
318 | 
319 | 
320 | 
321 | Nova execução do loop:
322 | 
323 | .. code-block:: python
324 | 
325 |     for i in f:
326 |         print(i.strip())
327 | 
328 | .. code-block:: console
329 | 
330 |     1 - Verde
331 |     2 - Preto
332 |     3 - Branco
333 | 
334 | 
335 | 
336 | Posição 1:
337 | 
338 | .. code-block:: python
339 | 
340 |     f.seek(1)
341 | 
342 | 
343 | 
344 | Nova execução do loop:
345 | 
346 | .. code-block:: python
347 | 
348 |     for i in f:
349 |         print(i.strip())
350 | 
351 | .. code-block:: console
352 | 
353 |     - Verde
354 |     2 - Preto
355 |     3 - Branco
356 | 
357 | 
358 | 
359 | Posição 0 (zero) do cursor:
360 | 
361 | .. code-block:: python
362 | 
363 |     f.seek(0)
364 | 
365 | 
366 | 
367 | Lê as 7 (sete) primeiras posições:
368 | 
369 | .. code-block:: python
370 | 
371 |     f.read(7)
372 | 
373 | .. code-block:: console
374 | 
375 |     '1 - Ver'
376 | 
377 | 
378 | 
379 | Ler as próximas 7 (sete) posições (repetir):
380 | 
381 | .. code-block:: python
382 | 
383 |     f.read(7)
384 | 
385 | .. code-block:: console
386 | 
387 |     'de\n2 - '
388 | 
389 | .. code-block:: console
390 | 
391 |     'Preto\n3'
392 | 
393 | 
394 | .. code-block:: console
395 | 
396 |     ' - Bran'
397 | 
398 | 
399 | 
400 | Fechar o arquivo:
401 | 
402 | .. code-block:: python
403 | 
404 |     f.close()
405 | 
406 | 
407 | 
408 | Verificar se o arquivo está fechado como o atributo closed:
409 | 
410 | .. code-block:: python
411 | 
412 |     f.closed
413 | 
414 | .. code-block:: console
415 | 
416 |     True
417 | 
418 | 
419 | 
420 | Abrir o arquivo como escrita:
421 | 
422 | .. code-block:: python
423 | 
424 |     f = open('/tmp/cores.txt', 'w')
425 | 
426 | 
427 | 
428 | Verificar se o arquivo está fechado como o atributo closed:
429 | 
430 | .. code-block:: python
431 | 
432 |     f.closed
433 | 
434 | .. code-block:: console
435 | 
436 |     False
437 | 
438 | 
439 | 
440 | Fechar o arquivo:
441 | 
442 | .. code-block:: python
443 | 
444 |     f.close()
445 | 
446 | 
447 | 
448 | Verificar o conteúdo do arquivo via shell do sistema operacional:
449 | 
450 | .. code-block:: bash
451 | 
452 |     cat /tmp/cores.txt
453 | 
454 | 
455 | 
456 | Abrir p arquivo como escrita:
457 | 
458 | .. code-block:: python
459 | 
460 |     f = open('/tmp/cores.txt', 'w')
461 | 
462 | 
463 | 
464 | Escrever no arquivo:
465 | 
466 | .. code-block:: python
467 | 
468 |     f.write('1 - Verde\n')
469 | 
470 | 
471 | 
472 | Fechar o arquivo:
473 | 
474 | .. code-block:: python
475 | 
476 |     f.close()
477 | 
478 | 
479 | 
480 | Verificar o conteúdo do arquivo via shell do sistema operacional:
481 | 
482 | .. code-block:: bash
483 | 
484 |     cat /tmp/cores.txt
485 | 
486 | .. code-block:: console
487 | 
488 |     1 - Verde
489 | 
490 | |   Todo o conteúdo foi substituído por essa linha...    
491 | 
492 | 
493 | 
494 | Exibir a localização do arquivo:
495 | 
496 | .. code-block:: python
497 | 
498 |     print(f.name)
499 | 
500 | .. code-block:: console
501 | 
502 |     /tmp/cores.txt
503 | 
504 | 
505 | 
506 | Abrir o arquivo em modo append:
507 | 
508 | .. code-block:: python
509 | 
510 |     f = open('/tmp/cores.txt', 'a')
511 | 
512 | 
513 | 
514 | Adicionar novas linhas ao arquivo:
515 | 
516 | .. code-block:: python
517 | 
518 |     f.write('2 - Preto\n')
519 |     f.write('3 - Branco\n')
520 | 
521 | 
522 | 
523 | Efetivar a escrita no arquivo sem fechá-lo:
524 | 
525 | .. code-block:: python
526 | 
527 |     f.flush()
528 | 
529 | 
530 | 
531 | Verificar o conteúdo do arquivo via shell do sistema operacional:
532 | 
533 | .. code-block:: bash
534 | 
535 |     cat /tmp/cores.txt
536 | 
537 | .. code-block:: console
538 | 
539 |     1 - Verde
540 |     2 - Preto
541 |     3 - Branco
542 | 
543 | 
544 | 
545 | Fechar o arquivo:
546 | 
547 | .. code-block:: python
548 | 
549 |     f.close()
550 | 
551 | 
552 | 
553 | Abrir o arquivo em modo leitura:
554 | 
555 | .. code-block:: python
556 | 
557 |     f = open('/tmp/cores.txt', 'r')
558 | 
559 | 
560 | 
561 | Método tell; retorna a posição atual:
562 | 
563 | .. code-block:: python
564 | 
565 |     f.tell()
566 | 
567 | .. code-block:: console
568 | 
569 |     0
570 | 
571 | 
572 | 
573 | Método read:
574 | 
575 | .. code-block:: python
576 | 
577 |     f.read()
578 | 
579 | .. code-block:: console
580 | 
581 |     '1 - Verde\n2 - Preto\n3 - Branco\n'
582 | 
583 | 
584 | 
585 | Veriricando a atual posição:
586 | 
587 | .. code-block:: python
588 | 
589 |     f.tell()
590 | 
591 | .. code-block:: console
592 | 
593 |     31
594 | 
595 | 
596 | 
597 | Método seek recoloca o cursor na posição 0 (zero):
598 | 
599 | .. code-block:: python
600 | 
601 |     f.seek(0)
602 | 
603 | .. code-block:: console
604 | 
605 |     0
606 | 
607 | 
608 | 
609 | Método tell confirma:
610 | 
611 | .. code-block:: python
612 | 
613 |     f.tell()
614 | 
615 | .. code-block:: console
616 | 
617 |     0
618 | 
619 | 
620 | 
621 | Ler 7 (sete) posições adiante:
622 | 
623 | .. code-block:: python
624 | 
625 |     f.read(7)
626 | 
627 | .. code-block:: console
628 | 
629 |     '1 - Ver'
630 | 
631 | 
632 | 
633 | Método tell:
634 | 
635 | .. code-block:: python
636 | 
637 |     f.tell()
638 | 
639 | .. code-block:: console
640 | 
641 |     7
642 | 
643 | 
644 | 
645 | Fechar o arquivo:
646 | 
647 | .. code-block:: python
648 | 
649 |     f.close()
650 | 
651 | 
652 | 
653 | Criar um novo arquivo como escrita:
654 | 
655 | .. code-block:: python
656 | 
657 |     f = open('/tmp/planetas.txt', 'w')
658 | 
659 | 
660 | 
661 | Tupla com 3 (três) elementos:
662 | 
663 | .. code-block:: python
664 | 
665 |     planetas = ('Saturno\n', 'Urano\n', 'Netuno\n')
666 | 
667 | 
668 | 
669 | Escreve linhas no arquivo com os elementos da tupla:
670 | 
671 | .. code-block:: python
672 | 
673 |     f.writelines(planetas)
674 | 
675 | 
676 | 
677 | Efetiva a escrita:
678 | 
679 | .. code-block:: python
680 | 
681 |     f.flush()
682 | 
683 | 
684 | 
685 | Verificando o conteúdo do arquivo via shell do sistema operacional:
686 | 
687 | .. code-block:: bash
688 | 
689 |     cat /tmp/planetas.txt
690 | 
691 | .. code-block:: console
692 | 
693 |     Saturno
694 |     Urano
695 |     Netuno
696 | 
697 | 
698 | 
699 | Redefinindo a tupla com outros elementos:
700 | 
701 | .. code-block:: python
702 | 
703 |     planetas = ('Marte\n', 'Vênus\n', 'Plutão\n', 'Júpiter\n')
704 | 
705 | 
706 | 
707 | Escrevendo (adicionando) linhas:
708 | 
709 | .. code-block:: python
710 | 
711 |     f.writelines(planetas)
712 | 
713 | 
714 | 
715 | Fechar o arquivo:
716 | 
717 | .. code-block:: python
718 | 
719 |     f.close()
720 | 
721 | 
722 | 
723 | Verificando o conteúdo do arquivo via shell do sistema operacional:
724 | 
725 | .. code-block:: bash
726 | 
727 |     cat /tmp/planetas.txt
728 | 
729 | .. code-block:: console
730 | 
731 |     Saturno
732 |     Urano
733 |     Netuno
734 |     Marte
735 |     Vênus
736 |     Plutão
737 |     Júpiter


--------------------------------------------------------------------------------
/source/content/language_particularities.rst:
--------------------------------------------------------------------------------
  1 | Particularidades da Linguagem
  2 | *****************************
  3 | 
  4 | Palavras Reservadas
  5 | -------------------
  6 | 
  7 | Palavras reservadas ou em inglês *keywords* são
  8 | 
  9 | .. code-block:: text
 10 | 
 11 |     False   class     finally  is        return  
 12 |     None    continue  for      lambda    try     
 13 |     True    def       from     nonlocal  while   
 14 |     and     del       global   not       with    
 15 |     as      elif      if       or        yield   
 16 |     assert  else      import   pass              
 17 |     break   except    in       raise
 18 | 
 19 | Podemos verificar as palavras reservdas de Python usando código:
 20 | 
 21 | .. code-block:: python
 22 | 
 23 |     from keyword import kwlist as keywords
 24 | 
 25 |     for i in keywords:
 26 |         print(i)
 27 | 
 28 | .. code-block:: console
 29 | 
 30 |     . . .
 31 | 
 32 | 
 33 | 
 34 | Definição do Interpretador de Comandos
 35 | --------------------------------------
 36 | 
 37 | 	Para scripts Python, na primeira linha podemos especificar o interpretador de comandos a ser utilizado, também conhecido como shebang;
 38 | 
 39 | .. code-block:: python
 40 |     :linenos:
 41 | 
 42 |     #!/usr/bin/env python3
 43 | 
 44 | .. note::
 45 | 
 46 |     Em ambientes Windows não é preciso espeficar, isso é pertinente a ambientes Unix.
 47 | 
 48 | Codificação (Conjunto de Caracteres - Encoding)
 49 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 50 | 
 51 | 	É possível utilizar codificações diferentes de ASCII em arquivos de código-fonte.
 52 | 	A melhor maneira de se fazer isso é colocar uma linha especial no começo do arquivo, se foi especificado o interpretador, deve vir logo depois dele:
 53 | 
 54 | .. code-block:: python
 55 |     :linenos:
 56 | 
 57 |     # _*_ encoding: utf-8 _*_
 58 | 
 59 | 
 60 | .. code-block:: bash
 61 | 
 62 |      vim /tmp/hello.py
 63 | 
 64 | .. code-block:: python
 65 |     :linenos:
 66 | 
 67 |     #!/usr/bin/env python
 68 | 
 69 |     print('Olá!')
 70 | 
 71 | .. code-block:: bash
 72 | 
 73 |     $ python /tmp/hello.py
 74 | 
 75 | .. code-block:: console
 76 | 
 77 |     File "/tmp/hello.py", line 4
 78 |     SyntaxError: Non-ASCII character '\xc3' in file /tmp/hello.py on line 4, but no encoding declared; see http://www.python.org/peps/pep-0263.html for details
 79 | 
 80 | Editar o script Python:
 81 | 
 82 | .. code-block:: bash
 83 |     vim /tmp/hello.py
 84 | 
 85 | .. code-block:: python
 86 |     :linenos:
 87 | 
 88 |     #!/usr/bin/env python
 89 |     #_*_ coding: utf-8 _*_
 90 | 
 91 |     print('Olá!')
 92 | 
 93 | Executar o script:
 94 | 
 95 | .. code-block:: bash
 96 | 
 97 |     python /tmp/hello.py
 98 | 
 99 | .. code-block:: console
100 | 
101 |     Olá!
102 | 
103 | Case Sensitive
104 | --------------
105 | 
106 | 	Python é case sensitive, ou seja, letras maiúsculas e minúsculas são interpretadas de formas diferentes.
107 | 
108 | 
109 | .. code-block:: python
110 | 
111 |     foo = 'bar'
112 |     Foo = 'foo'
113 |     print(foo)
114 | 
115 | .. code-block:: console
116 | 
117 |     bar
118 | 
119 | .. code-block:: python
120 | 
121 |     print(Foo)
122 | 
123 | .. code-block:: console
124 | 
125 |     foo
126 | 
127 | Não Suporta Sobrecarga de Funções / Métodos
128 | -------------------------------------------
129 | 
130 | 	Àqueles que vêm de Java deve estranhar dentre outras coisas o fato de Python não suportar sobrecarga de funções e métodos.
131 | 	Quando uma mesma função é escrita duas ou mais vezes, o que prevalece é a última definição.
132 | 
133 | .. code-block:: python
134 | 
135 |     # Definição da função sem parâmetro
136 |     def hello_world():
137 |         print('Hello World')
138 | 
139 |     # (Re)Definição da função com um parâmetro
140 |     def hello_world(string):
141 |         print(string)
142 | 
143 |     # Tentativa de execução sem parâmetro    
144 |     hello_world()
145 | 
146 | .. code-block:: console
147 | 
148 |     Traceback (most recent call last):
149 |       File "<input>", line 1, in <module>
150 |         hello_world()
151 |     TypeError: hello_world() missing 1 required positional argument: 'string'
152 | 
153 | 
154 | .. code-block:: python
155 | 
156 |     hello_world('foo')
157 | 
158 | .. code-block:: console
159 | 
160 |     foo
161 | 
162 | Orientada a Objetos
163 | -------------------
164 | 
165 | 	Em Python tudo é objeto.
166 | 	Ainda fazendo comparação com o mundo Java, em Python não existem tipos primitivos.
167 | 	Até mesmo um número inteiro é uma instância de int e tem seus atributos e métodos.
168 | 
169 | 
170 | .. code-block:: python
171 |     x = 45
172 |     x.__hex__()
173 | 
174 | .. code-block:: console
175 | 
176 |     '0x2d'
177 | 
178 | .. code-block:: python
179 | 
180 |     x.real
181 | 
182 | .. code-block:: console
183 | 
184 |     45
185 | 
186 | .. code-block:: python
187 | 
188 |     x.imag
189 | 
190 | .. code-block:: console
191 | 
192 |     0
193 | 
194 | 
195 | A criação de classes em Python é extremamente simples, sendo que uma classe primária a herança é 
196 | feita da classe object e cada classe pode herdar mais de uma. Ou seja, também é aceita herança múltipla.
197 | 
198 | 
199 | .. code-block:: python
200 | 
201 |     class Carro(object):
202 |         marca = ''
203 |         modelo = ''
204 |         ano = 0
205 | 
206 |     c1 = Carro()
207 | 
208 |     c1.marca = 'Porsche'
209 | 
210 |     c1.modelo = 'Carrera'
211 | 
212 |     c1.ano = 1995
213 | 
214 |     print('O {} {} fabricado em {} estava estacionado.'.format(c1.marca, c1.modelo, c1.ano))
215 | 
216 | .. code-block:: console
217 | 
218 |     O Porsche Carrera fabricado em 1995 estava estacionado.
219 | 
220 | 
221 | .. code-block:: python
222 |     
223 |     class Animal(object):
224 |         peso = 0.0
225 | 
226 |     class Humano(Animal):
227 |         quoficiente_inteligencia = 0.0
228 | 
229 |     class Touro(Animal):
230 |         envergadura_chifre = 0.0
231 | 
232 |     class Minotauro(Humano, Animal):
233 |         pass
234 | 
235 | 
236 | Tipagem Dinâmica
237 | ----------------
238 | 
239 | 	O interpretador define o tipo de acordo com o valor atribuído à variável.
240 | 	A mesma variável pode ter seu tipo mudado de acordo com valores a ela atribuídos ao longo do código-fonte e em seu tempo de execução.
241 | 
242 | .. code-block:: python
243 | 
244 |     foo = 'bar'
245 |     type(foo)
246 | 
247 | .. code-block:: console
248 | 
249 |     str
250 | 
251 | .. code-block:: python
252 | 
253 |     foo = 123
254 |     type(foo)
255 | 
256 | .. code-block:: console
257 | 
258 |     int
259 | 
260 | .. code-block:: python
261 | 
262 |     foo = 7.0
263 |     type(foo)
264 | 
265 | .. code-block:: console
266 | 
267 |     float
268 | 
269 |   
270 | 
271 | Tipagem Forte 
272 | -------------
273 | 
274 | 	O interpretador verifica se a operação é válida e não faz coerção automática entre tipos incompatíveis. Caso haja operações de tipos incompatíveis é preciso fazer a conversão explícita da variável ou variáveis antes da operação.
275 | 
276 | .. code-block:: python
277 | 
278 |     foo = '2'
279 |     bar = 5
280 |     type(foo)
281 | 
282 | .. code-block:: console
283 | 
284 |     <class 'str'>
285 | 
286 | .. code-block:: python
287 | 
288 |     type(bar)
289 | 
290 | .. code-block:: console
291 | 
292 |     <class 'int'>
293 | 
294 | .. code-block:: python
295 | 
296 |     foobar = foo + bar
297 | 
298 | 
299 | .. code-block:: console
300 | 
301 |     Traceback (most recent call last):
302 |         File "<input>", line 1, in <module>
303 |             foobar = foo + bar
304 |     TypeError: can only concatenate str (not "int") to str
305 | 
306 | .. code-block:: python
307 | 
308 |     foobar = int(foo) + bar
309 |     print(foobar)
310 | 
311 | .. code-block:: console
312 | 
313 |     7
314 | 
315 | .. code-block:: python
316 | 
317 |     foo = 2.0
318 |     type(foo)
319 | 
320 | .. code-block:: console
321 | 
322 |     <class 'float'>
323 | 
324 | 
325 | .. code-block:: python
326 | 
327 |     bar = 5
328 |     type(bar)
329 | 
330 | .. code-block:: console
331 | 
332 |     <class 'int'>
333 | 
334 | .. code-block:: python
335 | 
336 |     foobar = foo + bar
337 |     print(foobar)
338 | 
339 | .. code-block:: console
340 | 
341 |     7.0
342 | 
343 | Bytecode
344 | --------
345 | 
346 | 	Formato binário multiplataforma resultante da compilação de um código Python.
347 | 
348 | 
349 | Criação de estrutura de diretórios para teste de pacote e bytecode:
350 | 
351 | .. code-block:: bash
352 | 
353 |     mkdir -p /tmp/python/PacoteA/PacoteA1
354 | 
355 | Editar o módulo "Modulo1" que está dentro do pacote "PacoteA":
356 | 
357 | .. code-block:: bash
358 | 
359 |     vim /tmp/python/PacoteA/Modulo1.py
360 |     
361 | 
362 | .. code-block:: python
363 |     :linenos:
364 | 
365 |     def funcao():
366 |         print('Hello World!!!')
367 | 
368 | Editar o módulo "Modulo2" que está dentro do pacote "PacoteA":
369 | 
370 | .. code-block:: bash
371 | 
372 |     vim /tmp/python/PacoteA/PacoteA1/Modulo2.py
373 | 
374 | 
375 | .. code-block:: python
376 |     :linenos:
377 |     
378 |     def funcao(numero):
379 |         print(numero ** 3)
380 | 
381 | 
382 | Edição de script de exemplo:
383 | 
384 | .. code-block:: bash
385 | 
386 |     vim /tmp/python/foo.py
387 | 
388 | .. code-block:: python
389 |     :linenos:
390 | 
391 |     #!/usr/bin/env python
392 |     # _*_ encoding: utf-8 _*_
393 | 
394 |     from PacoteA.Modulo1 import funcao
395 |     from PacoteA.PacoteA1 import Modulo2
396 | 
397 |     print('\nAtenção!!!\n')
398 |     print('O teste vai começar...\n')
399 | 
400 |     funcao()
401 | 
402 |     Modulo2.funcao(3)
403 | 
404 | Execução do script:
405 | 
406 | .. code-block:: bash
407 | 
408 |     python3 /tmp/python/foo.py
409 | 
410 | .. code-block:: console
411 | 
412 |     Atenção!!!
413 | 
414 |     O teste vai começar...
415 | 
416 |     Hello World!!!
417 |     27
418 | 
419 | Quando um módulo é carregado pela primeira vez ou se seu código é mais novo do que o arquivo binário ele é compilado e então gera ou gera novamente o arquivo binário .pyc.
420 | 
421 | Listar o conteúdo de "PacoteA":
422 | 
423 | .. code-block:: bash
424 | 
425 |     ls /tmp/python/PacoteA/
426 | 
427 | .. code-block:: console
428 | 
429 |     Modulo1.py  PacoteA1  __pycache__
430 | 
431 | 
432 | Listar o conteúdo de __pycache__:
433 | 
434 | .. code-block:: bash
435 | 
436 |     ls /tmp/python/PacoteA/__pycache__/
437 | 
438 | .. code-block:: console
439 | 
440 |     Modulo1.cpython-36.pyc
441 | 
442 | 
443 | Com o comando "file" verificar informações de tipo de arquivo:    
444 | 
445 | .. code-block:: bash
446 | 
447 |     file /tmp/python/PacoteA/__pycache__/Modulo1.cpython-36.pyc
448 | 
449 | .. code-block:: console
450 | 
451 |     /tmp/python/PacoteA/__pycache__/Modulo1.cpython-36.pyc: python 3.6 byte-compiled
452 | 
453 | Quebra de linhas
454 | ----------------
455 | 
456 | Pode ser usada a barra invertida ou por vírgula.
457 | 
458 | .. code-block:: python
459 | 
460 |     varTeste = 3 * 5 + \
461 |     (10 + 7)
462 | 
463 |     varLista = [7,14,25,
464 |                 81,121]
465 | 
466 |                
467 | Blocos
468 | ------
469 | 
470 | 	São delimitados por endentação e a linha anterior ao bloco sempre termina com dois pontos.
471 | 
472 | 
473 | .. code-block:: python
474 | 
475 |     #Definição de uma classe
476 |     class Carro(object):
477 |         ano = 0
478 |         marca = ''
479 |         estado_farois = False
480 | 
481 |         #Definição de um método da classe
482 |         def interruptor_farois(self):
483 |             #Bloco if
484 |                 if(self.estado_farois):
485 |                     print('Apagando faróis')
486 |                     self.estado_farois = False
487 |                 else:
488 |                     print('Acendendo faróis')
489 |                     self.estado_farois = True
490 | 
491 | Comentários
492 | -----------
493 | 
494 | 	Inicia-se com o caractere "#" em cada linha.
495 | 
496 | .. code-block:: python
497 | 
498 |     # um simples comentário
499 | 
500 |     # A seguir uma soma
501 | 
502 |     x = 5 + 2
503 | 
504 |     print(x)  # Imprime o valor de x
505 | 
506 | 
507 | Docstrings ou Strings de Múltiplas Linhas
508 | -----------------------------------------
509 | 
510 | 	Feitos dentro de funções e classes, que geram documentação automaticamente que pode ser acessado pela função help().
511 | 	São usados três pares de apóstrofos (') ou três pares de aspas ("), 3 (três) no início e 3 (três) no fim.
512 | 
513 | 
514 | .. code-block:: python
515 | 
516 |     # Com apóstrofos
517 | 
518 |     '''Esta função faz isso de forma
519 |     x, y e z além de bla bla bla bla'''
520 | 
521 |     # Com aspas
522 | 
523 |     """Esta função faz isso de forma
524 |     x, y e z além de bla bla bla bla"""
525 | 
526 | Recurso para criar documentação automaticamente:
527 | 
528 | .. code-block:: python
529 | 
530 |     def funcao():
531 |         '''Esta função não faz absolutamente nada'''
532 | 
533 |     help(funcao)
534 | 
535 | .. code-block:: console
536 | 
537 |     Help on function funcao in module __main__:
538 | 
539 |     funcao()
540 |         Esta função não faz absolutamente nada
541 | 
542 | 
543 | Operadores
544 | ----------
545 | 
546 | Python suporta operadores dos tipos:
547 | 
548 | * Aritiméticos: +, -, *, /, //, **, %;
549 | * Relacionais: >, <, >=, >=, ==, !=;
550 | * Atribuição: =, +=, +=, -=, /=, *=, %=, **=, //=;
551 | * Lógicos: and, or, not;
552 | * Associação: in, not in;
553 | * Identidade: is, is not;
554 | * Bitwise: &, |, ^, ~, <<, >>.
555 | 
556 | Operadores serão discutidos em mais detalhes em um capítulo posterior.
557 | 
558 | O Comando del
559 | -------------
560 | 
561 | 	Este comando tem como objetivo remover a referência de um objeto.
562 | 	Se esse objeto não tiver outra referência, o garbage collector atuará liberando recursos.
563 | 
564 | .. code-block:: python
565 | 
566 |     sogra = 'Edelbarina'
567 |     print(sogra)
568 | 
569 | .. code-block:: console
570 | 
571 |     Edelbarina
572 | 
573 | .. code-block:: python
574 | 
575 |     del sogra
576 |     print(sogra)
577 | 
578 | .. code-block:: console
579 | 
580 |     Traceback (most recent call last):
581 |         File "<stdin>", line 1, in <module>
582 |     NameError: name 'sogra' is not defined
583 | 
584 | .. code-block:: python
585 | 
586 |     a = ['Z', 1, 5, 'm']
587 |     del a[2]
588 |     print(a)
589 | 
590 | .. code-block:: console
591 | 
592 |     ['Z', 1, 'm']
593 | 
594 | 
595 | print
596 | -----
597 | 
598 | 	Antes era somente um comando, a partir da série 3.X será apenas interpretado como função.
599 | 
600 | .. code-block:: python
601 | 
602 |     print('Teste')
603 | 
604 | .. code-block:: console
605 | 
606 |     Teste
607 | 
608 | 
609 | 
610 | Referência de Identificadores
611 | -----------------------------
612 | 
613 | .. code-block:: python
614 | 
615 |     x = 7
616 |     y = x
617 |     z = x
618 | 
619 |     id(x)
620 | 
621 | .. code-block:: console
622 | 
623 |     29786312
624 | 
625 | .. code-block:: python
626 | 
627 |     id(y)
628 | 
629 | .. code-block:: console
630 | 
631 |     29786312
632 | 
633 | .. code-block:: python
634 | 
635 |     id(z)
636 | 
637 | .. code-block:: console
638 | 
639 |     29786312
640 | 
641 | 3 (três) referências ao mesmo objeto
642 | 
643 | 
644 | .. code-block:: python
645 | 
646 |     del x
647 | 
648 | Agora são 2 (duas) referências...
649 | 
650 | .. code-block:: python
651 | 
652 |     print(y)
653 | 
654 | .. code-block:: console
655 | 
656 |     7
657 | 
658 | .. code-block:: python
659 | 
660 |     del y
661 | 
662 | Resta apenas 1 (uma) referência...
663 | 
664 | .. code-block:: python
665 | 
666 |     print(z)
667 | 
668 | .. code-block:: console
669 | 
670 |     7
671 | 
672 | .. code-block:: python
673 | 
674 |     del z
675 | 
676 | O contador de referências chegou a 0 (zero), ou seja, não há mais referência para o objeto.
677 | Então entra em ação o Garbage Collector para limpar a memória.


--------------------------------------------------------------------------------
/source/content/except.rst:
--------------------------------------------------------------------------------
  1 | Exceções
  2 | ********
  3 | 
  4 | .. https://docs.python.org/3/tutorial/errors.html
  5 | .. https://docs.python.org/3/library/exceptions.html
  6 | 
  7 | 
  8 | **Blocos de Comandos**:
  9 | 
 10 | - | try: Tenta executar o bloco de comandos;
 11 | - | except: Em outras linguagens de programação é conhecido como "catch",
 12 |   | captura e trata a exceção;
 13 | - | else: Só é executado se não tiver nenhuma exceção;
 14 | - | finally: Tendo exceção ou não é executado de qualquer jeito.
 15 | 
 16 | ::
 17 | 
 18 |                         try:
 19 |                          | 
 20 |                       Deu erro?
 21 |                         / \                    
 22 |                   Sim  /   \  Não
 23 |                       /     \
 24 |                      /       \
 25 |                    else:   except:
 26 |                      \       /
 27 |                       \     /
 28 |                        \   /
 29 |                         \ /
 30 |                       finally:
 31 | 
 32 | 
 33 | `Hierarquia de classes built-in de exceções <https://docs.python.org/3/library/exceptions.html>`_:
 34 | 
 35 | ::
 36 | 
 37 |     BaseException
 38 |     +-- SystemExit
 39 |     +-- KeyboardInterrupt
 40 |     +-- GeneratorExit
 41 |     +-- Exception
 42 |         +-- StopIteration
 43 |         +-- StopAsyncIteration
 44 |         +-- ArithmeticError
 45 |         |    +-- FloatingPointError
 46 |         |    +-- OverflowError
 47 |         |    +-- ZeroDivisionError
 48 |         +-- AssertionError
 49 |         +-- AttributeError
 50 |         +-- BufferError
 51 |         +-- EOFError
 52 |         +-- ImportError
 53 |         |    +-- ModuleNotFoundError
 54 |         +-- LookupError
 55 |         |    +-- IndexError
 56 |         |    +-- KeyError
 57 |         +-- MemoryError
 58 |         +-- NameError
 59 |         |    +-- UnboundLocalError
 60 |         +-- OSError
 61 |         |    +-- BlockingIOError
 62 |         |    +-- ChildProcessError
 63 |         |    +-- ConnectionError
 64 |         |    |    +-- BrokenPipeError
 65 |         |    |    +-- ConnectionAbortedError
 66 |         |    |    +-- ConnectionRefusedError
 67 |         |    |    +-- ConnectionResetError
 68 |         |    +-- FileExistsError
 69 |         |    +-- FileNotFoundError
 70 |         |    +-- InterruptedError
 71 |         |    +-- IsADirectoryError
 72 |         |    +-- NotADirectoryError
 73 |         |    +-- PermissionError
 74 |         |    +-- ProcessLookupError
 75 |         |    +-- TimeoutError
 76 |         +-- ReferenceError
 77 |         +-- RuntimeError
 78 |         |    +-- NotImplementedError
 79 |         |    +-- RecursionError
 80 |         +-- SyntaxError
 81 |         |    +-- IndentationError
 82 |         |         +-- TabError
 83 |         +-- SystemError
 84 |         +-- TypeError
 85 |         +-- ValueError
 86 |         |    +-- UnicodeError
 87 |         |         +-- UnicodeDecodeError
 88 |         |         +-- UnicodeEncodeError
 89 |         |         +-- UnicodeTranslateError
 90 |         +-- Warning
 91 |             +-- DeprecationWarning
 92 |             +-- PendingDeprecationWarning
 93 |             +-- RuntimeWarning
 94 |             +-- SyntaxWarning
 95 |             +-- UserWarning
 96 |             +-- FutureWarning
 97 |             +-- ImportWarning
 98 |             +-- UnicodeWarning
 99 |             +-- BytesWarning
100 |             +-- ResourceWarning
101 | 
102 | 
103 | 
104 | Forçando um erro dividindo por zero:
105 | 
106 | .. code-block:: python
107 | 
108 |     print(1 / 0)
109 | 
110 | .. code-block:: console
111 | 
112 |     ---------------------------------------------------------------------------
113 |     ZeroDivisionError                         Traceback (most recent call last)
114 |     <ipython-input-18-79ea940cf5e7> in <module>()
115 |     ----> 1 print('Resultado = %s' % (x / y))
116 | 
117 |     ZeroDivisionError: integer division or modulo by zero
118 | 
119 | 
120 | 
121 | bla bla bla:
122 | 
123 | .. code-block:: python
124 | 
125 |     try:
126 |         print(1 / 0)
127 | 
128 |     # catch all exceptions
129 |     except:
130 |         print('\n\nErro: Não dividirás por zero!\n\n')
131 | 
132 | .. code-block:: console
133 | 
134 |     Erro: Não dividirás por zero!
135 | 
136 | 
137 | 
138 | Utilizando try e forçando um erro de divisão por zero:
139 | 
140 | .. code-block:: python
141 | 
142 |     try:
143 |         print(1 / 0)
144 |     # specified exception
145 |     except ZeroDivisionError:
146 |         print('\n\nErro: Não dividirás por zero!\n\n')
147 | 
148 | 
149 | .. code-block:: console
150 | 
151 |     Erro: Não dividirás por zero!
152 | 
153 | 
154 | .. code-block:: python
155 | 
156 |     numeros = ('zero', 'um', 'dois')
157 | 
158 |     try:                            
159 |         print(numeros[0])
160 |         print(numeros[1])
161 |         print(numeros[2])
162 |         print(numeros[3])
163 |     except IndexError:    
164 |         print('\n\nERRO: Índice não encontrado\n\n')
165 |    
166 | .. code-block:: console
167 | 
168 |     zero
169 |     um
170 |     dois
171 | 
172 |     ERRO: Índice não encontrado
173 | 
174 | 
175 | 
176 | sasasasasa:
177 | 
178 | .. code-block:: python
179 | 
180 |     try:                            
181 |         print(numeros[0])
182 |         print(numeros[1])
183 |         print(numeros[2])
184 |         print(numeros[3])
185 |     except IndexError, e:    
186 |         print('\n\nERRO: Índice não encontrado\n\n%s' % e)
187 | 
188 | .. code-block:: console
189 | 
190 |     zero
191 |     um
192 |     dois
193 | 
194 | 
195 |     ERRO: Índice não encontrado
196 | 
197 |     tuple index out of range
198 | 
199 | O "e" é a mensagem de erro "tuple index out of range"
200 | 
201 | 
202 | 
203 | ssdsdpsdsd:
204 | 
205 | .. code-block:: bash
206 | 
207 |     $ vim excecao.py
208 | 
209 | .. code-block:: python
210 | 
211 |     #_*_ encoding: utf-8 _*_
212 | 
213 |     import sys
214 | 
215 |     numeros = ('zero', 'um', 'dois')
216 | 
217 |     try:
218 |         print(numeros[0])
219 |         print(numeros[1])
220 |         print(numeros[2])
221 |         print(numeros[3])
222 |     except IndexError, e:
223 |         print >> sys.stderr, '\n\nERRO: Índice não encontrado\n\n%s' % e
224 |         sys.exit(1)
225 | 
226 | 
227 | 
228 | sdsdsdsd:
229 | 
230 | .. code-block:: bash
231 | 
232 |     python excecao.py
233 | 
234 | .. code-block:: console
235 | 
236 |     zero
237 |     um
238 |     dois
239 | 
240 | 
241 |     ERRO: Índice não encontrado
242 | 
243 |     tuple index out of range
244 | 
245 | 
246 | ddsdsd:
247 | 
248 | .. code-block:: bash
249 | 
250 |     echo $?
251 | 
252 | .. code-block:: console
253 | 
254 |     1
255 | 
256 | 
257 | 
258 | sdsdsdsdsdsd:
259 | 
260 | .. code-block:: bash
261 | 
262 |     vim excecao3.py
263 | 
264 | .. code-block:: python
265 | 
266 |     #_*_ encoding: utf-8 _*_
267 | 
268 |     import sys
269 | 
270 |     numeros = ('zero', 'um', 'dois')
271 | 
272 |     try:
273 |         print(numeros[0])
274 |         print(numeros[1])
275 |         print(numeros[2])
276 |         print(numeros[3])
277 |     except IndexError as e:
278 |         print('\n\nERRO: Índice não encontrado\n\n%s' % e, file = sys.stderr)
279 |         sys.exit(1)
280 | 
281 | 
282 | 
283 | sdsdsd:
284 | 
285 | .. code-block:: bash
286 | 
287 |     python3 excecao3.py
288 | 
289 | .. code-block:: console
290 | 
291 |     zero
292 |     um
293 |     dois
294 | 
295 | 
296 |     ERRO: Índice não encontrado
297 | 
298 |     tuple index out of range
299 | 
300 | 
301 | 
302 | sdsdsdsd:
303 | 
304 | .. code-block:: bash
305 | 
306 |     echo $?
307 | 
308 | .. code-block:: console
309 | 
310 |     1
311 | 
312 | 
313 | 
314 | sddsdsdsdsd:
315 | 
316 | .. code-block:: python
317 | 
318 |     f = open('/tmp/blablabla.txt', 'r')
319 | 
320 | .. code-block:: console
321 | 
322 |     ---------------------------------------------------------------------------
323 |     IOError                                   Traceback (most recent call last)
324 |     <ipython-input-20-11fa3db68c79> in <module>()
325 |     ----> 1 f = open('/tmp/blablabla.txt', 'r')
326 | 
327 |     IOError: [Errno 2] No such file or directory: '/tmp/blablabla.txt'
328 | 
329 | 
330 | 
331 | sddsdsdsd:
332 | 
333 | .. code-block:: python
334 | 
335 |     try:
336 |         f = open('/tmp/blablabla.txt', 'r')
337 |     except IOError as e:
338 |         print('O arquivo não existe!')
339 | 
340 | .. code-block:: python
341 | 
342 |     O arquivo não existe!
343 | 
344 | 
345 | 
346 | sdsdsdsd:
347 | 
348 | .. code-block:: python
349 | 
350 |     type(e)
351 | 
352 | .. code-block:: console
353 | 
354 |     IOError
355 | 
356 | 
357 | 
358 | sdsdssdsdsd:    
359 | 
360 | .. code-block:: python
361 | 
362 |     dir(e)
363 | 
364 | .. code-block:: console
365 | 
366 |     ['__class__',
367 |      '__delattr__',
368 |      '__dict__',
369 |      '__doc__',
370 |      '__format__',
371 |      '__getattribute__',
372 |      '__getitem__',
373 |      '__getslice__',
374 |      '__hash__',
375 |      '__init__',
376 |      '__new__',
377 |      '__reduce__',
378 |      '__reduce_ex__',
379 |      '__repr__',
380 |      '__setattr__',
381 |      '__setstate__',
382 |      '__sizeof__',
383 |      '__str__',
384 |      '__subclasshook__',
385 |      '__unicode__',
386 |      'args',
387 |      'errno',
388 |      'filename',
389 |      'message',
390 |      'strerror']
391 | 
392 | 
393 | 
394 | dsdsdsdsd:
395 | 
396 | .. code-block:: python
397 | 
398 |     repr(e)
399 | 
400 | .. code-block:: console
401 | 
402 |     "IOError(2, 'No such file or directory')"
403 | 
404 | 
405 | sdsdsdsdsd:
406 | 
407 | .. code-block:: python
408 | 
409 |     e.<TAB>
410 | 
411 | .. code-block:: console
412 | 
413 |     e.args      e.errno     e.filename  e.message   e.strerror
414 | 
415 | 
416 | 
417 | sdsddssd:
418 | 
419 | .. code-block:: python
420 | 
421 |     print(e.errno)
422 | 
423 | .. code-block:: console
424 | 
425 |     2
426 | 
427 | 
428 | 
429 | sdsdsdsdsd:
430 | 
431 | .. code-block:: bash
432 | 
433 |     vim excecao.py
434 | 
435 | .. code-block:: python
436 | 
437 |     #_*_ encoding: utf-8 _*_
438 | 
439 |     import sys 
440 | 
441 |     try:    
442 |         f = open('/tmp/blablabla.txt', 'r')
443 |     
444 |     except IOError as e:       
445 |         print >> sys.stderr, '\n\nERRO: Arquivo não encontrado\n\n%s' % e 
446 |         sys.exit(e.errno)
447 | 
448 | 
449 | 
450 | sddssd:
451 | 
452 | .. code-block:: bash
453 | 
454 |     python excecao.py
455 | 
456 | .. code-block:: console
457 | 
458 |     ERRO: Arquivo não encontrado
459 | 
460 |     [Errno 2] No such file or directory: '/tmp/blablabla.txt'
461 | 
462 | 
463 | 
464 | sdsdklsdkkl:
465 | 
466 | .. code-block:: bash
467 | 
468 |     echo $?
469 | 
470 | .. code-block:: console
471 | 
472 |     2
473 | 
474 | 
475 | 
476 | sdsdsdsdd:
477 | 
478 | .. code-block:: bash
479 | 
480 |     vim excecao3.py
481 | 
482 | 
483 | 
484 | .. code-block:: python
485 | 
486 |     #_*_ encoding: utf-8 _*_
487 | 
488 |     import sys 
489 | 
490 |     try:    
491 |         f = open('/tmp/blablabla.txt', 'r')
492 |     
493 |     except IOError as e:       
494 |         print('\n\nERRO: Arquivo não encontrado\n\n%s' % e, file = sys.stderr) 
495 |         sys.exit(e.errno)
496 | 
497 | 
498 | 
499 | sdsdsdsdsd:
500 | 
501 | .. code-block:: bash
502 | 
503 |     python3 excecao3.py
504 | 
505 | .. code-block:: console
506 | 
507 |     ERRO: Arquivo não encontrado
508 | 
509 |     [Errno 2] No such file or directory: '/tmp/blablabla.txt'
510 | 
511 | 
512 | 
513 | sdsddssd:
514 | 
515 | .. code-block:: bash
516 | 
517 |     echo $?
518 | 
519 | .. code-block:: console
520 | 
521 |     2
522 | 
523 | 
524 | 
525 | 
526 | else
527 | ----
528 | 
529 | 
530 | 
531 | .. code-block:: bash
532 | 
533 |     vim excecao.py
534 | 
535 | .. code-block:: python
536 | 
537 |     #_*_ encoding: utf-8 _*_
538 | 
539 |     import sys
540 | 
541 |     f = sys.argv[1]
542 | 
543 |     try:
544 |         f = open(f, 'r')
545 | 
546 |     except IOError:
547 |         print('Não existe o arquivo')  
548 |         
549 |     else:
550 |         print('Sim, o arquivo existe!')  
551 |         f.close()
552 | 
553 | 
554 | 
555 | ewowewewe:
556 | 
557 | .. code-block:: bash
558 | 
559 |     python excecao.py /tmp/blablabla.txt
560 | 
561 | .. code-block:: console
562 | 
563 |     Não existe o arquivo
564 | 
565 | 
566 | 
567 | ewewewewe:
568 | 
569 | .. code-block:: bash
570 | 
571 |     touch /tmp/blablabla.txt
572 |     python excecao.py /tmp/blablabla.txt
573 | 
574 | .. code-block:: console
575 | 
576 |     Sim, o arquivo existe!
577 | 
578 | 
579 | 
580 | dsdsdsdsd:
581 | 
582 | .. code-block:: bash
583 | 
584 |     rm /tmp/blablabla.txt
585 | 
586 | 
587 | 
588 | finally
589 | -------
590 | 
591 | 
592 | 
593 | .. code-block:: bash
594 | 
595 |     vim excecao.py
596 | 
597 | 
598 | .. code-block:: python
599 | 
600 |     #_*_ encoding: utf-8 _*_
601 | 
602 |     import sys
603 | 
604 |     f = sys.argv[1]
605 | 
606 |     try:
607 |         f = open(f, 'r')
608 | 
609 |     except IOError:
610 |         print('Não existe o arquivo')  
611 |         
612 |     else:
613 |         print('Sim, o arquivo existe!')  
614 |         f.close()
615 | 
616 |     finally:
617 |         print('Se deu certo ou errado, o programa termina aqui :/')
618 | 
619 | 
620 | 
621 | dsdsdsdsd:
622 | 
623 | .. code-block:: bash
624 | 
625 |     python excecao.py /tmp/blablabla.txt
626 | 
627 | .. code-block:: console
628 | 
629 |     Não existe o arquivo
630 | 
631 | Se deu certo ou errado, o programa termina aqui :/
632 | 
633 | 
634 | 
635 | sdsdsd:
636 | 
637 | .. code-block:: bash
638 | 
639 |     touch /tmp/blablabla.txt
640 |     python excecao.py /tmp/blablabla.txt
641 | 
642 | .. code-block:: console
643 | 
644 |     Sim, o arquivo existe!
645 | 
646 | Se deu certo ou errado, o programa termina aqui :/
647 | 
648 | 
649 | raise
650 | -----
651 | 
652 | sasasasa:
653 | 
654 | .. code-block:: python
655 | 
656 |     raise Exception('Provocando uma exceção')
657 | 
658 | .. code-block:: console
659 |         
660 |     ---------------------------------------------------------------------------
661 |     Exception                                 Traceback (most recent call last)
662 |     <ipython-input-62-69ebfeaaf513> in <module>()
663 |     ----> 1 raise Exception('Provocando uma exceção')
664 | 
665 |     Exception: Provocando uma exceção
666 | 
667 | 
668 | 
669 | saassasasa:
670 | 
671 | .. code-block:: python
672 | 
673 |     try:
674 |         raise ZeroDivisionError()
675 |     except IOError:
676 |         print('Exceção IOError')
677 |     except IndexError:    
678 |         print('Exceção IndexError')
679 |     except:
680 |         print('Exceção não declarada')
681 | 
682 | .. code-block:: console
683 | 
684 |     Exceção não declarada
685 | 
686 | 
687 | 
688 | ewwewewe:
689 | 
690 | .. code-block:: python
691 | 
692 |     try:
693 |         raise ZeroDivisionError('Erro de divisão por zero')
694 |     except IOError:
695 |         print('Exceção IOError')
696 |     except IndexError:    
697 |         print('Exceção IndexError')
698 |     except ZeroDivisionError:
699 |         print('Exceção ZeroDivisionError')
700 |     except:
701 |         print('Exceção não declarada')
702 | 
703 | .. code-block:: console
704 | 
705 |     Exceção ZeroDivisionError
706 | 
707 | 
708 | 
709 | osdkskldskl:
710 | 
711 | .. code-block:: python
712 | 
713 |     try:
714 |         raise ZeroDivisionError('Erro de divisão por zero')
715 |     except IOError:
716 |         print('Exceção IOError')
717 |     except IndexError:    
718 |         print('Exceção IndexError')
719 |     except ZeroDivisionError:
720 |         print('Exceção ZeroDivisionError')
721 |     except Exception:
722 |         print('Exceção não declarada')
723 | 
724 | .. code-block:: console
725 | 
726 |     Exceção ZeroDivisionError
727 | 
728 | 
729 | 
730 | ssdsdpsdsd:
731 | 
732 | .. code-block:: python
733 | 
734 |     try:
735 |         raise ZeroDivisionError('Erro de divisão por zero')
736 |     except IOError:
737 |         print('Exceção IOError')    
738 |     except IndexError:    
739 |         print('Exceção IndexError')
740 |     except ZeroDivisionError:
741 |         print('Exceção ZeroDivisionError')
742 |         raise
743 |     except Exception:
744 |         print('Exceção não declarada')
745 | 
746 | .. code-block:: console
747 | 
748 |         Exceção ZeroDivisionError
749 |     ---------------------------------------------------------------------------
750 |     ZeroDivisionError                         Traceback (most recent call last)
751 |     <ipython-input-77-be8b35cbd0cc> in <module>()
752 |         1 try:
753 |     ----> 2     raise ZeroDivisionError('Erro de divisão por zero')
754 |         3 except IOError:
755 |         4     print('Exceção IOError')
756 |         5 except IndexError:
757 | 
758 |     ZeroDivisionError: Erro de divisão por zero
759 | 
760 | 
761 | 
762 | Exceção Personalizada
763 | ---------------------
764 | 
765 | Para criarmos uma exceção personalizada preciamos criar uma classe que herde
766 | de uma outra classe de exceção, cuja raiz é Exception.
767 | 
768 | 
769 | 
770 | DSSDSDSD:
771 | 
772 | .. code-block:: python
773 | 
774 |     class FooException(Exception):
775 |         pass
776 | 
777 |     try:
778 |         raise FooException('Bla bla bla')
779 |     except Exception as e:
780 |         print('Erro ------> %s' % e)
781 | 
782 | 
783 | .. code-block:: console
784 | 
785 |     Erro ------> Bla bla bla
786 | 
787 | 
788 | 
789 | sdsdksdsd:
790 | 
791 | .. code-block:: python
792 | 
793 |     class EggsException(Exception):
794 |         def __init__(self, value):
795 |             self.value = value
796 |         def __str__(self):
797 |             return self.value
798 | 
799 |     try:
800 |         raise EggsException(50)
801 |     except EggsException as e:
802 |         print('Ocorreu um erro da minha exceção, cujo valor é %s' % (e.value))
803 | 
804 | .. code-block:: console
805 | 
806 |     Ocorreu um erro da minha exceção, cujo valor é 50
807 | 
808 | 
809 | 
810 | sdaasasa:
811 | 
812 | .. code-block:: python
813 | 
814 |     raise EggsException('bla bla bla')
815 | 
816 | .. code-block:: console
817 | 
818 |     ---------------------------------------------------------------------------
819 |     EggsException                             Traceback (most recent call last)
820 |     <ipython-input-14-4cafda692601> in <module>()
821 |     ----> 1 raise EggsException('bla bla bla')
822 | 
823 |     EggsException: bla bla bla


--------------------------------------------------------------------------------
/source/content/functions.rst:
--------------------------------------------------------------------------------
  1 | Funções
  2 | *******
  3 | 
  4 | |   Uma funçao é um recurso de linguagens de programação, que armazena instruções contidas em um bloco de forma a evitar escrever novamente essas mesmas instruções reaproveitando o código ali escrito.
  5 | |   No âmbito (escopo) da função podem ser definidas variáveis que só terão visibilidade dentro da função.
  6 | |   Após definida a função, a mesma é invocada pelo seu nome e seus argumentos (se ela requerir).
  7 | |   Funções em Python são definidas a partir do comando def.
  8 | |   Funções ajudam o código a dividir, agrupar, reusar, reduzir, deixar mais legível além de ser uma boa prática.
  9 | 
 10 | 
 11 | Funções sem Argumentos
 12 | ----------------------
 13 | 
 14 | Definição da função sem argumentos:
 15 | 
 16 | .. code-block:: python
 17 | 
 18 |     def funcao():
 19 |         numero = 7 ** 2
 20 |         msg = 'O quardrado de 7 é %d' % numero
 21 |         print(msg)      
 22 |         
 23 |     funcao()
 24 | 
 25 | 
 26 | .. code-block:: console
 27 | 
 28 |     O quardrado de 7 é 49
 29 | 
 30 | O Comando return
 31 | ----------------
 32 | 
 33 | 	O comando return dá um retorno para a função.
 34 | 	Uma função pode retornar um ou mais valores (coleções).
 35 | 	Deve ser o último comando da função, pois se tiver algum código depois será ignorado.
 36 | 	Vale lembrar que return não é a mesma coisa que imprimir em tela. Quando se digita algo que retorne um valor dentro de um shell interativo, esse valor por conveniência é impresso em tela.
 37 | 	Mas em um aplicativo ou script isso não acontecerá, portanto se deseja imprimir um valor em tela, isso deve ser explicitado, o que é mais comumente feito por print().
 38 | 	Quando uma função não tem um comando return, seu retorno é None implícito, o que para outras linguagens como C e Java é a mesma coisa que void.
 39 | 
 40 | 
 41 | 
 42 | Definição da função:
 43 | 
 44 | .. code-block:: python
 45 | 
 46 |     def funcao():
 47 |         return 7
 48 | 
 49 | 
 50 | 
 51 | Utilizando print para imprimir em tela o valor retornado pela função
 52 | multiplicado por 3:
 53 | 
 54 | .. code-block:: python
 55 | 
 56 |     print(funcao() * 3)    
 57 | 
 58 | .. code-block:: console
 59 | 
 60 |     21
 61 |     
 62 |     
 63 |     
 64 | Definição de uma função que retorna mais de um valor:
 65 | 
 66 | .. code-block:: python
 67 | 
 68 |     def funcao():
 69 |         return 3, 9
 70 | 
 71 | 
 72 | 
 73 | Atribuindo à variável o valor de retorno da função:
 74 | 
 75 | .. code-block:: python
 76 | 
 77 |     x = funcao()
 78 | 
 79 | 
 80 | 
 81 | 
 82 | Imprimindo o valor da variável:
 83 | 
 84 | .. code-block:: python
 85 | 
 86 |     print(x)
 87 | 
 88 | .. code-block:: console
 89 | 
 90 |     (3, 9)
 91 | 
 92 | 
 93 | 
 94 | 
 95 | Verificando o tipo da variável:
 96 | 
 97 | .. code-block:: python
 98 | 
 99 |     type(x)
100 | 
101 | .. code-block:: console
102 | 
103 |     tuple
104 | 
105 | 
106 | 
107 | Definição de uma função com código após return:
108 | 
109 | .. code-block:: python
110 | 
111 |     def funcao():
112 |         return 7
113 |         print('Teste')
114 | 
115 | 
116 | 
117 | Execução da função:
118 | 
119 | .. code-block:: python
120 | 
121 |     funcao()
122 | 
123 | .. code-block:: console
124 | 
125 |     7
126 | 
127 | |   Como pode-se notar, o código inserido após return foi completamente
128 | | ignorado.
129 | |   Devido ao fato de os comandos serem digitados no shell interativo foi
130 | | impresso em tela o valor de retorno da função.
131 | 
132 | 
133 | 
134 | Argumentos Simples (Argumentos Não Nomeados)
135 | --------------------------------------------
136 | 
137 | 	Uma função pode ter um ou mais argumentos a serem pasados.
138 | 	Esses argumentos podem ser ou não obrigatórios. Sendo que os argumentos não obrigatórios têm um valor inicial.
139 | 
140 | 
141 | 
142 | Definição de uma função:
143 | 
144 | .. code-block:: python
145 | 
146 |     def funcao(x):
147 |         return x
148 | 
149 | 
150 | 
151 | Execução da função sem passar argumentos:
152 | 
153 | .. code-block:: python
154 | 
155 |     funcao()
156 | 
157 | .. code-block:: console
158 | 
159 |     ---------------------------------------------------------------------------
160 |     TypeError                                 Traceback (most recent call last)
161 |     /home/beethoven/<ipython-input-22-7473677d9fe3> in <module>()
162 |     ----> 1 funcao()
163 | 
164 |     TypeError: funcao() takes exactly 1 argument (0 given)
165 | 
166 | |   Devido ao fato de a função exigir que seja passado um argumento.
167 | 
168 | 
169 | 
170 | Execução da função passando um argumento:
171 | 
172 | .. code-block:: python
173 | 
174 |     funcao(7)
175 | 
176 | .. code-block:: console
177 | 
178 |     7
179 |     
180 |     
181 |     
182 | Argumentos Nomeados
183 | -------------------
184 | 
185 | 	Podemos definir uma função em que um ou mais argumentos tenham valores padrões de forma que ao invocar a função podemos omitir a declaração, pois será considerado o padrão ou explicitando um valor.
186 | 	Quando houver mais de um argumento, os argumentos obrigatórios devem vira primeiro.
187 | 
188 | 
189 | 
190 | Definição de função com um argumento:
191 | 
192 | .. code-block:: python
193 | 
194 |     def funcao(x = 7):
195 |         return x
196 | 
197 | 
198 | 
199 | Chamando a função sem declarar valor de argumento:
200 | 
201 | .. code-block:: python
202 | 
203 |     funcao()
204 | 
205 | .. code-block:: console
206 | 
207 |     7
208 | 
209 | 
210 | 
211 | Chamando a função explicitando um valor de argumento:
212 | 
213 | .. code-block:: python
214 | 
215 |     funcao(9)
216 | 
217 | ou
218 | 
219 | .. code-block:: python
220 | 
221 |     funcao(x = 9)    
222 | 
223 | .. code-block:: console
224 | 
225 |     9
226 | 
227 | 
228 | 
229 | Definindo uma função mesclando argumentos padrão e obrigatórios:
230 | 
231 | .. code-block:: python
232 | 
233 |     def funcao(x = 7, y):
234 |         return x + y
235 | 
236 | .. code-block:: console
237 | 
238 |     SyntaxError: non-default argument follows default argument
239 | 
240 | |   Houve um erro, pois primeiro são os argumentos não padrões.
241 | 
242 | 
243 | 
244 | Definindo uma função com dois parâmetros:
245 | 
246 | .. code-block:: python
247 | 
248 |     def funcao(x, y = 7):
249 |         return x + y
250 | 
251 | 
252 | 
253 | Execução da função passando apenas um parâmetro (o obrigatório):
254 | 
255 | .. code-block:: python
256 | 
257 |     funcao(3)
258 | 
259 | .. code-block:: console
260 | 
261 |     10
262 | 
263 | 
264 | 
265 | Passando os dois parâmetros:
266 | 
267 | .. code-block:: python
268 | 
269 |     funcao(2, 3)
270 | 
271 | .. code-block:: console
272 | 
273 |     5
274 | 
275 | 
276 | 
277 | Forçando um erro ao não passar sequer o parâmetro obrigatório:
278 | 
279 | .. code-block:: python
280 | 
281 |     funcao()
282 | 
283 | .. code-block:: console
284 | 
285 |     TypeError: funcao() takes at least 1 argument (0 given)
286 | 
287 | 
288 | 
289 | Definindo uma função com dois parâmetros opcionais:
290 | 
291 | .. code-block:: python
292 | 
293 |     def funcao(x, y = 1, z = 2):
294 |         return x + y + z
295 | 
296 | 
297 | 
298 | Execução da função com um parâmetro (o obrigatório):
299 | 
300 | .. code-block:: python
301 | 
302 |     funcao(0)
303 | 
304 | .. code-block:: console
305 | 
306 |     3
307 | 
308 | 
309 | 
310 | Execução da função com um parâmetro obrigatório e um opcional:
311 | 
312 | .. code-block:: python
313 | 
314 |     funcao(1, 2)
315 | 
316 | .. code-block:: console
317 | 
318 |     5
319 | 
320 | 
321 | 
322 | Execução da função com um parâmetro obrigatório e dois opcionais:
323 | 
324 | .. code-block:: python
325 | 
326 |     funcao(1, 2, 90)
327 | 
328 | .. code-block:: console
329 | 
330 |     93
331 | 
332 | funcao(10, z = 30, y = 50)
333 | 
334 | .. code-block:: console
335 | 
336 |     90
337 | 
338 | 
339 | 
340 | Argumentos em Lista Não Nomeados
341 | --------------------------------
342 | 
343 | |   É possível passar uma lista de argumentos sem nomear cada um deles, ou 
344 | | seja, atribuir uma variável.
345 | |   Essa lista, internamente é interpretada como uma tupla (tuple).
346 | |   Tal recurso nos possibilita passar uma quantidade indeterminada de
347 | | argumentos.
348 | |   O identificador da variável que representa esse tipo de argumento vem logo
349 | | depois do caractere asterisco (*).
350 | 
351 | .. code-block:: python
352 | 
353 |     def funcao(*args): 
354 |         qtd = len(args) 
355 |         primeiro = args[0] 
356 |         ultimo = args[-1] 
357 |         print(f'Foram passados {qtd} argumentos') 
358 |         print(f'O primeiro é {primeiro}') 
359 |         print(f'O último é {ultimo}') 
360 |         print(f'Os argumentos passados foram: {args}')
361 | 
362 | .. code-block:: console
363 | 
364 |     funcao('abacaxi', 3, 'p', 8.3, 5 + 9j)
365 |     Foram passados 5 argumentos
366 |     O primeiro é "abacaxi"
367 |     O último é "(5+9j)"
368 |     Os argumentos passados foram: ('abacaxi', 3, 'p', 8.3, (5+9j))
369 | 
370 | 
371 | 
372 | Definição de função de duas formas diferentes:
373 | 
374 | .. code-block:: python
375 | 
376 |     def funcao(*args):
377 |         for arg in args:
378 |             print(f'Argumento {args.index(arg)} = {arg}')
379 | 
380 | ou
381 | 
382 | .. code-block:: python
383 | 
384 |     def funcao(*args):
385 |         for i, arg in enumerate(args):
386 |             print(f'Argumento {i} = {arg}')
387 | 
388 | 
389 | 
390 | Execução:
391 | 
392 | .. code-block:: python
393 | 
394 |     funcao('a', 1.5, 7, 99)
395 | 
396 | .. code-block:: console
397 | 
398 |     Argumento 0 = a
399 |     Argumento 1 = 1.5
400 |     Argumento 2 = 7
401 |     Argumento 3 = 99
402 | 
403 | 
404 | 
405 | Definição de uma função com um parâmetro arbitrário não nomeado:    
406 | 
407 | .. code-block:: python
408 | 
409 |     def funcao(*args):
410 |         print(args)
411 |         for i in args:
412 |             print(i)
413 | 
414 | 
415 | 
416 | Criação de uma tupla com quatro elementos:
417 | 
418 | .. code-block:: python
419 | 
420 |     spam = (1, 2, 3, 4)
421 | 
422 | 
423 | 
424 | Notemos a diferença de comportamento nas execuções:
425 | 
426 | .. code-block:: python
427 | 
428 |     # Execução sem "desempacotamento" dos valores da tupla
429 |     funcao(spam)
430 | 
431 | .. code-block:: console
432 | 
433 |     ((1, 2, 3, 4),)
434 |     (1, 2, 3, 4)
435 | 
436 | 
437 | .. code-block:: python
438 | 
439 |     # Execução com "desempacotamento" dos valores da tupla
440 |     funcao(*spam)
441 | 
442 | .. code-block:: console
443 | 
444 |     (1, 2, 3, 4)
445 |     1
446 |     2
447 |     3
448 |     4
449 |     
450 | |   Quando o caractere asterisco é posicionado antes de uma variável faz com
451 | | que considere que aquela variável (coleções) seja "desempacotada".
452 | |   Seus elementos são passados como se fossem uma tupla, ou seja, uma
453 | | sequência de valores estraídos separados por vírgulas.
454 | 
455 | 
456 | 
457 | Argumentos em Lista Nomeados
458 | ----------------------------
459 | 
460 | |   O identificador da variável desse tipo de argumento é precedido por dois
461 | | asteriscos (**).
462 | |   É uma lista com quantidade indeterminada e cada elemento da lista tem um
463 | | identificador próprio.
464 | 
465 | 
466 | 
467 | Definição de uma função com parâmetros arbitrários nomeados:
468 | 
469 | .. code-block:: python
470 | 
471 |     def funcao(**kargs):
472 |         return kargs
473 |     
474 |     funcao(a = 1, b = 2)
475 | 
476 | .. code-block:: console
477 | 
478 |     {'a': 1, 'b': 2}
479 | 
480 | 
481 | 
482 | Definição e execução:
483 | 
484 | .. code-block:: python
485 | 
486 |     def funcao(**kargs):
487 |         for k, v in kargs.items():
488 |             print(f'{k} = {v}')
489 |             
490 |             
491 |     funcao(
492 |         nome = 'Chiquinho',
493 |         sobrenome = 'da Silva',
494 |         idade = 30,
495 |         telefone = '(11) 99999-9999',
496 |     )
497 | 
498 | 
499 | .. code-block:: console
500 | 
501 |     Idade = 30
502 |     Sobrenome = da Silva
503 |     Telefone = (11) 99999-9999
504 |     Nome = Chiquinho
505 | 
506 | 
507 | 
508 | Definição e execução:
509 | 
510 | .. code-block:: python
511 | 
512 |     def funcao(**kargs):
513 |         return kargs
514 | 
515 |         eggs = {'a': 3, 'b': 5, 'c': 'x'}
516 | 
517 |     funcao(eggs)
518 | 
519 | .. code-block:: console
520 | 
521 |     TypeError: funcao() takes exactly 0 arguments (1 given)
522 | 
523 | 
524 | 
525 | Execução com duplo asterisco no identificador do parâmetro:
526 | 
527 | .. code-block:: python
528 | 
529 |     funcao(**eggs)
530 | 
531 | .. code-block:: console
532 | 
533 |     {'a': 3, 'b': 5, 'c': 'x'}
534 | 
535 | 
536 | 
537 | Funções com Argumentos Variados
538 | -------------------------------
539 | 
540 | |   E se precisarmos fazer uma função que utilize tipos diferentes conforme
541 | | visto anteriormente?
542 | |   A ordem dos tipos de argumentos é a seguinte:
543 | |
544 | |   **Simples**, **Nomeados**, **Lista de Não Nomeados** e **Lista de Nomeados**
545 | 
546 | 
547 | 
548 | Definição e execução de uma função com parâmetros mistos:
549 | 
550 | .. code-block:: python
551 | 
552 |     def foo(a, b = 3, *c, **d):
553 |         print(a + b)
554 |         print(c)
555 |         print(d)
556 | 
557 |     foo(
558 |         4,
559 |         5,
560 |         'Alemanha',
561 |         'Holanda',
562 |         'Inglaterra',
563 |         continente = 'Europa',
564 |         hemisferio = 'Norte')
565 | 
566 | .. code-block:: console
567 | 
568 |     9
569 |     ('Alemanha', 'Holanda', 'Inglaterra')
570 |     {'continente': 'Europa', 'hemisferio': 'Norte'}
571 | 
572 | 
573 | 
574 | Estruturas de Dados como Parâmetro para Funções
575 | -----------------------------------------------
576 | 
577 | |   Em algumas situações pode ser útil utilizar uma estrutura de dados como
578 | | tupla (tuple), lista (list), dicionário (dict) ou mesmo um conjunto
579 | | (set / frozenset).
580 | 
581 | 
582 | 
583 | Criação da função de teste:
584 | 
585 | .. code-block:: python
586 | 
587 |     def param_test(x, y):
588 |         return x + y
589 | 
590 | 
591 | 
592 | Declaração das variáveis de estrutura de dados que serão utilizadas como
593 | parâmetro para a função:
594 | 
595 | .. code-block:: python
596 | 
597 |     tupla = (5, 2)
598 |     lista = [5, 2]
599 |     dicio = {'x': 5, 'y': 2}
600 |     conjunto = {2, 5, 2}
601 | 
602 | 
603 | 
604 | Testes utilizando as estruturas de dados criadas:
605 | 
606 | .. code-block:: python
607 | 
608 |     param_test(**dicio)  # Dicionário (dict) como parâmetro
609 |     param_test(*tupla)  # Tupla (tuple) como parâmetro  
610 |     param_test(*lista)  # Lista (list) como parâmetro
611 |     param_test(*conjunto)  # Conjunto (set) como parâmetro
612 | 
613 | .. code-block:: console
614 | 
615 |     7
616 | 
617 | 
618 | 
619 | Boas Práticas: Função Main
620 | --------------------------
621 | 
622 | |   Evite execuções globais, quebre seu código em funções o que facilita o
623 | | reúso e teste de código.
624 | |   Crie uma função principal (main). Crie primeiro as outras funções e por
625 | | último a ser definida a função principal.
626 | |   Na função principal serão feitas as chamadas às outras funções.
627 | |   Outra coisa interessante a ser feita é colocar a função principal dentro
628 | | de um if. Sendo que se for executado, terá a variável especial "__name__"
629 | | como valor "__main__".
630 | 
631 | 
632 | 
633 | Editando um script Python de teste:
634 | 
635 | .. code-block:: bash
636 | 
637 |     vim hello.py
638 | 
639 | .. code-block:: python
640 | 
641 |     #!/usr/bin/env python
642 |     #_*_ coding: utf-8 _*_
643 | 
644 |     def funcao():
645 |         print('Função executada')
646 | 
647 | 
648 |     def Main():
649 |         print('==== Início ====')
650 |         funcao()
651 |         print('==== Fim ====')
652 | 
653 | 
654 |     if __name__ == '__main__':
655 |         Main()
656 | 
657 | 
658 | 
659 | Execução do script:
660 | 
661 | .. code-block:: bash
662 | 
663 |     python hello.py 
664 | 
665 | .. code-block:: console
666 | 
667 |     ==== Início ====
668 |     Função executada
669 |     ==== Fim ====
670 | 
671 | 
672 | 
673 | Funções Geradoras
674 | -----------------
675 | 
676 | |   Uma função geradora ao invés de utilizar o comando return, utiliza o
677 | | comando yield, que retorna um objeto generator.
678 | 
679 | 
680 | 
681 | Criação de uma função geradora:
682 | 
683 | .. code-block:: python
684 | 
685 |     def f_gen(var):
686 |         print('INÍCIO')
687 | 
688 |         for i in var:
689 |             yield i
690 |         
691 |         print('FIM')
692 | 
693 | 
694 | 
695 | Criação de um generator pela função geradora e verificando seu tipo:
696 | 
697 | .. code-block:: python
698 | 
699 |     g = f_gen('Python')
700 |     type(g)
701 | 
702 | .. code-block:: console
703 | 
704 |     generator
705 | 
706 | 
707 | 
708 | Método next():
709 | 
710 | .. code-block:: python
711 | 
712 |     g.next()
713 | 
714 | .. code-block:: console
715 | 
716 |     INÍCIO
717 |     'P'
718 | 
719 | .. code-block:: python
720 | 
721 |     g.next()
722 | 
723 | 
724 | .. code-block:: console
725 | 
726 |     'y'
727 | 
728 | .. code-block:: python
729 | 
730 |     g.next()
731 | 
732 | .. code-block:: console
733 |     
734 |     't'
735 | 
736 | .. code-block:: python
737 | 
738 |     g.next()
739 | 
740 | .. code-block:: console
741 | 
742 |     'h'
743 | 
744 | .. code-block:: python
745 | 
746 |     g.next()
747 | 
748 | .. code-block:: console
749 | 
750 |     'o'
751 | 
752 | .. code-block:: python
753 | 
754 |     g.next()
755 | 
756 | .. code-block:: console
757 | 
758 |     'n'
759 | 
760 | .. code-block:: python
761 | 
762 |     g.next()
763 | 
764 | .. code-block:: console
765 | 
766 |     FIM
767 | 
768 |     StopIteration: . . .
769 | 
770 | 
771 | Funções Lambda
772 | --------------
773 | 
774 | |	São funções anônimas, ou seja, que não são associadas a um nome. Um
775 | | recurso similar às funções anônimas em PL/pgSQL (PostgreSQL).
776 | |   Sua estrutura é composta apenas por expressões, o que a torna muito
777 | | limitada, no entanto consome menos recursos do que uma função convencional. 
778 | |   Por só aceitar expressões, o comando return não é permitido em sua
779 | | estrutura.
780 | 
781 | 
782 | 
783 | Execução de uma função lambda:
784 | 
785 | .. code-block:: python
786 | 
787 |     (lambda x, y: x + y)(5, 2)
788 | 
789 | .. code-block:: console
790 | 
791 |     7
792 | 
793 | 
794 | 
795 | Criando uma função através de uma função lambda e execução:
796 | 
797 | .. code-block:: python
798 | 
799 |     foo = lambda x, y: x ** y
800 |     print(foo(2, 5))
801 | 
802 | .. code-block:: console
803 | 
804 |     32


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