fix(guide): simplify directory structure

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

@@ -0,0 +1,130 @@
+---
+title: The Python Dict
+localeTitle: El Dict Python
+---
+Un Diccionario (también conocido como "dict") en python es un tipo de datos incorporado que se puede usar para almacenar pares **`key-value`** . Esto le permite tratar un **`dict`** como si fuera una _base_ de _datos_ para almacenar y organizar datos.
+
+Lo especial de los diccionarios es la forma en que se implementan. La estructura tipo tabla de hash facilita la comprobación de existencia, lo que significa que podemos determinar fácilmente si una clave específica está presente en el diccionario sin necesidad de examinar cada elemento El intérprete de Python puede simplemente ir a la clave de ubicación y verificar si la clave está allí.
+
+Los diccionarios pueden usar casi cualquier tipo de datos arbitrarios, como cadenas, enteros, etc., para las claves. Sin embargo, los valores que no son hashable, es decir, los valores que contienen listas, diccionarios u otros tipos mutables (que se comparan por valor en lugar de por identidad de objeto) no se pueden usar como claves. Los tipos numéricos utilizados para las teclas obedecen las reglas normales para la comparación numérica: si dos números se comparan de la misma manera (como `1` y `1.0` ), se pueden usar indistintamente para indexar la misma entrada del diccionario. (Sin embargo, tenga en cuenta que dado que las computadoras almacenan números de punto flotante como aproximaciones, generalmente no es aconsejable usarlos como claves de diccionario).
+
+Un requisito más importante de un diccionario es que las claves **deben** ser únicas.  
+Para crear un diccionario vacío solo usa un par de llaves:
+
+```python
+    >>> teams = {} 
+    >>> type(teams) 
+    >>> <class 'dict'> 
+```
+
+  
+Para crear un diccionario no vacío con algunos valores iniciales, coloque una lista separada por comas de pares clave-valor:
+
+```python
+    >>> teams = {'barcelona': 1875, 'chelsea': 1910} 
+    >>> teams 
+    {'barcelona': 1875, 'chelsea': 1910} 
+```
+
+Es fácil agregar pares clave-valor a un diccionario 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`** operador se utiliza para eliminar un par clave-valor del dict. En los escenarios donde una clave que ya está en uso se usa de nuevo para almacenar valores, el valor antiguo asociado con esa clave se pierde por completo. Además, tenga en cuenta que es un error extraer el valor utilizando una clave que no existe.
+
+```python
+    >>> del teams['santos'] 
+    >>> teams 
+    {'chelsea': 1910, 'barcelona': 1875} 
+    >>> teams['chelsea'] = 2017 # overwriting 
+    >>> teams 
+    {'chelsea': 2017, 'barcelona': 1875} 
+```
+
+  
+**`in`** palabra clave se puede utilizar para verificar si existe una clave en el dict o no:
+
+```python
+    >>> 'sanots' in teams 
+    False 
+    >>> 'barcelona' in teams 
+    True 
+    >>> 'chelsea' not in teams 
+    False 
+```
+
+  
+**`keys`** es un _método_ incorporado que se puede usar para obtener las claves de un diccionario determinado. Para extraer las claves presentes en un dict como listas:
+
+```python
+    >>> club_names = list(teams.keys()) 
+    >>> club_names 
+    ['chelsea', 'barcelona'] 
+```
+
+  
+Otra forma de crear un diccionario es mediante el 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} 
+```
+
+Las comprensiones de Dict también se pueden utilizar para crear diccionarios a partir de expresiones de valor y clave arbitrarias:
+
+```python
+    >>> {x: x**2 for x in (2, 4, 6)} 
+    {2: 4, 4: 16, 6: 36} 
+```
+
+**Bucle en Diccionario**  
+Para simplemente pasar las claves en el diccionario, en lugar de las claves y valores:
+
+```python
+    >>> d = {'x': 1, 'y': 2, 'z': 3} 
+    >>> for key in d: 
+    ...     print(key) # do something 
+    ... 
+    x 
+    y 
+    z 
+```
+
+Para recorrer tanto la clave como el valor, puede utilizar lo siguiente:  
+Para Python 2.x:
+
+```python
+    >>> for key, item in d.iteritems(): 
+    ...     print items 
+    ... 
+    1 
+    2 
+    3 
+```
+
+Use **`items()`** para Python 3.x:
+
+```python
+    >>> for key, item in d.items(): 
+    ...     print(key, items) 
+    ... 
+    x 1 
+    y 2 
+    z 3 
+
+```

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

