fix(guide): simplify directory structure

guide/spanish/python/lists/index.md

@@ -0,0 +1,124 @@
+---
+title: Lists
+localeTitle: Liza
+---
+**TODO: `list` información básica**
+
+[Python Docs - Listas](https://docs.python.org/3/library/stdtypes.html#lists)
+
+**Creación:**
+
+Una `list` vacía se crea utilizando un par de corchetes:
+
+```shell
+>>> empty_list = [] 
+ >>> type(empty_list) 
+ <class 'list'> 
+ >>> len(empty_list) 
+ 0 
+```
+
+Se puede crear una `list` con elementos encerrando una lista de elementos separados por comas entre corchetes. Las listas permiten que los elementos sean de diferentes tipos (heterogéneos), pero generalmente son de un solo tipo (homogéneos):
+
+```shell
+>>> homogeneous_list = [1, 1, 2, 3, 5, 8] 
+ >>> type(homogeneous_list) 
+ <class 'list'> 
+ >>> print(homogeneous_list) 
+ [1, 1, 2, 3, 5, 8] 
+ >>> len(homogeneous_list) 
+ 6 
+ >>> heterogeneous_list = [1, "Hello Campers!"] 
+ >>> print(heterogeneous_list) 
+ [1, "Hello Campers!"] 
+ >>> len(heterogeneous_list) 
+ 2 
+```
+
+El constructor de `list` también se puede utilizar para crear una `list` :
+
+```shell
+>>> empty_list = list()                            # Creates an empty list 
+ >>> print(empty_list) 
+ [] 
+ >>> list_from_iterable = list("Hello campers!")    # Creates a list from an iterable. 
+ >>> print(list_from_iterable) 
+ ['H', 'e', 'l', 'l', 'o', ' ', 'c', 'a', 'm', 'p', 'e', 'r', 's', '!'] 
+```
+
+**Accediendo a los elementos de una `list` :**
+
+```shell
+>>> my_list = [1, 2, 9, 16, 25] 
+ >>> print(my_list) 
+ [1, 2, 9, 16, 25] 
+```
+
+_Cero indexado_
+
+```shell
+>>> my_list[0] 
+ 1 
+ >>> my_list[1] 
+ 2 
+ >>> my_list[2] 
+ 9 
+```
+
+_Envolver alrededor de la indexación_
+
+```shell
+>>> my_list[-1] 
+ 25 
+ >>> my_list[-2] 
+ 16 
+```
+
+_Desembalaje de listas para python-3_
+
+```shell
+>>> print(*my_list) 
+ 1 2 9 16 25 
+```
+
+**Mudable:**
+
+`lists` son contenedores mutables. Los contenedores mutables son contenedores que permiten cambios en los objetos que contiene el contenedor. **TODO: AÑADIR MÁS?**
+
+_Reorganizar elementos en una lista._
+
+Los elementos de una `list` pueden extraerse y reorganizarse utilizando otra `list` como índice.
+
+```shell
+>>> my_list = [1, 2, 9, 16, 25, 34, 53, 21] 
+ >>> my_index = [5, 2, 0] 
+ >>> my_new_list = [my_list[i] for i in my_index] 
+ >>> print(my_new_list) 
+ [34, 9, 1] 
+```
+
+**TODO: ¿Cuál de estos debería ser discutido aquí?**
+
+[Python Docs - Más en las listas](https://docs.python.org/3/tutorial/datastructures.html#more-on-lists)
+
+*   `list.append(x)` Agrega un elemento al final de la lista. Equivalente a un \[len (a):\] = \[x\].
+    
+*   `list.extend(L)` Extienda la lista agregando todos los elementos en la lista dada. Equivalente a un \[len (a):\] = L.
+    
+*   `list.insert(i, x)` Insertar un elemento en una posición dada. El primer argumento es el índice del elemento antes del cual se inserta, por lo que a.insert (0, x) se inserta al principio de la lista, y a.insert (len (a), x) es equivalente a a.append ( X).
+    
+*   `list.remove(x)` Elimina el primer elemento de la lista cuyo valor es x. Es un error si no hay tal artículo.
+    
+*   `list.pop([i])` Elimine el elemento en la posición dada en la lista y devuélvalo. Si no se especifica ningún índice, a.pop () elimina y devuelve el último elemento de la lista. (Los corchetes alrededor de la i en la firma del método indican que el parámetro es opcional, no que se deben escribir corchetes en esa posición. Verá esta notación con frecuencia en la Referencia de la biblioteca de Python).
+    
+*   `list.clear()` Eliminar todos los elementos de la lista. Equivalente a del a \[:\].
+    
+*   `list.index(x)` Devuelve el índice en la lista del primer elemento cuyo valor es x. Es un error si no hay tal artículo.
+    
+*   `list.count(x)` Devuelve el número de veces que x aparece en la lista.
+    
+*   `list.sort(key=None, reverse=False)` Ordena los elementos de la lista en su lugar (los argumentos se pueden usar para la personalización de la clasificación, consulta ordenados () para su explicación).
+    
+*   `list.reverse()` Invierta los elementos de la lista en su lugar.
+    
+*   `list.copy()` Devuelve una copia superficial de la lista. Equivalente a un \[:\].

guide/spanish/python/lists/list-append-method/index.md

@@ -0,0 +1,26 @@
+---
+title: List Append Method
+localeTitle: Lista de añadir método
+---
+## Lista de añadir método
+
+Existen muchos métodos para listas, puede explorarlas todas escribiendo `help(list)` en su consola de Python. Una de ellas es la función de agregar que, como su nombre lo dice, adjunta el argumento de la lista.
+
+#### Ejemplo de uso
+
+```py
+words = ["I", "love", "Python"] 
+ words.append("very much") 
+ print(words) 
+```
+
+#### Salida
+```
+["I", "love", "Python", "very much"] 
+```
+
+Como habrán notado, el elemento `"very much"` se adjunta a la lista.
+
+#### Más información:
+
+La documentación oficial del `append()` se puede encontrar [aquí.](https://docs.python.org/3.6/tutorial/datastructures.html)

guide/spanish/python/lists/list-comprehension/index.md

@@ -0,0 +1,116 @@
+---
+title: List Comprehension
+localeTitle: Comprensión de lista
+---
+## Comprensión de lista
+
+La comprensión de lista es una forma de recorrer una lista para generar una nueva lista basada en algunas condiciones. Puede ser confuso al principio, pero una vez que se haya aclimatado a la sintaxis es muy potente y rápido.
+
+El primer paso para aprender a usar la comprensión de listas es observar la forma tradicional de recorrer una lista. El siguiente es un ejemplo simple que devuelve una nueva lista de números pares.
+
+```python
+# Example list for demonstration 
+ some_list = [1, 2, 5, 7, 8, 10] 
+ 
+ # Empty list that will be populate with a loop 
+ even_list = [] 
+ 
+ for number in some_list: 
+  if number % 2 == 0: 
+    even_list.append(number) 
+ 
+ # even_list now equals [2, 8, 10] 
+```
+
+Primero se crea una lista con algunos números. A continuación, crea una lista vacía que contendrá sus resultados del bucle. En el bucle, verifica si cada número es divisible por 2 y, si es así, lo agregas a la lista\_incluso. Esto tomó 5 líneas de código sin incluir comentarios y espacios en blanco, lo cual no es mucho en este ejemplo.
+
+Ahora para el ejemplo de la lista de comprensión.
+
+```python
+# Example list for demonstration 
+ some_list = [1, 2, 5, 7, 8, 10] 
+ 
+ # List Comprehension 
+ even_list = [number for number in some_list if number % 2 == 0] 
+ 
+ # even_list now equals [2, 8, 10] 
+```
+
+Otro ejemplo, con los mismos dos pasos: Lo siguiente creará una lista de números que corresponden a los números en `my_starting_list` multiplicados por 7.
+
+```py
+my_starting_list = [1, 2, 3, 4, 5, 6, 7, 8] 
+ my_new_list = [] 
+ 
+ for item in my_starting_list: 
+ my_new_list.append(item * 7) 
+```
+
+Cuando se ejecuta este código, el valor final de `my_new_list` es: `[7, 14, 21, 28, 35, 42, 49, 56]`
+
+Un desarrollador que usa la comprensión de la lista podría lograr el mismo resultado utilizando la siguiente comprensión de la lista, lo que da como resultado la misma `my_new_list` .
+
+```py
+my_starting_list = [1, 2, 3, 4, 5, 6, 7, 8] 
+ 
+ my_new_list = [item * 7 for item in my_starting_list] 
+```
+
+Una fórmula simple para escribir en una lista de comprensión es:
+
+`my_list = [{operation with input n} for n in {python iterable}]`
+
+Reemplace `{operation with input n}` con sin embargo, desea cambiar el elemento devuelto desde el iterable. El ejemplo anterior utiliza `n * 7` pero la operación puede ser tan simple o tan compleja como sea necesario.
+
+Reemplace `{python iterable}` con cualquier iterable. [Los tipos de secuencia](https://guide.freecodecamp.org/python/sequence-types) serán los más comunes. Se utilizó una lista en el ejemplo anterior, pero también son comunes las tuplas y los rangos.
+
+La comprensión de la lista agrega un elemento de una lista existente a una nueva lista si se cumple alguna condición. Es más ordenado, pero también es mucho más rápido en la mayoría de los casos. En algunos casos, la comprensión de la lista puede dificultar la legibilidad, por lo que el desarrollador debe sopesar sus opciones al elegir utilizar la comprensión de la lista.
+
+## Ejemplos de comprensión de lista con condicionales
+
+El flujo de control en las listas de comprensión se puede controlar usando condicionales. Por ejemplo:
+
+```py
+only_even_list = [i for i in range(13) if i%2==0] 
+```
+
+Esto es equivalente al siguiente bucle:
+
+```py
+only_even_list = list() 
+ for i in range(13): 
+  if i%2 == 0: 
+    only_even_list.append(i) 
+```
+
+Lista de comprensión también puede contener anidada si las condiciones. Considere el siguiente bucle:
+
+```py
+divisible = list() 
+ for i in range(50): 
+  if i%2 == 0: 
+    if i%3 == 0: 
+      divisible.append(i) 
+```
+
+Usando la lista de comprensión esto se puede escribir como:
+
+```py
+divisible = [i for i in range(50) if i%2==0 if i%3==0] 
+```
+
+La instrucción If-Else también se puede utilizar junto con la comprensión de la lista.
+
+```py
+list_1 = [i if i%2==0 else i*-1 for i in range(10)] 
+```
+
+#### Más información:
+
+[Estructuras de datos Python - Listas](https://docs.python.org/2.7/tutorial/datastructures.html)
+
+[Python For Loops](https://guide.freecodecamp.org/python/for-loop-statements)
+
+[Listas de Python](https://guide.freecodecamp.org/python/learn-about-python-lists)
+
+[Python para principiantes - List Comprehensions](http://www.pythonforbeginners.com/basics/list-comprehensions-in-python)

guide/spanish/python/lists/list-extend-method/index.md

@@ -0,0 +1,25 @@
+---
+title: List Extend Method
+localeTitle: Método de ampliación de lista
+---
+## Método de ampliación de lista
+
+Existen muchos métodos para listas, puede explorarlas todas escribiendo `help(list)` en su consola de Python. Una de ellas es la función de extensión que, como su nombre lo dice, extiende la lista al agregar todos los elementos de una lista (que se pasa como argumento) al final.
+
+#### Ejemplo de uso
+
+```py
+cities = ["San Francisco", "Los Angeles", "New York"] 
+ cities_in_texas = ["San Antonio", "Austin", "Dallas"] 
+ cities.extend(cities_in_texas) 
+ print(cities) 
+```
+
+#### Salida
+```
+["San Francisco", "Los Angeles", "New York", "San Antonio", "Austin", "Dallas"] 
+```
+
+#### Más información:
+
+La documentación oficial de `extend()` se puede encontrar [aquí.](https://docs.python.org/3.6/tutorial/datastructures.html)

guide/spanish/python/lists/list-index-method/index.md

@@ -0,0 +1,59 @@
+---
+title: List Index Method
+localeTitle: Método de índice de lista
+---
+## Método de índice de lista
+
+Entre las muchas funciones que vienen junto con la estructura de datos de la lista, el `index()` devuelve la primera aparición / índice del elemento en la lista dada como un argumento a la función.
+
+Las listas son la estructura de datos de Python más básica y almacenan una lista de valores en orden (en comparación con los diccionarios, el orden no importa). Recuperamos los artículos por índice numérico.
+
+Teniendo en cuenta el hecho de que la indexación comienza desde 0, o se considera que el primer elemento se encuentra en el índice 0, veamos algunos ejemplos.
+
+#### Ejemplo de uso:
+
+```py
+numbers = [1, 2, 2, 3, 9, 5, 6, 10] 
+ words = ["I", "love", "Python", "I", "love"] 
+ 
+ print(numbers.index(9)) 
+ print(numbers.index(2)) 
+ print(words.index("I")) 
+ print(words.index("am")) 
+```
+
+##### Salida:
+
+```py
+4 
+ 1 
+ 0 
+ Traceback (most recent call last): 
+  File "<stdin>", line 1, in <module> 
+ ValueError: 'am' is not in list 
+```
+
+Aquí la primera salida es muy obvia, pero la segunda y la tercera pueden parecer confusas al principio. Pero recuerda que `index()` devuelve la primera aparición del elemento y, por lo tanto, en este caso `1` y `0` son los índices donde `2` y `"I"` aparecen primero en las listas respectivamente.
+
+Además, si un elemento no se encuentra en la lista, se devuelve un `ValueError` como en el caso de la indexación `"am"` en la lista de `words` .
+
+#### Argumentos opcionales:
+
+También puede usar argumentos opcionales para limitar su búsqueda a una subsecuencia particular de la lista como se ilustra en este ejemplo:
+
+```py
+words = ["I","am", "a", "I", "am", "Pythonista"] 
+ 
+ print(words.index("am",2,5)) 
+```
+
+##### Salida:
+```
+4 
+```
+
+Aquí, aunque el elemento se busca entre los índices 2 (inclusive) y 5 (no incluido), el índice devuelto se calcula en relación con el principio de la lista completa en lugar del argumento de inicio.
+
+#### Más información:
+
+La documentación oficial de `index()` se puede encontrar [aquí.](https://docs.python.org/3.6/tutorial/datastructures.html)

guide/spanish/python/lists/list-map-filter-reduce/index.md

@@ -0,0 +1,88 @@
+---
+title: Map, Reduce, Filter
+localeTitle: Mapa, Reducir, Filtrar
+---
+# Mapa, Reducir y Filtrar
+
+La mayoría de los ingenieros trabajan con listas para procesar la lista de pedidos / usuarios, etc. El análisis de las listas puede complicarse y desordenarse rápidamente si se usan varios bucles for y loops anidados. Por lo tanto, estos métodos anteriores pueden simplificar el uso de las operaciones de lista.
+
+## Mapa
+
+Si su tarea es aplicar un método específico a cada elemento de una lista, el mapa será útil. Supongamos que tiene una lista de valores de grado y desea convertir todos estos valores en una lista de valores en unidades Fahrenheit.
+
+#### Ejemplo de uso
+
+```py
+inputs = [10,32,5,40,25] 
+ 
+ def degreesToFahren(deg): 
+    fahrenheit = (9.0/5)*deg +32 
+    return fahrenheit 
+ 
+ # The most common way of doing this 
+ result=[] 
+ for i in inputs: 
+    iTofahren = degreesToFahren(i) 
+    result.append(iTofahren) 
+ print(result)   # [50.0, 89.6, 41.0, 104.0, 77.0] 
+```
+
+```py
+# Using Map 
+ result = list(map(degreesToFahren,inputs)) 
+ print(result) # [50.0, 89.6, 41.0, 104.0, 77.0] 
+```
+
+Como habrás notado, el uso de mapas es simplemente una operación de una sola línea. Generalmente, si tiene datos = `[a1,a2,...,an]` y una función `f()` , entonces `map(f,data):` devuelve un iterador sobre `f(a1),f(a2)...f(an).` use `list()` para convertir el objeto iterador en una lista de python.
+
+## Filtrar
+
+La función de filtro elimina los datos de una lista que necesita / no necesita, de ahí el nombre. Supongamos que desea filtrar una lista según los valores que no necesita, por ejemplo, valores superiores a 2.
+
+#### Ejemplo de uso
+
+```py
+data = [1.2,2.5,5.8,0.4,4.7,9.9] 
+ result = list(filter(lambda x:x > 2,data)) 
+ print(result) 
+```
+
+#### Salida
+```
+[2.5, 5.8, 4.7, 9.9] 
+```
+
+Este también es un simple 1 liner similar a la función map () anterior. Consulte el tutorial sobre las funciones de lambda si encuentra este término desconocido.
+
+## Reducir
+
+Del creador de Python, Guido van Rossum. `"Use functools.reduce if you really need it; however, 99% of the time an explicit for loop is more readable"`
+
+Lo que generalmente hace es aplicar una función `f()` a elementos de datos en una lista y usar ese resultado para el siguiente valor en la lista. Visualmente,
+
+Datos = \[a 1 , a 2 ,…, a n \] función = f (x, y)
+
+reducir (f, datos): Paso 1: val 1 = f (a 1 , a 2 ) Paso 2: val 2 = f (val 1 , a 3 ) Paso 3: val 3 = f (val 2 , a 4 ) . . . Paso n-1: val n-1 = f (val n-2 , a n )
+
+Por ejemplo, usted quiere multiplicar todos los números en una lista.
+
+#### Ejemplo de uso
+
+```py
+from functools import reduce 
+ 
+ input = [1,2,3,4,5,6] 
+ multiplier = lambda x,y:x*y 
+ answer = reduce(multiplier,input) 
+ print(answer) 
+```
+
+#### Salida
+```
+720 
+```
+
+Sin embargo, lo anterior podría calcularse utilizando un bucle simple y el uso de estos métodos está sujeto a preferencias.
+
+#### Más información:
+

guide/spanish/python/lists/list-pop/index.md

@@ -0,0 +1,31 @@
+---
+title: List Pop Method
+localeTitle: Método de lista pop
+---
+# Función pop
+
+El método pop () elimina y devuelve el último elemento de la lista. Hay un parámetro opcional, índice del elemento que se eliminará de la lista. Si no se especifica ningún índice, a.pop () elimina y devuelve el último elemento de la lista. Si el índice pasado al método pop () no está en el rango, arroja IndexError: el índice de pop fuera de la excepción de rango.
+
+#### Ejemplo de uso
+
+\`\` \`py ciudades = \['Nueva York', 'Dallas', 'San Antonio', 'Houston', 'San Francisco'\];
+
+Imprimir "Ciudad emergida es:", cities.pop () Imprimir "Ciudad en el índice 2 es:", cities.pop (2) \`\` \`
+
+\#### Salida `City popped is : San Francisco City at index 2 is : San Antonio`
+
+#### Funcionalidad de pila básica
+
+El método `pop()` se usa a menudo junto con `append()` para implementar la funcionalidad de pila básica en una aplicación Python.
+
+```py
+stack = [] 
+ 
+ for i in range(5): 
+    stack.append(i) 
+ 
+ while len(stack): 
+    print(stack.pop()) 
+```
+
+\#### Más información: La documentación oficial de `pop()` se puede encontrar [aquí.](https://docs.python.org/3.6/tutorial/datastructures.html)

guide/spanish/python/lists/list-remove-method/index.md

@@ -0,0 +1,40 @@
+---
+title: List Remove Method
+localeTitle: Método de eliminación de lista
+---
+## Método de eliminación de lista
+
+El método `remove()` elimina el argumento dado a él de la lista.
+
+#### Ejemplo de uso
+
+```py
+words = ["I", "love", "Python"] 
+ words.remove("I") 
+ print(words) 
+```
+
+#### Salida
+
+```py
+["love","Python"] 
+```
+
+Tenga en cuenta que devuelve un error si el elemento que se va a eliminar no se encuentra en la lista, como se ilustra en el siguiente ejemplo.
+
+```py
+kiss = ["keep", "it", "simple", "stupid"] 
+ kiss.remove("complex") 
+ print(kiss) 
+```
+
+#### Salida
+```
+Traceback (most recent call last): 
+  File "<stdin>", line 1, in <module> 
+ ValueError: list.remove(x): x not in list 
+```
+
+#### Más información:
+
+Más información sobre `remove()` se puede encontrar [aquí](https://docs.python.org/3.6/tutorial/datastructures.html)

guide/spanish/python/lists/list-sort-method/index.md

@@ -0,0 +1,109 @@
+---
+title: List Sort Method
+localeTitle: Método de clasificación de lista
+---
+## Método de clasificación de lista
+
+Las listas de Python tienen un método `sort()` incorporado que modifica la lista en el lugar y una función incorporada `sorted()` que construye una nueva lista ordenada a partir de una iterable.
+
+list.sort (key =…, reverse = \[True / False\])
+
+### Parámetros
+
+Hay dos parámetros opcionales para este método. _clave_ : el valor de entrada para el parámetro clave debe ser una función que tome un solo argumento y devuelva un valor utilizado para las comparaciones para ordenar los elementos de la lista _revertir = \[valor\]_ _valor = Verdadero_ : ordena los elementos de la lista en orden descendente _valor = falso_ : ordena los elementos de la lista en orden ascendente. Esto se considera el valor predeterminado. Tenga en cuenta que el método `sort()` no devuelve ningún valor. Modifica la lista original.
+
+### Ejemplo de uso
+
+```py
+a = [4, 2, 5, 3, 1] 
+ a.sort() 
+ print a # prints [1, 2, 3, 4, 5] 
+ 
+ b = ['free', 'code', 'camp'] 
+ b.sort() 
+ print b # prints ['camp', 'code', 'free'] 
+```
+
+Considere un ejemplo con el parámetro **inverso**
+
+```py
+a = [4, 2, 5, 3, 1] 
+ 
+ #Sorts the list in descending order 
+ a.sort(reverse=True) 
+ 
+ print a # prints [5, 4, 3, 2, 1] 
+```
+
+Si desea ordenar la lista en función de su propia función, utilice el parámetro **clave** . Aquí hay un ejemplo para ordenar las cadenas en la lista por longitud, en orden ascendente
+
+```py
+a = ["hello", "hi", "hey"] 
+ 
+ #The built-in len() function is given as an input to key parameter to sort the strings by length 
+ a.sort(key = len) 
+ 
+ print a # prints ['hi', 'hey', 'hello'] 
+```
+
+Aquí hay otro ejemplo, donde la lista contiene tuplas (nombre, edad). El uso a continuación muestra cómo ordenar la lista por edad, en orden ascendente.
+
+```py
+#Consider the second element in the tuple for sorting 
+ >>> def compareByAge(element): 
+ ...     return element[1] 
+ 
+ b = [('Adam', 20), ('Rahman', 30), ('Rahul', 25)] 
+ 
+ #Sort the list by age 
+ b.sort(key = compareByAge) 
+ 
+ #Output 
+ print b # prints [('Adam', 20), ('Rahul', 25), ('Rahman', 30)] 
+```
+
+### Conceptos básicos de clasificación
+
+Una ordenación ascendente simple es muy fácil, simplemente llame a la función ordenada (). Devuelve una nueva lista ordenada:
+
+```python
+>>> sorted([5, 2, 3, 1, 4]) 
+ [1, 2, 3, 4, 5] 
+```
+
+También puede utilizar el método list.sort () de una lista. Modifica la lista en el lugar (y devuelve Ninguno para evitar confusiones). Por lo general, es menos conveniente que el ordenado (), pero si no necesita la lista original, es un poco más eficiente.
+
+```python
+>>> a = [5, 2, 3, 1, 4] 
+ >>> a.sort() 
+ >>> a 
+ [1, 2, 3, 4, 5] 
+```
+
+Otra diferencia es que el método list.sort () solo se define para listas. En contraste, la función ordenada () acepta cualquier iterable.
+
+```python
+>>> sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'}) 
+ [1, 2, 3, 4, 5] 
+```
+
+#### Detalles de implementacion
+
+Si desea conocer detalles sobre la implementación de la función de clasificación, el algoritmo y la complejidad del tiempo, etc., consulte [aquí](http://svn.python.org/projects/python/trunk/Objects/listsort.txt) . En resumen, la función de clasificación utiliza el algoritmo TimSort, que según Python Developers es:
+
+> una combinación adaptativa, estable y natural, llamada modestamente timsort (hey, me lo gané ). Tiene un rendimiento sobrenatural en muchos tipos de arreglos ordenados parcialmente (se necesitan menos de lg (N!) comparaciones, y tan pocos como N-1), pero tan rápido como el sampleort altamente afinado anterior de Python híbrido en matrices aleatorias.
+
+#### ordenar () Parámetros
+
+Por defecto, sort () no requiere ningún parámetro extra. Sin embargo, tiene dos parámetros opcionales:
+
+*   Invertir: si es verdadero, la lista ordenada se invierte (o se ordena en orden descendente)
+*   tecla - función que sirve como una tecla para la comparación de ordenación
+
+#### Más información:
+
+Más información sobre `sort()` se puede encontrar [aquí](https://docs.python.org/3/library/functions.html#sorted)
+
+Puede encontrar más información sobre sort () y sorted () [aquí.](https://docs.python.org/3.6/tutorial/datastructures.html)
+
+Más información sobre sort () y sorted () se puede encontrar [aquí](https://docs.python.org/3.6/tutorial/datastructures.html) .