fix(guide): simplify directory structure

guide/portuguese/python/data-structures/dictionaries/index.md

@@ -0,0 +1,130 @@
+---
+title: The Python Dict
+localeTitle: O Dict Python
+---
+Um Dicionário (também conhecido como "dict") em python é um tipo de dados interno que pode ser usado para armazenar pares de **`key-value`** . Isso permite que você trate um **`dict`** como se fosse um _banco_ de _dados_ para armazenar e organizar dados.
+
+A coisa especial sobre os dicionários é a maneira como eles são implementados. A estrutura tipo mesa de hash facilita a verificação de existência - o que significa que podemos determinar facilmente se uma chave específica está presente no dicionário sem precisar examinar cada elemento. O interpretador Python pode simplesmente ir até a chave de localização e verificar se a chave está lá.
+
+Dicionários podem usar quase todos os tipos de dados arbitrários, como strings, inteiros, etc., para chaves. No entanto, valores que não são hashable, ou seja, valores contendo listas, dicionários ou outros tipos mutáveis ​​(que são comparados por valor em vez de por identidade de objeto) não podem ser usados ​​como chaves. Os tipos numéricos usados ​​para teclas obedecem às regras normais de comparação numérica: se dois números forem iguais (como `1` e `1.0` ), eles poderão ser usados ​​de forma intercambiável para indexar a mesma entrada do dicionário. (Observe, no entanto, que, como os computadores armazenam números de ponto flutuante como aproximações, geralmente é insensato usá-los como chaves de dicionário.)
+
+Um requisito mais importante de um dicionário é que as chaves **devem** ser exclusivos.  
+Para criar um dicionário vazio, basta usar um par de chaves:
+
+```python
+    >>> teams = {} 
+    >>> type(teams) 
+    >>> <class 'dict'> 
+```
+
+  
+Para criar um dicionário não vazio com alguns valores iniciais, coloque uma lista separada por vírgula de pares de valores-chave:
+
+```python
+    >>> teams = {'barcelona': 1875, 'chelsea': 1910} 
+    >>> teams 
+    {'barcelona': 1875, 'chelsea': 1910} 
+```
+
+É fácil adicionar pares de valores-chave a um dicionário existente:
+
+```python
+    >>> teams['santos'] = 1787 
+    >>> teams 
+    {'chelsea': 1910, 'barcelona': 1875, 'santos': 1787} # Notice the order - Dictionaries are unordered ! 
+    >>> # extracting value - Just provide the key 
+    ... 
+    >>> teams['barcelona'] 
+    1875 
+```
+
+  
+**`del`** operator é usado para excluir um par de valores-chave do dict. Nos cenários em que uma chave que já está em uso é novamente usada para armazenar valores, o valor antigo associado a essa chave é completamente perdido. Além disso, lembre-se de que é um erro extrair o valor usando uma chave inexistente.
+
+```python
+    >>> del teams['santos'] 
+    >>> teams 
+    {'chelsea': 1910, 'barcelona': 1875} 
+    >>> teams['chelsea'] = 2017 # overwriting 
+    >>> teams 
+    {'chelsea': 2017, 'barcelona': 1875} 
+```
+
+  
+**`in`** palavra-chave pode ser usado para verificar se existe uma chave no dict ou não:
+
+```python
+    >>> 'sanots' in teams 
+    False 
+    >>> 'barcelona' in teams 
+    True 
+    >>> 'chelsea' not in teams 
+    False 
+```
+
+  
+**`keys`** é um _método interno_ que pode ser usado para obter as chaves de um determinado dicionário. Para extrair as chaves presentes em um dict como listas:
+
+```python
+    >>> club_names = list(teams.keys()) 
+    >>> club_names 
+    ['chelsea', 'barcelona'] 
+```
+
+  
+Ainda outra maneira de criar dicionário é usando o método **`dict()`** :
+
+```python
+    >>> players = dict( [('messi','argentina'), ('ronaldo','portugal'), ('kaka','brazil')] ) # sequence of key-value pair is passed 
+    >>> players 
+    {'ronaldo': 'portugal', 'kaka': 'brazil', 'messi': 'argentina'} 
+    >>> 
+    >>> # If keys are simple strings, it's quite easier to specify pairs using keyword arguments 
+    ... 
+    >>> dict( totti = 38, zidane = 43 ) 
+    {'zidane': 43, 'totti': 38} 
+```
+
+As compreensões de ditado podem ser usadas também para criar dicionários a partir de expressões arbitrárias de chave e valor:
+
+```python
+    >>> {x: x**2 for x in (2, 4, 6)} 
+    {2: 4, 4: 16, 6: 36} 
+```
+
+**Looping no dicionário**  
+Para simplesmente percorrer as teclas no dicionário, em vez das chaves e valores:
+
+```python
+    >>> d = {'x': 1, 'y': 2, 'z': 3} 
+    >>> for key in d: 
+    ...     print(key) # do something 
+    ... 
+    x 
+    y 
+    z 
+```
+
+Para repetir a chave e o valor, você pode usar o seguinte:  
+Para Python 2.x:
+
+```python
+    >>> for key, item in d.iteritems(): 
+    ...     print items 
+    ... 
+    1 
+    2 
+    3 
+```
+
+Use **`items()`** para o Python 3.x:
+
+```python
+    >>> for key, item in d.items(): 
+    ...     print(key, items) 
+    ... 
+    x 1 
+    y 2 
+    z 3 
+
+```