@@ -0,0 +1,118 @@
+---
+title: Python Floating Point Numbers
+localeTitle: Números de punto flotante de Python
+---
+[Aquí](https://docs.python.org/3/tutorial/floatingpoint.html) se puede encontrar información general sobre los números de punto flotante y cómo funcionan en Python.
+
+Casi todas las implementaciones de Python siguen la especificación IEEE 754: Estándar para aritmética de punto flotante binario. Más información se encuentra en el [sitio IEEE](http://grouper.ieee.org/groups/754/) .
+
+Los objetos flotantes se pueden crear utilizando [literales de punto flotante](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 
+```
+
+Los literales numéricos no contienen un signo, sin embargo, es posible crear objetos flotantes negativos prefijando con un operador unario `-` (menos) sin espacio antes del literal
+```
+>>> -3.141592653589793 
+ -3.141592653589793 
+ >>> type(-3.141592653589793) 
+ <class 'float'> 
+```
+
+Del mismo modo, los objetos flotantes positivos se pueden prefijar con un operador unario `+ (` más) sin espacio antes del literal. Normalmente se omite `+`
+```
+>>> +3.141592653589793 
+ 3.141592653589793 
+```
+
+Tenga en cuenta que los cero iniciales y finales son válidos para literales de punto flotante
+```
+>>> 0.0 
+ 0.0 
+ >>> 00.00 
+ 0.0 
+ >>> 00100.00100 
+ 100.001 
+ >>> 001e0010      # Same as 1e10 
+ 10000000000.0 
+```
+
+El [constructor `float`](https://docs.python.org/3/library/functions.html#float) es otra forma de crear objetos `float` .
+
+La creación de `float` objetos con los literales de punto flotante se prefiere cuando sea posible:
+```
+>>> a = 3.14         # Prefer floating point literal when possible. 
+ >>> type(a) 
+ <class 'float'> 
+ >>> b = int(3.14)    # Works but unnecessary. 
+ >>> type(b) 
+ <class 'float'> 
+```
+
+Sin embargo, el constructor flotante permite crear objetos flotantes de otros 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 
+```
+
+El constructor `float` también creará objetos `float` partir de cadenas que representan números literales:
+```
+>>> 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 
+```
+
+El constructor `float` también se puede usar para hacer una representación numérica de `NaN` (No es un número), `infinity` negativo e `infinity` (las cadenas de notas para estas son insensibles a mayúsculas y minúsculas):
+```
+>>> float('nan') 
+ nan 
+ >>> float('inf') 
+ inf 
+ >>> float('-inf') 
+ -inf 
+ >>> float('infinity') 
+ inf 
+ >>> float('-infinity') 
+ -inf 
+
+```

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

@@ -0,0 +1,18 @@
+---
+title: The Python Data Structures
+localeTitle: Las estructuras de datos de Python
+---
+Una estructura de datos es una forma particular de organizar los datos en una computadora para que pueda usarse de manera eficiente. Python viene con un conjunto robusto de estructuras de datos incorporadas. Algunos de los más utilizados son:
+
+*   Liza
+*   Tuplas
+*   Los diccionarios
+
+Principalmente, las estructuras de datos se pueden dividir en dos categorías:
+
+*   Mutable: una estructura de datos mutable es una estructura cuyo estado se puede modificar después de su creación. Las listas de Python y los diccionarios son mutables.
+*   Inmutable: - Una estructura de datos inmutable no puede ser modificada. Ejemplo: - Una vez que se crea una tupla, no podemos actualizar los valores dentro de ella.
+
+## Referencia:
+
+[Estructuras de datos de Python](https://docs.python.org/3.7/tutorial/datastructures.html)

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

@@ -0,0 +1,165 @@
+---
+title: Python Integers
+localeTitle: Enteros de Python
+---
+El dominio teórico para enteros en python es infinito negativo a infinito. En la práctica, los valores enteros están limitados por la cantidad de memoria disponible.
+
+En Python 2, había una distinción entre **`int`** , números que caben en números de 32 o 64 bit _C_ , y **`long`** , limitados por la memoria disponible. Python 3 unificó los dos tipos en solo **`int`** , más información en [PEP 237](https://www.python.org/dev/peps/pep-0237/) .
+
+**creación `int` utilizando literales enteros**
+
+[Literales enteros](https://docs.python.org/3/reference/lexical_analysis.html#integer-literals)
+
+_Los objetos enteros_ se pueden crear utilizando literales enteros. Los números sin adornos sin decimales son literales enteros:
+```
+>>> 1234567890           # Unadorned numbers are integer literals 
+ 1234567890 
+ >>> type(1234567890) 
+ <class 'int'> 
+```
+
+Los literales numéricos no contienen un signo, sin embargo, es posible crear _objetos enteros_ negativos prefijando con un operador unario `-` (menos) sin espacio antes del literal:
+```
+>>> -1234567890 
+ -1234567890 
+ >>> type(-1234567890) 
+ <class 'int'> 
+```
+
+Del mismo modo, los objetos enteros positivos se pueden crear prefijando un operador unario `+` (más) sin espacio antes de los dígitos. Por lo general, `+` es omitido:
+```
+>>> +1234 
+ 1234 
+```
+
+Los enteros binarios (base 2, prefijo: `0b` o `0B` ), octal (base 8, prefijo: `0o` o `0O` ) y hexadecimal (base 16, prefijo: `0x` o `0X` ) también pueden crearse utilizando literales enteros:
+```
+>>> 0b1, 0b10, 0b11 
+ (1, 2, 3) 
+ >>> 0o1, 0o10, 0o11 
+ (1, 8, 9) 
+ >>> 0x1, 0x10, 0x11 
+ (1, 16, 17) 
+```
+
+Tenga en cuenta que los 0 iniciales para los literales enteros distintos de cero **no** están **permitidos** :
+```
+>>> 0     # Zero by itself is okay. 
+ 0 
+ >>> 01    # Leading zero(s) cause SyntaxError. 
+  File "<stdin>", line 1 
+    01 
+     ^ 
+ SyntaxError: invalid token 
+```
+
+El [constructor](https://docs.python.org/3/library/functions.html#int) `int` es otra forma de crear _objetos enteros_ .
+```
+class int(x=0) 
+ class int(x, base=10) 
+```
+
+La creación de _objetos enteros_ con literales enteros se prefiere cuando es posible:
+```
+>>> a = 1         # Prefer integer literal when possible. 
+ >>> type(a) 
+ <class 'int'> 
+ >>> b = int(1)    # Works but unnecessary. 
+ >>> type(b) 
+ <class 'int'> 
+```
+
+Sin embargo, el constructor permite crear _objetos enteros_ de otros 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 
+```
+
+El uso del constructor `int` para los números de punto flotante truncará el número hacia cero:
+```
+>>> int(-1.23) 
+ -1 
+ >>> int(1.23) 
+ 1 
+```
+
+Las constantes `boolean` integradas son instancias de la clase `bool` , y son subclases de la clase `int` , lo que las convierte en un tipo de tipo numérico:
+```
+>>> type(True) 
+ <class 'bool'> 
+ >>> issubclass(bool, int) 
+ True 
+```
+
+Si eso no tiene sentido para ti, no te preocupes. Por ahora solo recuerda que llamar al constructor int con objetos `boolean` devolverá _objetos enteros_ :
+```
+>>> int(True) 
+ 1 
+ >>> int(False) 
+ 0 
+```
+
+El constructor `int` también creará _objetos enteros a_ partir de cadenas:
+```
+>>> a = "10" 
+ >>> type(a) 
+ <class 'str'> 
+ >>> b = int("10") 
+ >>> type(b) 
+ <class 'int'> 
+```
+
+_Las cadenas_ para el constructor `int` deben representar un literal entero:
+
+El segundo parámetro del constructor `int` es especificar una base (por defecto: 10). Las bases válidas son 0 y 2-36.
+
+Si se proporciona una base explícita, el primer argumento debe ser una cadena.
+```
+>>> 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 
+```
+
+La cadena utilizada para el constructor `int` con una base explícita debe ser un literal entero válido para esa 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' 
+```
+
+Se pueden usar tanto cadenas prefijadas como no prefijadas de literales enteros, sin embargo, si se usan, el prefijo debe coincidir con la base proporcionada.
+```
+>>> 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' 
+```
+
+Si se usa una cadena prefijada y una base 0, el objeto entero creado usará la base especificada por el prefijo. Si no se usa ningún prefijo, entonces se supone que la base 10
+```
+>>> int('100', 0) 
+ 100 
+ >>> int('0b100', 0) 
+ 4 
+ >>> int('0o100', 0) 
+ 64 
+
+```

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

@@ -0,0 +1,116 @@
+---
+title: The Python Objects
+localeTitle: Los objetos de Python
+---
+> En Python, todo es un _objeto_ .
+
+_Los objetos_ representan una agrupación lógica de atributos. Los atributos son datos y / o funciones. Cuando se crea un objeto en Python, se crea con una _identidad_ , _tipo_ y _valor_ .
+
+En otros idiomas, las _primitivas_ son _valores_ que no tienen _propiedades_ (atributos). Por ejemplo, en javascript `undefined` , `null` , `boolean` , `string` , `number` y `symbol` (nuevo en ECMAScript 2015) son primitivos.
+
+En Python, no hay primitivos. `None` , _booleanos_ , _cadenas_ , _números_ e incluso _funciones_ son _objetos,_ independientemente de cómo se creen.
+
+Podemos demostrar esto usando algunas funciones incorporadas:
+
+*   [`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)
+
+Las constantes incorporadas `None` , `True` y `False` son _objetos_ :
+
+Aquí probamos el objeto `None` .
+
+```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 
+```
+
+A continuación, vamos a inspeccionar el `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 
+```
+
+No hay razón para dejar de lado lo `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 
+```
+
+_Las cadenas_ , incluso cuando son creadas por literales de una cadena, también son _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 
+```
+
+Igual con _numeros_
+
+```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 
+```
+
+## Las funciones son objetos también
+
+> En Python, las funciones son objetos de primera clase.
+
+_Las funciones_ en Python también son _objetos_ , creados con una _identidad_ , _tipo_ y _valor_ . Ellos también pueden ser pasados ​​a otras _funciones_ :
+
+```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 
+```
+
+También es posible vincular funciones a un nombre y llamar a la función enlazada usando ese nombre:
+
+```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:
+
+*   [Haga clic aquí](https://www.jeffknupp.com/blog/2014/06/18/improve-your-python-python-classes-and-object-oriented-programming/) para obtener más información.

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

@@ -0,0 +1,87 @@
+---
+title: The Python Range
+localeTitle: El rango de Python
+---
+## Rangos de Python
+
+En lugar de ser una función, un rango es en realidad un [tipo de secuencia inmutable](https://docs.python.org/3/library/stdtypes.html#immutable-sequence-types) y se usa comúnmente para hacer un bucle un número específico de veces en los bucles.
+
+**Creación:**
+
+`ranges` se crean utilizando el constructor de `range` . Los parámetros para el constructor son:
+
+*   `start` : primer valor inclusivo del rango (entero opcional, predeterminado en 0).
+*   `stop` : valor de parada exclusivo, el rango se detiene cuando se proporcionará este valor o mayor (entero necesario).
+*   `step` : la cantidad agregada al valor actual para obtener el siguiente valor (entero opcional, predeterminado en 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) 
+```
+
+**Ejemplos:**
+
+Como los `ranges` son iterables, se pueden pasar a la `list` y a los constructores de `tuple` para crear esos tipos de secuencias. Usando este hecho, podemos visualizar algunos ejemplos:
+
+```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` longitud cero:
+
+```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` con argumentos de paso:
+
+```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] 
+```
+
+**Beneficios:**
+
+La ventaja de utilizar el `range` es que, independientemente del tamaño del rango especificado, solo se necesita una pequeña cantidad de memoria para almacenar el `range` , los valores de inicio, parada y paso. Los valores individuales de los `ranges` se calculan por iteración.
+
+```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 
+```
+
+### Más información:
+
+[Python Doc - Rangos](https://docs.python.org/3/library/stdtypes.html#ranges)
+
+**TODO: Métodos que los `ranges` implementan y no implementan.**

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

@@ -0,0 +1,13 @@
+---
+title: The Python Scopes
+localeTitle: Los alcances de Python
+---
+**TODO: NOTA**
+
+*   Esto pertenece cerca del bloque de código y la información de sangría.
+*   Esto también está relacionado con las variables, ya que la búsqueda de nombres y la vinculación están relacionadas con los ámbitos.
+
+**TODO: CONTENIDO**
+
+*   `global`
+*   `nonlocal`

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

@@ -0,0 +1,36 @@
+---
+title: The Python Strings
+localeTitle: Las cuerdas de Python
+---
+Python permite que los objetos `str` , o _cadenas_ , se expresen de diferentes maneras:
+
+*   Comillas simples: `'Single quote strings can have "double" quotes inside.'`
+    
+*   Comillas dobles: `"Double quote strings can have 'single' quotes inside."`
+    
+*   Triple 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.''' 
+    
+    ```
+    
+*   Inmutable: no puede editar / cambiar directamente una cadena Python después de haberla creado. Por ejemplo, si intenta reasignar / cambiar directamente la primera letra de una cadena, se produce un error.
+    
+    ```
+    >>> 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 
+    
+    ```
+    
+
+## Referencia:
+
+[Tipo de secuencia de texto _str_](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)

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

@@ -0,0 +1,196 @@
+---
+title: The Tuples
+localeTitle: Las Tuplas
+---
+## Las Tuplas
+
+Una tupla es una secuencia de objetos de Python. Las tuplas son inmutables, lo que significa que no se pueden modificar después de la creación, a diferencia de las listas.
+
+**Creación:**
+
+Se crea una `tuple` vacía utilizando un par de paréntesis, `()` :
+
+```shell
+    >>> empty_tuple = () 
+    >>> print(empty_tuple) 
+    () 
+    >>> type(empty_tuple) 
+    <class 'tuple'> 
+    >>> len(empty_tuple) 
+    0 
+```
+
+Se crea una `tuple` con elementos al separar los elementos con comas (los corchetes circundantes, `()` , son opcionales con excepciones):
+
+```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) 
+```
+
+Una `tuple` con un solo elemento debe tener una coma al final (con o sin paréntesis):
+
+```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'> 
+```
+
+Los paréntesis se requieren en casos de ambigüedad (si la tupla es parte de una expresión más grande):
+
+> Tenga en cuenta que en realidad es la coma la que forma una tupla, no los paréntesis. Los paréntesis son opcionales, excepto en el caso de la tupla vacía, o cuando son necesarios para evitar la ambigüedad sintáctica. Por ejemplo, `f(a, b, c)` es una llamada de función con tres argumentos, mientras que `f((a, b, c))` es una llamada de función con una tupla de 3 como ú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 
+```
+
+Una `tuple` también se puede crear con la `tuple` constructor:
+
+```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 
+```
+
+**Accediendo a los elementos de una `tuple` :**
+
+Se accede a los elementos de las `tuples` y se indexan de la misma manera que las `lists` .
+
+```shell
+    >>> my_tuple = 1, 2, 9, 16, 25 
+    >>> print(my_tuple) 
+    (1, 2, 9, 16, 25) 
+```
+
+_Cero indexado_
+
+```shell
+    >>> my_tuple[0] 
+    1 
+    >>> my_tuple[1] 
+    2 
+    >>> my_tuple[2] 
+    9 
+```
+
+_Envolver alrededor de la indexación_
+
+```shell
+    >>> my_tuple[-1] 
+    25 
+    >>> my_tuple[-2] 
+    16 
+```
+
+**Embalaje y desembalaje:**
+
+La declaración `t = 12345, 54321, 'hello!'` es un ejemplo de empaquetamiento de tuplas: los valores `12345` , `54321` y `'hello!'` se empaquetan juntos en una tupla. La operación inversa también es posible:
+
+```shell
+    >>> x, y, z = t 
+```
+
+Esto se denomina, apropiadamente, desempaquetado de secuencias y funciona para cualquier secuencia en el lado derecho. El desempaquetado de secuencias requiere que haya tantas variables en el lado izquierdo del signo igual como elementos en la secuencia. Tenga en cuenta que la asignación múltiple es solo una combinación de empaquetamiento de tuplas y desempaquetado de secuencias.
+
+```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) 
+```
+
+**Inmutable:**
+
+`tuples` son contenedores inmutables, garantizando **que los** objetos que contienen no cambien. Esto **no** garantiza que los objetos que contiene no cambiarán:
+
+```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:**
+
+Las funciones solo pueden devolver un solo valor, sin embargo, se puede usar una `tuple` heterogénea para devolver múltiples valores desde una función. Un ejemplo es la función de `enumerate` integrada que devuelve una iterable de `tuples` heterogéneas:
+
+```shell
+    >>> greeting = ["Hello", "campers!"] 
+    >>> enumerator = enumerate(greeting) 
+    >>> enumerator.next() 
+    >>> enumerator.__next__() 
+    (0, 'Hello') 
+    >>> enumerator.__next__() 
+    (1, 'campers!') 
+```
+
+### Más información:
+
+[Python Docs - Tuples](https://docs.python.org/3/library/stdtypes.html#tuples)