guide/portuguese/python/data-structures/floating-point-numbers/index.md

@@ -0,0 +1,118 @@
+---
+title: Python Floating Point Numbers
+localeTitle: Números de pontos flutuantes em Python
+---
+Algumas informações gerais sobre números de ponto flutuante e como elas funcionam em Python podem ser encontradas [aqui](https://docs.python.org/3/tutorial/floatingpoint.html) .
+
+Quase todas as implementações do Python seguem a especificação IEEE 754: Standard para aritmética binária de ponto flutuante. Mais informações encontradas no [site](http://grouper.ieee.org/groups/754/) do [IEEE](http://grouper.ieee.org/groups/754/) .
+
+Objetos flutuantes podem ser criados usando o uso de [literais de ponto flutuante](https://docs.python.org/3/reference/lexical_analysis.html#floating-point-literals) :
+```
+>>> 3.14 
+ 3.14 
+ >>> 314\.    # Trailing zero(s) not required. 
+ 314.0 
+ >>> .314    # Leading zero(s) not required. 
+ 0.314 
+ >>> 3e0 
+ 3.0 
+ >>> 3E0     # 'e' or 'E' can be used. 
+ 3.0 
+ >>> 3e1     # Positive value after e moves the decimal to the right. 
+ 30.0 
+ >>> 3e-1    # Negative value after e moves the decimal to the left. 
+ 0.3 
+ >>> 3.14e+2 # '+' not required but can be used for exponent part. 
+ 314.0 
+```
+
+Literais numéricos não contêm um sinal, no entanto, criar objetos float negativos é possível prefixando com um operador unário `-` (menos) sem espaço antes do literal
+```
+>>> -3.141592653589793 
+ -3.141592653589793 
+ >>> type(-3.141592653589793) 
+ <class 'float'> 
+```
+
+Da mesma forma, objetos float positivos podem ser prefixados com um operador unário `+ (` mais) sem espaço antes do literal. Geralmente `+` é omitido:
+```
+>>> +3.141592653589793 
+ 3.141592653589793 
+```
+
+Observe que zero (s) inicial e final (es) são válidos para literais de ponto flutuante
+```
+>>> 0.0 
+ 0.0 
+ >>> 00.00 
+ 0.0 
+ >>> 00100.00100 
+ 100.001 
+ >>> 001e0010      # Same as 1e10 
+ 10000000000.0 
+```
+
+O [construtor `float`](https://docs.python.org/3/library/functions.html#float) é outra maneira de criar objetos `float` .
+
+Criando `float` objectos com literais de ponto flutuante é preferido quando possível:
+```
+>>> a = 3.14         # Prefer floating point literal when possible. 
+ >>> type(a) 
+ <class 'float'> 
+ >>> b = int(3.14)    # Works but unnecessary. 
+ >>> type(b) 
+ <class 'float'> 
+```
+
+No entanto, o construtor float permite criar objetos float de outros tipos de números:
+```
+>>> a = 4 
+ >>> type(a) 
+ <class 'int'> 
+ >>> print(a) 
+ 4 
+ >>> b = float(4) 
+ >>> type(b) 
+ <class 'float'> 
+ >>> print(b) 
+ 4.0 
+ >>> float(400000000000000000000000000000000) 
+ 4e+32 
+ >>> float(.00000000000000000000000000000004) 
+ 4e-32 
+ >>> float(True) 
+ 1.0 
+ >>> float(False) 
+ 0.0 
+```
+
+O construtor `float` também fará objetos `float` de strings que representam literais numéricos:
+```
+>>> float('1') 
+ 1.0 
+ >>> float('.1') 
+ 0.1 
+ >>> float('3.') 
+ 3.0 
+ >>> float('1e-3') 
+ 0.001 
+ >>> float('3.14') 
+ 3.14 
+ >>> float('-.15e-2') 
+ -0.0015 
+```
+
+O construtor `float` também pode ser usado para fazer uma representação numérica de `NaN` (Não um Número), `infinity` negativo e `infinity` (cadeias de notas para estas são insensíveis a maiúsculas e minúsculas):
+```
+>>> float('nan') 
+ nan 
+ >>> float('inf') 
+ inf 
+ >>> float('-inf') 
+ -inf 
+ >>> float('infinity') 
+ inf 
+ >>> float('-infinity') 
+ -inf 
+
+```

guide/portuguese/python/data-structures/index.md

@@ -0,0 +1,18 @@
+---
+title: The Python Data Structures
+localeTitle: As estruturas de dados do Python
+---
+Uma estrutura de dados é uma maneira particular de organizar dados em um computador para que possa ser usada com eficiência. O Python vem com um conjunto robusto de estruturas de dados embutidas. Alguns dos mais usados ​​são: -
+
+*   Listas
+*   Tuplas
+*   Dicionários
+
+Principalmente, as estruturas de dados podem ser divididas em duas categorias:
+
+*   Mutável: - Uma estrutura de dados mutável é uma estrutura cujo estado pode ser modificado depois de criado. Listas e dicionários de Python são mutáveis.
+*   Imutável: - Uma estrutura de dados imutável não pode ser modificada. Exemplo: - Uma vez que uma tupla é criada, não podemos atualizar os valores dentro dela.
+
+## Referência:
+
+[Estruturas de Dados Python](https://docs.python.org/3.7/tutorial/datastructures.html)

guide/portuguese/python/data-structures/integers/index.md

@@ -0,0 +1,165 @@
+---
+title: Python Integers
+localeTitle: Inteiros em Python
+---
+O domínio teórico para números inteiros em python é infinito negativo até o infinito. Na prática, os valores inteiros são limitados pela quantidade de memória disponível.
+
+No Python 2, havia uma distinção entre **`int`** , números que se encaixam em números _longos_ e **`long`** , de 32 ou 64 bits, limitados pela memória disponível. O Python 3 unificou os dois tipos em apenas **`int`** , mais informações no [PEP 237](https://www.python.org/dev/peps/pep-0237/) .
+
+**criação `int` usando literais inteiros**
+
+[Literais Inteiros](https://docs.python.org/3/reference/lexical_analysis.html#integer-literals)
+
+_Objetos inteiros_ podem ser criados usando o uso de literais inteiros. Números sem adornos sem decimais são literais inteiros:
+```
+>>> 1234567890           # Unadorned numbers are integer literals 
+ 1234567890 
+ >>> type(1234567890) 
+ <class 'int'> 
+```
+
+Literais numéricos não contêm um sinal, no entanto, é possível criar _objetos inteiros_ negativos prefixando com um operador unário `-` (menos) sem espaço antes do literal:
+```
+>>> -1234567890 
+ -1234567890 
+ >>> type(-1234567890) 
+ <class 'int'> 
+```
+
+Da mesma forma, objetos inteiros positivos podem ser criados prefixando um operador unário `+` (mais) sem espaço antes dos dígitos. Normalmente `+` é omitido:
+```
+>>> +1234 
+ 1234 
+```
+
+Os números inteiros binários (base 2, prefixo: `0b` ou `0B` ), octal (base 8, prefixo: `0o` ou `0O` ) e hexadecimal (base 16, prefixo: `0x` ou `0X` ) também podem ser criados usando literais de inteiros:
+```
+>>> 0b1, 0b10, 0b11 
+ (1, 2, 3) 
+ >>> 0o1, 0o10, 0o11 
+ (1, 8, 9) 
+ >>> 0x1, 0x10, 0x11 
+ (1, 16, 17) 
+```
+
+Observe que os 0s iniciais para literais inteiros diferentes de zero **não** são **permitidos** :
+```
+>>> 0     # Zero by itself is okay. 
+ 0 
+ >>> 01    # Leading zero(s) cause SyntaxError. 
+  File "<stdin>", line 1 
+    01 
+     ^ 
+ SyntaxError: invalid token 
+```
+
+O [construtor](https://docs.python.org/3/library/functions.html#int) `int` é outra maneira de criar _objetos inteiros_ .
+```
+class int(x=0) 
+ class int(x, base=10) 
+```
+
+Criar _objetos inteiros_ com literais inteiros é preferível quando possível:
+```
+>>> a = 1         # Prefer integer literal when possible. 
+ >>> type(a) 
+ <class 'int'> 
+ >>> b = int(1)    # Works but unnecessary. 
+ >>> type(b) 
+ <class 'int'> 
+```
+
+No entanto, o construtor permite criar _objetos inteiros_ de outros tipos de números:
+```
+>>> a = 1.123 
+ >>> type(a) 
+ <class 'float'> 
+ >>> print(a) 
+ 1.123 
+ >>> b = int(1.123) 
+ >>> type(b) 
+ <class 'int'> 
+ >>> print(b) 
+ 1 
+```
+
+Usando o construtor `int` para números de ponto flutuante truncará o número em direção a zero:
+```
+>>> int(-1.23) 
+ -1 
+ >>> int(1.23) 
+ 1 
+```
+
+As constantes `boolean` internas são instâncias da classe `bool` e são subclasses da classe `int` , tornando-as uma espécie de tipo numérico:
+```
+>>> type(True) 
+ <class 'bool'> 
+ >>> issubclass(bool, int) 
+ True 
+```
+
+Se isso não faz sentido para você, não se preocupe. Por enquanto, lembre-se de que chamar o construtor int com objetos `boolean` retornará _objetos inteiros_ :
+```
+>>> int(True) 
+ 1 
+ >>> int(False) 
+ 0 
+```
+
+O construtor `int` também fará _objetos inteiros a_ partir de strings:
+```
+>>> a = "10" 
+ >>> type(a) 
+ <class 'str'> 
+ >>> b = int("10") 
+ >>> type(b) 
+ <class 'int'> 
+```
+
+_Strings_ para o construtor `int` devem representar um literal inteiro:
+
+O segundo parâmetro do construtor `int` é especificar uma base (padrão: 10). Bases válidas são 0 e 2-36.
+
+Se uma base explícita for fornecida, o primeiro argumento deve ser uma string.
+```
+>>> int("111", 2) 
+ 7 
+ >>> int(111, 2) 
+ Traceback (most recent call last): 
+  File "<stdin>", line 1, in <module> 
+ TypeError: int() can't convert non-string with explicit base 
+```
+
+A string usada para o construtor `int` com uma base explícita deve ser um literal inteiro válido para essa base:
+```
+>>> int('11', 2) 
+ 3 
+ >>> int('12', 2) 
+ Traceback (most recent call last): 
+  File "<stdin>", line 1, in <module> 
+ ValueError: invalid literal for int() with base 2: '12' 
+```
+
+Ambas as sequências prefixadas e não prefixadas de literais inteiros podem ser usadas, no entanto, se usadas, o prefixo deve corresponder à base fornecida.
+```
+>>> int('1101', 2) 
+ 13 
+ >>> int('0b1101', 2) 
+ 13 
+ >>> int('0x1101', 2) 
+ Traceback (most recent call last): 
+  File "<stdin>", line 1, in <module> 
+ ValueError: invalid literal for int() with base 2: '0x1101' 
+```
+
+Se uma seqüência de caracteres prefixada e base 0 for usada, o objeto inteiro criado usará a base especificada pelo prefixo. Se nenhum prefixo for usado, então a base é assumida 10
+```
+>>> int('100', 0) 
+ 100 
+ >>> int('0b100', 0) 
+ 4 
+ >>> int('0o100', 0) 
+ 64 
+
+```

guide/portuguese/python/data-structures/objects/index.md

@@ -0,0 +1,116 @@
+---
+title: The Python Objects
+localeTitle: Os objetos do Python
+---
+> No Python, tudo é um _objeto_ .
+
+_Objetos_ representam um agrupamento lógico de atributos. Atributos são dados e / ou funções. Quando um objeto é criado no Python, ele é criado com uma _identidade_ , _tipo_ e _valor_ .
+
+Em outras linguagens, os _primitivos_ são _valores_ que não possuem _propriedades_ (atributos). Por exemplo, em javascript `undefined` , `null` , `boolean` , `string` , `number` e `symbol` (novo no ECMAScript 2015) são primitivos.
+
+Em Python, não há primitivos. `None` , _booleanas_ , _cadeias de caracteres_ , _números_ e _funções_ pares são todos os _objetos,_ independentemente de como eles são criados.
+
+Podemos demonstrar isso usando algumas funções internas:
+
+*   [`id`](https://docs.python.org/3/library/functions.html#id)
+*   [`type`](https://docs.python.org/3/library/functions.html#type)
+*   [`dir`](https://docs.python.org/3/library/functions.html#dir)
+*   [`issubclass`](https://docs.python.org/3/library/functions.html#issubclass)
+
+Constantes `None` , `True` e `False` são _objetos_ :
+
+Nós testamos o objeto `None` aqui.
+
+```python
+>>> id(None) 
+ 4550218168 
+ >>> type(None) 
+ <class 'NoneType'> 
+ >>> dir(None) 
+ [__bool__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__'] 
+ >>> issubclass(type(None), object) 
+ True 
+```
+
+Em seguida, vamos inspecionar `True` .
+
+```python
+>>> id(True) 
+ 4550117616 
+ >>> type(True) 
+ <class 'bool'> 
+ >>> dir(True) 
+ ['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes'] 
+ >>> issubclass(type(True), object) 
+ True 
+```
+
+Nenhuma razão para deixar de fora `False` !
+
+```python
+>>> id(False) 
+ 4550117584 
+ >>> type(False) 
+ <class 'bool'> 
+ >>> dir(False) 
+ ['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes'] 
+ >>> issubclass(type(False), object) 
+ True 
+```
+
+_Strings_ , mesmo quando criadas por literais de string, também são _objetos_ .
+
+```python
+>>> id("Hello campers!") 
+ 4570186864 
+ >>> type('Hello campers!') 
+ <class 'str'> 
+ >>> dir("Hello campers!") 
+ ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill'] 
+ >>> issubclass(type('Hello campers!'), object) 
+ True 
+```
+
+O mesmo com os _números_
+
+```python
+>>> id(42) 
+ 4550495728 
+ >>> type(42) 
+ <class 'int'> 
+ >>> dir(42) 
+ ['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes'] 
+ >>> issubclass(type(42), object) 
+ True 
+```
+
+## Funções são objetos também
+
+> No Python, as funções são objetos de primeira classe.
+
+_Funções_ em Python também são _objetos_ , criados com uma _identidade_ , _tipo_ e _valor_ . Eles também podem ser passados ​​para outras _funções_ :
+
+```python
+>>> id(dir) 
+ 4568035688 
+ >>> type(dir) 
+ <class 'builtin_function_or_method'> 
+ >>> dir(dir) 
+ ['__call__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__text_signature__'] 
+ >>> issubclass(type(dir), object) 
+ True 
+```
+
+Também é possível ligar funções a um nome e chamar a função ligada usando esse nome:
+
+```python
+>>> a = dir 
+ >>> print(a) 
+ <built-in function dir> 
+ >>> a(a) 
+ ['__call__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__text_signature__'] 
+```
+
+Recursos:
+
+*   [Clique aqui](https://www.jeffknupp.com/blog/2014/06/18/improve-your-python-python-classes-and-object-oriented-programming/) para saber mais.

guide/portuguese/python/data-structures/ranges/index.md

@@ -0,0 +1,87 @@
+---
+title: The Python Range
+localeTitle: O intervalo do Python
+---
+## Faixas Python
+
+Em vez de ser uma função, um intervalo é, na verdade, um [tipo de sequência imutável](https://docs.python.org/3/library/stdtypes.html#immutable-sequence-types) e é comumente usado para fazer um loop de um número específico de vezes em loops forçados.
+
+**Criação:**
+
+`ranges` são criados usando o construtor de `range` . Os parâmetros para o construtor são:
+
+*   `start` : o primeiro valor inclusivo do intervalo (inteiro opcional, o padrão é 0).
+*   `stop` : Valor de parada exclusivo, o intervalo é interrompido quando esse valor ou maior for fornecido (inteiro obrigatório).
+*   `step` : A quantia adicionada ao valor atual para obter o próximo valor (inteiro opcional, o padrão é 1).
+
+```python
+>>> range(10)          # Only the stop parameter is required. 
+ range(0, 10) 
+ >>> range(0, 10)       # Default for start parameter is 0. 
+ range(0, 10) 
+ >>> range(0, 10, 1)    # Default for step is 1\. Start parameter is required if 
+ step is needed. 
+ range(0, 10) 
+```
+
+**Exemplos:**
+
+Como os `ranges` são iteráveis, eles podem ser passados ​​para a `list` e os construtores da `tuple` para criar esses tipos de sequências. Usando esse fato, podemos visualizar alguns exemplos:
+
+```python
+>>> list(range(10))     # range as argument for list constructor. 
+ [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
+ >>> tuple(range(10))    # range as argument for tuple constructor. 
+ (0, 1, 2, 3, 4, 5, 6, 7, 8, 9) 
+```
+
+`ranges` comprimento zero:
+
+```python
+>>> list(range(10, 0))        # start greater than stop with postive step. 
+ [] 
+ >>> list(range(10, 10))       # start equal to stop with postive step. 
+ [] 
+ >>> list(range(10, 10, -1))   # start equal to stop with negative step. 
+ [] 
+ >>> list(range(0, 10, -1))    # start less than stop with negative step. 
+ [] 
+```
+
+`ranges` com argumentos de passo:
+
+```python
+>>> list(range(0, 10, 2))       # next value would be 10, stops at 8. 
+ [0, 2, 4, 6, 8] 
+ >>> list(range(0, 10, 3))       # next value would be 12, stops at 9. 
+ [0, 3, 6, 9] 
+ >>> list(range(0, 10, 4))       # next value would be 12, stops at 8. 
+ [0, 4, 8] 
+ >>> list(range(10, 0, -1))      # negative step makes decreasing ranges. 
+ [10, 9, 8, 7, 6, 5, 4, 3, 2, 1] 
+ >>> list(range(-5, -30, -3))    # negative integers are valid arguments. 
+ [-5, -8, -11, -14, -17, -20, -23, -26, -29] 
+```
+
+**Benefícios:**
+
+O benefício de usar o `range` é que, independentemente do tamanho de um intervalo especificado, apenas uma pequena quantidade de memória é necessária para armazenar o `range` , os valores para iniciar, parar e etapa. Os valores individuais dos `ranges` são calculados após a iteração.
+
+```python
+>>> import sys 
+ >>> a_range = range(1000000) 
+ >>> a_list = list(a_range) 
+ >>> a_tuple = tuple(a_range) 
+ >>> sys.getsizeof(a_range) 
+ 48 
+ >>> sys.getsizeof(a_list) 
+ 9000112 
+ >>> sys.getsizeof(a_tuple) 
+ 8000048 
+```
+
+### Mais Inforamtion:
+
+[Python Doc - Ranges](https://docs.python.org/3/library/stdtypes.html#ranges)
+
+**TODO: os `ranges` métodos executam e não implementam**

guide/portuguese/python/data-structures/scopes/index.md

@@ -0,0 +1,13 @@
+---
+title: The Python Scopes
+localeTitle: Os escopos do Python
+---
+**TODO: NOTA**
+
+*   Isso pertence perto do bloco de código e informações de recuo.
+*   Isso também está relacionado a variáveis, pois a localização e vinculação de nomes está relacionada a escopos.
+
+**TODO: CONTEÚDO**
+
+*   `global`
+*   `nonlocal`

guide/portuguese/python/data-structures/strings/index.md

@@ -0,0 +1,36 @@
+---
+title: The Python Strings
+localeTitle: As cordas do Python
+---
+O Python permite que objetos `str` , ou _strings_ , sejam expressos de algumas maneiras diferentes:
+
+*   Aspas simples: `'Single quote strings can have "double" quotes inside.'`
+    
+*   Aspas duplas: `"Double quote strings can have 'single' quotes inside."`
+    
+*   Triplo citado:
+    
+    ```
+    """Triple quoted strings can span multiple lines. 
+     Unescaped "double" and 'single' quotes in triple quoted strings are retained.""" 
+     
+     '''Triple quoted strings can be 'single'or "double" quotes. 
+     Unescaped newlines are also retained.''' 
+    
+    ```
+    
+*   Imutável: Você não pode editar / alterar diretamente uma string do Python depois de criá-la. Por exemplo, se você tentar reatribuir / alterar diretamente a primeira letra de uma string, um erro será lançado.
+    
+    ```
+    >>> foo = "my string" 
+     >>> foo[0] = "a" 
+     Traceback (most recent call last): 
+            File "<stdin>", line 1, in <module> 
+     TypeError: 'str' object does not support item assignment 
+    
+    ```
+    
+
+## Referência:
+
+[Tipo de Sequência de Texto _str_](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)

guide/portuguese/python/data-structures/tuples/index.md

@@ -0,0 +1,196 @@
+---
+title: The Tuples
+localeTitle: As tuplas
+---
+## As tuplas
+
+Uma tupla é uma sequência de objetos Python. As tuplas são imutáveis, o que significa que não podem ser modificadas após a criação, ao contrário das listas.
+
+**Criação:**
+
+Uma `tuple` vazia é criada usando um par de parênteses, `()` :
+
+```shell
+    >>> empty_tuple = () 
+    >>> print(empty_tuple) 
+    () 
+    >>> type(empty_tuple) 
+    <class 'tuple'> 
+    >>> len(empty_tuple) 
+    0 
+```
+
+Uma `tuple` com elementos é criada ao separar os elementos com vírgulas (os parêntesis circundantes, `()` são opcionais com exceções):
+
+```shell
+    >>> tuple_1 = 1, 2, 3       # Create tuple without round brackets. 
+    >>> print(tuple_1) 
+    (1, 2, 3) 
+    >>> type(tuple_1) 
+    <class 'tuple'> 
+    >>> len(tuple_1) 
+    3 
+    >>> tuple_2 = (1, 2, 3)     # Create tuple with round brackets. 
+    >>> print(tuple_2) 
+    (1, 2, 3) 
+    >>> tuple_3 = 1, 2, 3,      # Trailing comma is optional. 
+    >>> print(tuple_3) 
+    (1, 2, 3) 
+    >>> tuple_4 = (1, 2, 3,)    # Trailing comma in round brackets is also optional. 
+    >>> print(tuple_4) 
+    (1, 2, 3) 
+```
+
+Uma `tuple` com um único elemento deve ter a vírgula final (com ou sem colchetes):
+
+```shell
+    >>> not_tuple = (2)    # No trailing comma makes this not a tuple. 
+    >>> print(not_tuple) 
+    2 
+    >>> type(not_tuple) 
+    <class 'int'> 
+    >>> a_tuple = (2,)     # Single element tuple. Requires trailing comma. 
+    >>> print(a_tuple) 
+    (2,) 
+    >>> type(a_tuple) 
+    <class 'tuple'> 
+    >>> len(a_tuple) 
+    1 
+    >>> also_tuple = 2,    # Round brackets omitted. Requires trailing comma. 
+    >>> print(also_tuple) 
+    (2,) 
+    >>> type(also_tuple) 
+    <class 'tuple'> 
+```
+
+Colchetes são necessários em casos de ambigüidade (se a tupla fizer parte de uma expressão maior):
+
+> Note que na verdade é a vírgula que faz uma tupla, não os parênteses. Os parênteses são opcionais, exceto no caso da tupla vazia, ou quando são necessários para evitar ambigüidade sintática. Por exemplo, `f(a, b, c)` é uma chamada de função com três argumentos, enquanto `f((a, b, c))` é uma chamada de função com uma 3-tupla como o único argumento.
+
+```shell
+    >>> print(1,2,3,4,)          # Calls print with 4 arguments: 1, 2, 3, and 4 
+    1 2 3 4 
+    >>> print((1,2,3,4,))        # Calls print with 1 argument: (1, 2, 3, 4,) 
+    (1, 2, 3, 4) 
+    >>> 1, 2, 3 == (1, 2, 3)     # Equivalent to 1, 2, (3 == (1, 2, 3)) 
+    (1, 2, False) 
+    >>> (1, 2, 3) == (1, 2, 3)   # Use surrounding round brackets when ambiguous. 
+    True 
+```
+
+Uma `tuple` também pode ser criada com o construtor da `tuple` :
+
+```shell
+    >>> empty_tuple = tuple() 
+    >>> print(empty_tuple) 
+    () 
+    >>> tuple_from_list = tuple([1,2,3,4]) 
+    >>> print(tuple_from_list) 
+    (1, 2, 3, 4) 
+    >>> tuple_from_string = tuple("Hello campers!") 
+    >>> print(tuple_from_string) 
+    ('H', 'e', 'l', 'l', 'o', ' ', 'c', 'a', 'm', 'p', 'e', 'r', 's', '!') 
+    >>> a_tuple = 1, 2, 3 
+    >>> b_tuple = tuple(a_tuple)    # If the constructor is called with a tuple for 
+    the iterable, 
+    >>> a_tuple is b_tuple          # the tuple argument is returned. 
+    True 
+```
+
+**Acessando elementos de uma `tuple` :**
+
+Elementos de `tuples` são acessados ​​e indexados da mesma maneira que as `lists` .
+
+```shell
+    >>> my_tuple = 1, 2, 9, 16, 25 
+    >>> print(my_tuple) 
+    (1, 2, 9, 16, 25) 
+```
+
+_Zero indexado_
+
+```shell
+    >>> my_tuple[0] 
+    1 
+    >>> my_tuple[1] 
+    2 
+    >>> my_tuple[2] 
+    9 
+```
+
+_Envolva a indexação_
+
+```shell
+    >>> my_tuple[-1] 
+    25 
+    >>> my_tuple[-2] 
+    16 
+```
+
+**Embalagem e Desembalagem:**
+
+A declaração `t = 12345, 54321, 'hello!'` é um exemplo de empacotamento de tupla: os valores `12345` , `54321` e `'hello!'` são embalados juntos em uma tupla. A operação inversa também é possível:
+
+```shell
+    >>> x, y, z = t 
+```
+
+Isso é chamado, apropriadamente, de descompactação de seqüência e funciona para qualquer sequência do lado direito. A descompactação de sequências requer que haja tantas variáveis ​​no lado esquerdo do sinal de igual quanto há elementos na sequência. Observe que a atribuição múltipla é realmente apenas uma combinação de empacotamento de tupla e descompactação de sequência.
+
+```shell
+    >>> t = 1, 2, 3    # Tuple packing. 
+    >>> print(t) 
+    (1, 2, 3) 
+    >>> a, b, c = t    # Sequence unpacking. 
+    >>> print(a) 
+    1 
+    >>> print(b) 
+    2 
+    >>> print(c) 
+    3 
+    >>> d, e, f = 4, 5, 6    # Multiple assignment combines packing and unpacking. 
+    >>> print(d) 
+    4 
+    >>> print(e) 
+    5 
+    >>> print(f) 
+    6 
+    >>> a, b = 1, 2, 3       # Multiple assignment requires each variable (right) 
+    have a matching element (left). 
+    Traceback (most recent call last): 
+      File "<stdin>", line 1, in <module> 
+    ValueError: too many values to unpack (expected 2) 
+```
+
+**Imutável:**
+
+`tuples` são contêineres imutáveis, garantindo **que os** objetos que contêm não serão alterados. Ele **não** garante que os objetos que contém não mudará:
+
+```shell
+    >>> a_list = [] 
+    >>> a_tuple = (a_list,)    # A tuple (immutable) with a list (mutable) element. 
+    >>> print(a_tuple) 
+    ([],) 
+ 
+    >>> a_list.append("Hello campers!") 
+    >>> print(a_tuple)         # Element of the immutable is mutated. 
+    (['Hello campers!'],) 
+```
+
+**Usos:**
+
+Funções só podem retornar um único valor, no entanto, uma `tuple` heterogênea pode ser usada para retornar vários valores de uma função. Um exemplo é a função de `enumerate` interna que retorna um iterável de `tuples` heterogêneas:
+
+```shell
+    >>> greeting = ["Hello", "campers!"] 
+    >>> enumerator = enumerate(greeting) 
+    >>> enumerator.next() 
+    >>> enumerator.__next__() 
+    (0, 'Hello') 
+    >>> enumerator.__next__() 
+    (1, 'campers!') 
+```
+
+### Mais Inforamtion:
+
+[Documentos em Python - Tuplas](https://docs.python.org/3/library/stdtypes.html#tuples)